plane_3d.hpp

#pragma once
 
#include <cmath>
 
#include "global.hpp"
 
#include "point_3d.hpp"
#include "affine_matrix_3d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  class Plane3D final
  {
  public:

    Plane3D() noexcept = default;


    Plane3D(double nx, double ny, double nz, double distanceToOrigin) noexcept
        : normal_{nx, ny, nz}
        , distanceToOrigin_{distanceToOrigin}
    {
    }
    Plane3D(double nx, double ny, double nz, double distanceToOrigin) noexcept {…}


    Plane3D(Point3D<double> normal, double distanceToOrigin) noexcept
        : normal_{normal}
        , distanceToOrigin_{distanceToOrigin}
    {
    }
    Plane3D(Point3D<double> normal, double distanceToOrigin) noexcept {…}


    Point3D<double> Normal() const noexcept
    {
      return normal_;
    }
    Point3D<double> Normal() const noexcept {…}


    void SetNormal(Point3D<double> normal) noexcept
    {
      normal_ = normal;
    }
    void SetNormal(Point3D<double> normal) noexcept {…}


    double DistanceToOrigin() const noexcept
    {
      return distanceToOrigin_;
    }
    double DistanceToOrigin() const noexcept {…}


    void SetDistanceToOrigin(double distanceToOrigin) noexcept
    {
      distanceToOrigin_ = distanceToOrigin;
    }
    void SetDistanceToOrigin(double distanceToOrigin) noexcept {…}


    double DistanceToPoint(const Point3D<double> &pt) const noexcept
    {
      return DistanceToPoint(pt.X(), pt.Y(), pt.Z());
    }
    double DistanceToPoint(const Point3D<double> &pt) const noexcept {…}


    double DistanceToPoint(double x, double y, double z) const noexcept
    {
      auto normal = normal_ / normal_.Length();
      return std::abs(normal.X() * x + normal.Y() * y + normal.Z() * z - distanceToOrigin_);
    }
    double DistanceToPoint(double x, double y, double z) const noexcept {…}


    AffineMatrix3D AlignToXYPlane()
    {
      return Internal::DoResCallValueOut<AffineMatrix3D>([&](AffineMatrix3D &value) {
        auto valueData = reinterpret_cast<CExports::CVC3DTransformation *>(&value);
 
        return CVB_CALL_CAPI(CVC3DAlignToXYPlane(*reinterpret_cast<const CExports::CVC3DPlane *>(this), *valueData));
      });
    }
    AffineMatrix3D AlignToXYPlane() {…}


    bool operator==(const Plane3D &plane) const noexcept
    {
      return (normal_ == plane.normal_ && distanceToOrigin_ == plane.distanceToOrigin_);
    }
    bool operator==(const Plane3D &plane) const noexcept {…}


    bool operator!=(const Plane3D &plane) const noexcept
    {
      return !(*this == plane);
    }
    bool operator!=(const Plane3D &plane) const noexcept {…}
 
  private:
    Point3D<double> normal_{0.0, 0.0, 0.0};
    double distanceToOrigin_ = 0.0;
  };
  class Plane3D final {…};
 
  CVB_END_INLINE_NS
}  // namespace Cvb