Sphere3d.h

// Sphere3d.h:
// -----------
//

#ifndef __IPSDKGEOMETRY_SPHERE3D_H__
#define __IPSDKGEOMETRY_SPHERE3D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Sphere3d<ipsdk::ipInt32>::_centerPt': struct 'ipsdk::geom::Point3dData<T>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Sphere3d<ipsdk::ipInt32>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Point/Point3d.h>
#include <IPSDKGeometry/Entity/3d/Sphere/Sphere3dOperators.h>
#include <IPSDKMath/Geometry/3d/Sphere3d.h>

namespace ipsdk {
namespace geom {


template <typename T>
class IPSDKGEOMETRY_API Sphere3d : public BaseTypedGeometryEntity3d<T>
{
    // declare 3d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_3D(IPSDKGeometry, Sphere3d);

// predefined public types
public:
    static const eCoordinateSystem3dType::domain g_coordinateSystem3dType = eCoordinateSystem3dType::eCS3DT_Cartesian;

    static const eEntity3dType::domain g_entity3dType = eEntity3dType::eE3DT_Sphere;

public:
    Sphere3d();
    Sphere3d(const Point3dData<T>& center, const T radius);
    Sphere3d(const Point3d<T>& center, const T radius);
    Sphere3d(const T xCenter, const T yCenter, const T zCenter, const T radius);
    ~Sphere3d();

// methods
public:
    inline eCoordinateSystem3dType  getCoordinateSystem3dType() const;

    inline eEntity3dType            getEntity3dType() const;

    inline void                     setCoords(const Point3dData<T>& centerPt, const T radius);
    inline void                     setCoords(const Point3d<T>& centerPt, const T radius);
    inline void                     setCoords(const T xCenter, const T yCenter, const T zCenter, const T radius);
    inline void                     setCenter(const Point3dData<T>& centerPt);
    inline void                     setCenter(const Point3d<T>& centerPt);
    inline void                     setCenter(const T xCenter, const T yCenter, const T zCenter);
    inline void                     setRadius(const T radius);
    inline T                        getRadius() const;
    inline T                        centerX() const;
    inline T                        centerY() const;
    inline T                        centerZ() const;
    inline const Point3dData<T>&    center() const;
    inline Point3dData<T>&          center();

    inline ipReal64                 distance(const Point3d<T>& pt) const;
    ipReal64                        distance(const Point3dData<T>& pt) const;

    inline ipReal64                 signedDistance(const Point3d<T>& pt) const;
    ipReal64                        signedDistance(const Point3dData<T>& pt) const;

    ipReal64                        area() const;

    ipReal64                        volume() const;

// attributes
protected:
    Point3dData<T>  _centerPt;

    T               _radius;

};


template <typename T>
inline eCoordinateSystem3dType
Sphere3d<T>::getCoordinateSystem3dType() const
{
    return g_coordinateSystem3dType;
}

template <typename T>
inline eEntity3dType
Sphere3d<T>::getEntity3dType() const
{
    return g_entity3dType;
}

template <typename T>
inline void
Sphere3d<T>::setCoords(const Point3dData<T>& centerPt, const T radius)
{
    _centerPt = centerPt;
    _radius = radius;
}

template <typename T>
inline void
Sphere3d<T>::setCoords(const Point3d<T>& centerPt, const T radius)
{
    _centerPt = centerPt.getCoords();
    _radius = radius;
}

template <typename T>
inline void
Sphere3d<T>::setCoords(const T xCenter, const T yCenter, const T zCenter, const T radius)
{
    _centerPt.setCoords(xCenter, yCenter, zCenter);
    _radius = radius;
}

template <typename T>
inline void
Sphere3d<T>::setCenter(const Point3dData<T>& centerPt)
{
    _centerPt = centerPt;
}

template <typename T>
inline void
Sphere3d<T>::setCenter(const Point3d<T>& centerPt)
{
    _centerPt = centerPt.getCoords();
}

template <typename T>
inline void
Sphere3d<T>::setCenter(const T xCenter, const T yCenter, const T zCenter)
{
    _centerPt.setCoords(xCenter, yCenter, zCenter);
}

template <typename T>
inline void
Sphere3d<T>::setRadius(const T radius)
{
    _radius = radius;
}

template <typename T>
inline T
Sphere3d<T>::centerX() const
{
    return _centerPt._x;
}

template <typename T>
inline T
Sphere3d<T>::centerY() const
{
    return _centerPt._y;
}

template <typename T>
inline T
Sphere3d<T>::centerZ() const
{
    return _centerPt._z;
}

template <typename T>
inline const Point3dData<T>&
Sphere3d<T>::center() const
{
    return _centerPt;
}

template <typename T>
inline Point3dData<T>&
Sphere3d<T>::center()
{
    return _centerPt;
}

template <typename T>
inline T
Sphere3d<T>::getRadius() const
{
    return _radius;
}

template <typename T>
inline ipReal64
Sphere3d<T>::distance(const Point3d<T>& pt) const
{
    return distance(pt.getCoords());
}

template <typename T>
inline ipReal64
Sphere3d<T>::distance(const Point3dData<T>& pt) const
{
    return std::abs(signedDistance(pt));
}

template <typename T>
inline ipReal64
Sphere3d<T>::signedDistance(const Point3d<T>& pt) const
{
    return signedDistance(pt.getCoords());
}

template <typename T>
inline ipReal64
Sphere3d<T>::area() const
{
    return math::sphereArea(_radius);
}

template <typename T>
inline ipReal64
Sphere3d<T>::volume() const
{
    return math::sphereVolume(_radius);
}


} // end of namespace geom
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_SPHERE3D_H__