BoundingBox.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidGeometry/DllConfig.h"
#include "MantidKernel/V3D.h"
#ifndef Q_MOC_RUN
#include <memory>
#endif
#include <sstream>
 
namespace Mantid {
namespace Geometry {
 
//-------------------------------------------------------------------------
// Forward declarations
//-------------------------------------------------------------------------
class Track;
 
class MANTID_GEOMETRY_DLL BoundingBox {
public:
  BoundingBox() : m_minPoint(), m_maxPoint(), m_null(true), is_axis_aligned(true) {}
 
  BoundingBox(double xmax, double ymax, double zmax, double xmin, double ymin, double zmin)
      : m_minPoint(xmin, ymin, zmin), m_maxPoint(xmax, ymax, zmax), m_null(false), is_axis_aligned(true) {
    // Sanity check
    checkValid(xmax, ymax, zmax, xmin, ymin, zmin);
  }
 
  static void checkValid(double xmax, double ymax, double zmax, double xmin, double ymin, double zmin) {
    if (xmax < xmin || ymax < ymin || zmax < zmin) {
      std::ostringstream error;
      error << "Error creating bounding box, inconsistent values given:\n"
            << "\txmin=" << xmin << ", xmax=" << xmax << "\n"
            << "\tymin=" << ymin << ", ymax=" << ymax << "\n"
            << "\tzmin=" << zmin << ", zmax=" << zmax << "\n";
      throw std::invalid_argument(error.str());
    }
  }
 
  inline double xMin() const { return m_minPoint.X(); }
  inline double xMax() const { return m_maxPoint.X(); }
  inline double yMin() const { return m_minPoint.Y(); }
  inline double yMax() const { return m_maxPoint.Y(); }
  inline double zMin() const { return m_minPoint.Z(); }
  inline double zMax() const { return m_maxPoint.Z(); }
  inline const Kernel::V3D &minPoint() const { return m_minPoint; }
  inline const Kernel::V3D &maxPoint() const { return m_maxPoint; }
  inline Kernel::V3D centrePoint() const {
    return Kernel::V3D(0.5 * (xMax() + xMin()), 0.5 * (yMax() + yMin()), 0.5 * (zMax() + zMin()));
  }
  inline Kernel::V3D width() const { return Kernel::V3D(m_maxPoint - m_minPoint); }
 
  inline bool isNull() const { return m_null; }
  inline bool isNonNull() const { return !m_null; }
  bool isPointInside(const Kernel::V3D &point) const;
  bool doesLineIntersect(const Track &track) const;
  bool doesLineIntersect(const Kernel::V3D &startPoint, const Kernel::V3D &lineDir) const;
  double angularWidth(const Kernel::V3D &observer) const;
  inline bool isAxisAligned() const { return is_axis_aligned; }
  std::vector<Kernel::V3D> const &getCoordSystem() const { return coord_system; }
 
  Kernel::V3D generatePointInside(double r1, double r2, double r3) const;
  void getFullBox(std::vector<Kernel::V3D> &box, const Kernel::V3D &observer) const;
  inline double &xMin() {
    m_null = false;
    return m_minPoint[0];
  }
  inline double &xMax() {
    m_null = false;
    return m_maxPoint[0];
  }
  inline double &yMin() {
    m_null = false;
    return m_minPoint[1];
  }
  inline double &yMax() {
    m_null = false;
    return m_maxPoint[1];
  }
  inline double &zMin() {
    m_null = false;
    return m_minPoint[2];
  }
  inline double &zMax() {
    m_null = false;
    return m_maxPoint[2];
  }
  void grow(const BoundingBox &other);
  void setBoxAlignment(const Kernel::V3D &R0, const std::vector<Kernel::V3D> &orts);
  void nullify();
  void realign(std::vector<Kernel::V3D> const *const pCS = nullptr);
  void moveBy(const Kernel::V3D &v) {
    m_minPoint += v;
    m_maxPoint += v;
  }
 
private:
  Kernel::V3D m_minPoint;
  Kernel::V3D m_maxPoint;
  bool m_null;
  bool is_axis_aligned;
  std::vector<Kernel::V3D> coord_system;
};
 
using BoundingBox_sptr = std::shared_ptr<BoundingBox>;
using BoundingBox_const_sptr = std::shared_ptr<const BoundingBox>;
 
MANTID_GEOMETRY_DLL std::ostream &operator<<(std::ostream &os, const BoundingBox &box);
} // namespace Geometry
} // namespace Mantid