MDPlane.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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 "MantidGeometry/MDGeometry/MDTypes.h"
#include "MantidKernel/VMD.h"
#include <vector>
 
namespace Mantid {
namespace Geometry {
 
class MANTID_GEOMETRY_DLL MDPlane {
public:
  MDPlane(const Mantid::Kernel::VMD &normal, const Mantid::Kernel::VMD &point);
  MDPlane(const std::vector<coord_t> &normal, const std::vector<coord_t> &point);
  MDPlane(const size_t nd, const float *normal, const float *point);
  MDPlane(const size_t nd, const double *normal, const double *point);
  MDPlane(const std::vector<Mantid::Kernel::VMD> &vectors, const Mantid::Kernel::VMD &origin,
          const Mantid::Kernel::VMD &insidePoint);
  MDPlane(const MDPlane &other);
  MDPlane &operator=(const MDPlane &other);
  ~MDPlane();
 
  size_t getNumDims() const { return m_nd; }
 
  const coord_t *getNormal() const { return m_normal; }
 
  coord_t getInequality() const { return m_inequality; }
 
  // ==================== Methods that are inline for performance
  // ================================
  //----------------------------------------------------------------------------------------------
  inline bool isPointBounded(const coord_t *coords) const {
    coord_t total = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      total += m_normal[d] * coords[d];
    }
    return (total >= m_inequality);
  }
 
  //----------------------------------------------------------------------------------------------
  inline bool isPointBounded(const Mantid::Kernel::VMD &coords) const {
    coord_t total = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      total += m_normal[d] * static_cast<coord_t>(coords[d]);
    }
    return (total >= m_inequality);
  }
 
  //----------------------------------------------------------------------------------------------
  inline bool isPointBounded(const std::vector<coord_t> &coords) const {
    coord_t total = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      total += m_normal[d] * coords[d];
    }
    return (total >= m_inequality);
  }
 
  //----------------------------------------------------------------------------------------------
  inline bool isPointInside(const coord_t *coords) const {
    coord_t total = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      total += m_normal[d] * coords[d];
    }
    return (total > m_inequality);
  }
 
  //----------------------------------------------------------------------------------------------
  inline bool isPointInside(const std::vector<coord_t> &coords) const {
    coord_t total = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      total += m_normal[d] * coords[d];
    }
    return (total > m_inequality);
  }
 
  //----------------------------------------------------------------------------------------------
  bool doesLineIntersect(const coord_t *pointA, const coord_t *pointB) const {
    bool AisBounded = isPointBounded(pointA);
    bool BisBounded = isPointBounded(pointB);
    // The line crosses the plane if one point is bounded and not the other.
    // Simple! :)
    return (AisBounded != BisBounded);
  }
 
private:
  //----------------------------------------------------------------------------------------------
  template <typename IterableType> void construct(IterableType normal, IterableType point) {
    m_normal = new coord_t[m_nd];
    m_inequality = 0;
    for (size_t d = 0; d < m_nd; ++d) {
      m_normal[d] = static_cast<coord_t>(normal[d]);
      m_inequality += static_cast<coord_t>(point[d]) * m_normal[d];
    }
  }
 
protected:
  size_t m_nd;
 
  coord_t *m_normal;
 
  coord_t m_inequality;
};
 
} // namespace Geometry
} // namespace Mantid