Ellipsoid3d.h

// Ellipsoid3d.h:
// --------------
//

#ifndef __IPSDKGEOMETRY_ELLIPSOID3D_H__
#define __IPSDKGEOMETRY_ELLIPSOID3D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Ellipsoid3d<ipsdk::ipInt32>::_centerPt': struct 'ipsdk::geom::Point3dData<T>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Ellipsoid3d<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/Ellipsoid/Ellipsoid3dOperators.h>
#include <IPSDKMath/Geometry/3d/Angles3d.h>
#include <IPSDKMath/Geometry/3d/Ellipsoid3d.h>

namespace ipsdk {
namespace geom {


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

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

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

public:
    Ellipsoid3d();
    Ellipsoid3d(const Point3dData<T>& centerPt, const T majorRadius, const T mediumRadius, const T minorRadius, const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    Ellipsoid3d(const Point3d<T>& centerPt, const T majorRadius, const T mediumRadius, const T minorRadius, const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    Ellipsoid3d(const T xCenter, const T yCenter, const T zCenter, const T majorRadius, const T mediumRadius, const T minorRadius, const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    ~Ellipsoid3d();

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

    inline eEntity3dType            getEntity3dType() const;

    inline void                     setCoords(const Point3dData<T>& centerPt,
                                              const T majorRadius, const T mediumRadius, const T minorRadius,
                                              const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    inline void                     setCoords(const Point3d<T>& centerPt,
                                              const T majorRadius, const T mediumRadius, const T minorRadius,
                                              const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    inline void                     setCoords(const T xCenter, const T yCenter, const T zCenter,
                                              const T majorRadius, const T mediumRadius, const T minorRadius,
                                              const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    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                     setMajorRadius(const T majorRadius);
    inline void                     setMediumRadius(const T mediumRadius);
    inline void                     setMinorRadius(const T minorRadius);
    inline void                     setOrientation(const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha);
    inline T                        getMajorRadius() const;
    inline T                        getMediumRadius() const;
    inline T                        getMinorRadius() const;
    inline ipReal64                 getAlpha() const;
    inline ipReal64                 getBeta() const;
    inline ipReal64                 getChi() const;
    inline const math::Matrix3d&    getMatRot() 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                 area() const;

    inline ipReal64                 volume() const;

    inline ipReal64                 excentricity() const;

    inline ipReal64                 radius(const ipReal64 theta, const ipReal64 phi) const;

    inline Point3dData<ipReal64>    boundaryPoint(const ipReal64 theta, const ipReal64 phi) const;

// attributes
protected:
    Point3dData<T>  _centerPt;

    T               _majorRadius;

    T               _mediumRadius;

    T               _minorRadius;

    ipReal64        _alpha;

    ipReal64        _beta;

    ipReal64        _chi;

    math::Matrix3d  _matRot;
};


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

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

template <typename T>
inline void
Ellipsoid3d<T>::setCoords(const Point3dData<T>& centerPt,
                          const T majorRadius, const T mediumRadius, const T minorRadius,
                          const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha)
{
    _centerPt = centerPt;
    _majorRadius = majorRadius;
    _mediumRadius = mediumRadius;
    _minorRadius = minorRadius;
    setOrientation(chi, beta, alpha);
}

template <typename T>
inline void
Ellipsoid3d<T>::setCoords(const Point3d<T>& centerPt,
                          const T majorRadius, const T mediumRadius, const T minorRadius,
                          const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha)
{
    _centerPt = centerPt.getCoords();
    _majorRadius = majorRadius;
    _mediumRadius = mediumRadius;
    _minorRadius = minorRadius;
    setOrientation(chi, beta, alpha);
}

template <typename T>
inline void
Ellipsoid3d<T>::setCoords(const T xCenter, const T yCenter, const T zCenter,
                          const T majorRadius, const T mediumRadius, const T minorRadius,
                          const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha)
{
    _centerPt.setCoords(xCenter, yCenter, zCenter);
    _majorRadius = majorRadius;
    _mediumRadius = mediumRadius;
    _minorRadius = minorRadius;
    setOrientation(chi, beta, alpha);
}

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

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

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

template <typename T>
inline void
Ellipsoid3d<T>::setMajorRadius(const T majorRadius)
{
    _majorRadius = majorRadius;
}

template <typename T>
inline void
Ellipsoid3d<T>::setMediumRadius(const T mediumRadius)
{
    _mediumRadius = mediumRadius;
}

template <typename T>
inline void
Ellipsoid3d<T>::setMinorRadius(const T minorRadius)
{
    _minorRadius = minorRadius;
}

template <typename T>
inline void
Ellipsoid3d<T>::setOrientation(const ipReal64 chi, const ipReal64 beta, const ipReal64 alpha)
{
    _chi = chi;
    _beta = beta;
    _alpha = alpha;
    _matRot = math::eulerToMatrix(chi, beta, alpha);
}

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

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

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

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

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

template <typename T>
inline T
Ellipsoid3d<T>::getMajorRadius() const
{
    return _majorRadius;
}

template <typename T>
inline T
Ellipsoid3d<T>::getMediumRadius() const
{
    return _mediumRadius;
}

template <typename T>
inline T
Ellipsoid3d<T>::getMinorRadius() const
{
    return _minorRadius;
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::getAlpha() const
{
    return _alpha;
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::getBeta() const
{
    return _beta;
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::getChi() const
{
    return _chi;
}

template <typename T>
inline const math::Matrix3d&
Ellipsoid3d<T>::getMatRot() const
{
    return _matRot;
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::area() const
{
    return math::ellipsoidArea(_majorRadius, _mediumRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::volume() const
{
    return math::ellipsoidVolume(_majorRadius, _mediumRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::excentricity() const
{
    return math::ellipsoidExcentricity(_majorRadius, _mediumRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipsoid3d<T>::radius(const ipReal64 theta, const ipReal64 phi) const
{
    return math::ellipsoidRadius(_majorRadius, _mediumRadius, _minorRadius,
                                 _matRot,
                                 theta, phi);
}

template <typename T>
inline Point3dData<ipReal64>
Ellipsoid3d<T>::boundaryPoint(const ipReal64 theta, const ipReal64 phi) const
{
    Point3dData<ipReal64> pt;
    math::ellipsoidPoint(_centerPt._x, _centerPt._y, _centerPt._z,
                         _majorRadius, _mediumRadius, _minorRadius,
                         _matRot,
                         theta, phi,
                         pt._x, pt._y, pt._z);

    return pt;
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_ELLIPSOID3D_H__