Class BoundingBox

c++/include/orc/Geospatial.hh:69–181

BoundingBox represents the minimum bounding rectangle (or box) for a geometry. It supports up to 4 dimensions (X, Y, Z, M).

  // BoundingBox represents the minimum bounding rectangle (or box) for a geometry.
  // It supports up to 4 dimensions (X, Y, Z, M).
  struct BoundingBox {
    using XY = std::array<double, 2>;
    using XYZ = std::array<double, 3>;
    using XYM = std::array<double, 3>;
    using XYZM = std::array<double, 4>;

    // Default constructor: initializes to an empty bounding box.
    BoundingBox() : min{INF, INF, INF, INF}, max{-INF, -INF, -INF, -INF} {}
    // Constructor with explicit min/max values.
    BoundingBox(const XYZM& mins, const XYZM& maxes) : min(mins), max(maxes) {}
    BoundingBox(const BoundingBox& other) = default;
    BoundingBox& operator=(const BoundingBox&) = default;

    // Update the bounding box to include a 2D coordinate.
    void updateXY(const XY& coord) {
      updateInternal(coord);
    }
    // Update the bounding box to include a 3D coordinate (XYZ).
    void updateXYZ(const XYZ& coord) {
      updateInternal(coord);
    }
    // Update the bounding box to include a 3D coordinate (XYM).
    void updateXYM(const XYM& coord) {
      std::array<int, 3> dims = {0, 1, 3};
      for (int i = 0; i < 3; ++i) {
        auto dim = dims[i];
        if (!std::isnan(min[dim]) && !std::isnan(max[dim])) {
          min[dim] = std::min(min[dim], coord[i]);
          max[dim] = std::max(max[dim], coord[i]);
        }
      }
    }
    // Update the bounding box to include a 4D coordinate (XYZM).
    void updateXYZM(const XYZM& coord) {
      updateInternal(coord);
    }

    // Reset the bounding box to its initial empty state.
    void reset() {
      for (int i = 0; i < MAX_DIMENSIONS; ++i) {
        min[i] = INF;
        max[i] = -INF;
      }
    }

    // Invalidate the bounding box (set all values to NaN).
    void invalidate() {
      for (int i = 0; i < MAX_DIMENSIONS; ++i) {
        min[i] = std::numeric_limits<double>::quiet_NaN();
        max[i] = std::numeric_limits<double>::quiet_NaN();
      }
    }

    // Check if the bound for a given dimension is empty.
    bool boundEmpty(int dim) const {
      return std::isinf(min[dim] - max[dim]);
    }