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(Point3D<double> normal, double distanceToOrigin) noexcept
      : normal_{normal}, distanceToOrigin_{distanceToOrigin}
  {
  }
 
 
  Point3D<double> Normal() const noexcept { return normal_; }
 
 
  void SetNormal(Point3D<double> normal) noexcept { normal_ = normal; }
 
 
  double DistanceToOrigin() const noexcept { return distanceToOrigin_; }
 
 
  void SetDistanceToOrigin(double distanceToOrigin) noexcept { distanceToOrigin_ = distanceToOrigin; }
 
 
  double DistanceToPoint(const Point3D<double> &pt) const noexcept { return DistanceToPoint(pt.X(), pt.Y(), pt.Z()); }
 
 
  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_);
  }
 
 
  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));
      });
 
  }
 
private:
  Point3D<double> normal_{0.0, 0.0, 0.0};
  double distanceToOrigin_ = 0.0;
};
 
CVB_END_INLINE_NS
}