CPlane3d.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <i3d/CVector3d.h>
 
 
namespace i3d
{
 
 
class CPlane3d
{
public:
       CPlane3d();
       
       CPlane3d(const CVector3d& point, const CVector3d& normal);
       
       CPlane3d(const CVector3d& p1, const CVector3d& p2, const CVector3d& p3);
       
       const CVector3d& GetPoint() const;
       
       void SetPoint(const CVector3d& point);
       
       const CVector3d& GetNormal() const;
       
       void SetNormal(const CVector3d& normal);
       
       double GetSignedDistance(const CVector3d& point) const;
       
       double GetDistance(const CVector3d& point) const;
       
       CVector3d GetProjection(const CVector3d& point) const;
       
       bool Contains(const CVector3d& point, double tolerance = I_BIG_EPSILON) const;
       
       bool Serialize(iser::IArchive& archive);
       
       bool operator==(const CPlane3d& plane) const;
       bool operator!=(const CPlane3d& plane) const;
 
private:
       CVector3d m_point;          
       CVector3d m_normal;         
};
 
 
// inline methods
 
inline CPlane3d::CPlane3d()
:      m_point(0.0, 0.0, 0.0)
,      m_normal(0.0, 0.0, 1.0)
{
}
 
 
inline CPlane3d::CPlane3d(const CVector3d& point, const CVector3d& normal)
:      m_point(point)
,      m_normal(normal.GetNormalized())
{
}
 
 
inline const CVector3d& CPlane3d::GetPoint() const
{
       return m_point;
}
 
 
inline void CPlane3d::SetPoint(const CVector3d& point)
{
       m_point = point;
}
 
 
inline const CVector3d& CPlane3d::GetNormal() const
{
       return m_normal;
}
 
 
inline void CPlane3d::SetNormal(const CVector3d& normal)
{
       m_normal = normal.GetNormalized();
}
 
 
inline double CPlane3d::GetSignedDistance(const CVector3d& point) const
{
       return m_normal.GetDotProduct(point - m_point);
}
 
 
inline double CPlane3d::GetDistance(const CVector3d& point) const
{
       return qAbs(GetSignedDistance(point));
}
 
 
inline CVector3d CPlane3d::GetProjection(const CVector3d& point) const
{
       double distance = GetSignedDistance(point);
       return point - m_normal * distance;
}
 
 
inline bool CPlane3d::Contains(const CVector3d& point, double tolerance) const
{
       return GetDistance(point) < tolerance;
}
 
 
inline bool CPlane3d::operator==(const CPlane3d& plane) const
{
       return m_point == plane.m_point && m_normal == plane.m_normal;
}
 
 
inline bool CPlane3d::operator!=(const CPlane3d& plane) const
{
       return !(*this == plane);
}
 
 
} // namespace i3d