CSphere.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 CLine3d;
 
 
class CSphere
{
public:
       CSphere();
       
       CSphere(double radius, const CVector3d& center);
       
       double GetRadius() const;
       
       void SetRadius(double radius);
       
       const CVector3d& GetCenter() const;
       
       void SetCenter(const CVector3d& center);
       
       double GetVolume() const;
       
       double GetSurfaceArea() const;
       
       bool Contains(const CVector3d& point, double tolerance = 0.0) const;
       
       bool Intersects(const CSphere& other) const;
       
       bool Intersects(const CLine3d& line) const;
       
       double GetSignedDistance(const CVector3d& point) const;
       
       CVector3d GetClosestPoint(const CVector3d& point) const;
       
       bool Serialize(iser::IArchive& archive);
       
       bool operator==(const CSphere& sphere) const;
       bool operator!=(const CSphere& sphere) const;
 
private:
       CVector3d m_center;         
       double m_radius;            
};
 
 
// inline methods
 
inline CSphere::CSphere()
:      m_center(0.0, 0.0, 0.0)
,      m_radius(1.0)
{
}
 
 
inline CSphere::CSphere(double radius, const CVector3d& center)
:      m_center(center)
,      m_radius(radius)
{
}
 
 
inline double CSphere::GetRadius() const
{
       return m_radius;
}
 
 
inline void CSphere::SetRadius(double radius)
{
       m_radius = radius;
}
 
 
inline const CVector3d& CSphere::GetCenter() const
{
       return m_center;
}
 
 
inline void CSphere::SetCenter(const CVector3d& center)
{
       m_center = center;
}
 
 
inline double CSphere::GetVolume() const
{
       return (4.0 / 3.0) * I_PI * m_radius * m_radius * m_radius;
}
 
 
inline double CSphere::GetSurfaceArea() const
{
       return 4.0 * I_PI * m_radius * m_radius;
}
 
 
inline bool CSphere::Contains(const CVector3d& point, double tolerance) const
{
       double distSq = (point - m_center).GetLength2();
       double radiusTol = m_radius + tolerance;
       return distSq <= radiusTol * radiusTol;
}
 
 
inline bool CSphere::Intersects(const CSphere& other) const
{
       double centerDist = (m_center - other.m_center).GetLength();
       return centerDist <= (m_radius + other.m_radius);
}
 
 
inline double CSphere::GetSignedDistance(const CVector3d& point) const
{
       return (point - m_center).GetLength() - m_radius;
}
 
 
inline CVector3d CSphere::GetClosestPoint(const CVector3d& point) const
{
       CVector3d direction = (point - m_center).GetNormalized();
       return m_center + direction * m_radius;
}
 
 
inline bool CSphere::operator==(const CSphere& sphere) const
{
       return m_center == sphere.m_center && qAbs(m_radius - sphere.m_radius) < I_BIG_EPSILON;
}
 
 
inline bool CSphere::operator!=(const CSphere& sphere) const
{
       return !(*this == sphere);
}
 
 
} // namespace i3d