Quadrilateral.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
 
//------------------------------------------------------------------------------
// Includes
//------------------------------------------------------------------------------
#include "MantidGeometry/Math/ConvexPolygon.h"
#include "MantidKernel/V2D.h"
#include <array>
 
namespace Mantid {
namespace Geometry {
 
class MANTID_GEOMETRY_DLL Quadrilateral final : public ConvexPolygon {
public:
  Quadrilateral(const Kernel::V2D &lowerLeft, const Kernel::V2D &lowerRight, const Kernel::V2D &upperRight,
                const Kernel::V2D &upperLeft);
  Quadrilateral(const double lowerX, const double upperX, const double lowerY, const double upperY);
  Quadrilateral(Quadrilateral &&) = default;
  Quadrilateral &operator=(Quadrilateral &&) = default;
  Quadrilateral(const Quadrilateral &) = default;
  Quadrilateral &operator=(const Quadrilateral &) = default;
 
  inline const Kernel::V2D &operator[](const size_t index) const override { return m_vertices[index]; };
  const Kernel::V2D &at(const size_t index) const override;
  inline size_t npoints() const override { return 4; }
  bool contains(const Kernel::V2D &point) const override;
  bool contains(const ConvexPolygon &poly) const override;
  inline double area() const override {
    const double lhs = lowerLeft().Y() * upperLeft().X() + upperLeft().Y() * upperRight().X() +
                       upperRight().Y() * lowerRight().X() + lowerRight().Y() * lowerLeft().X();
    const double rhs = lowerLeft().X() * upperLeft().Y() + upperLeft().X() * upperRight().Y() +
                       upperRight().X() * lowerRight().Y() + lowerRight().X() * lowerLeft().Y();
    return 0.5 * (lhs - rhs);
  }
 
  inline double determinant() const override { return 2.0 * area(); }
  inline double minX() const override { return std::min(lowerLeft().X(), upperLeft().X()); }
  inline double maxX() const override { return std::max(lowerRight().X(), upperRight().X()); }
  inline double minY() const override { return std::min(lowerLeft().Y(), lowerRight().Y()); }
  inline double maxY() const override { return std::max(upperLeft().Y(), upperRight().Y()); }
  ConvexPolygon toPoly() const override;
  virtual void shiftVertexesClockwise();
 
private:
  inline const Kernel::V2D &lowerLeft() const { return m_vertices[0]; }
  inline const Kernel::V2D &upperLeft() const { return m_vertices[1]; }
  inline const Kernel::V2D &upperRight() const { return m_vertices[2]; }
  inline const Kernel::V2D &lowerRight() const { return m_vertices[3]; }
 
  // Order=ll,ul,ur,lr
  std::array<Kernel::V2D, 4> m_vertices;
};
 
} // namespace Geometry
} // namespace Mantid