BoundingCylinder< T > Class Template Reference

BoundingCylinder class is a subclass of BoundingVolume class. More...

#include <TAPsBoundingCylinder.hpp>

Inheritance diagram for BoundingCylinder< T >:

[legend]

Collaboration diagram for BoundingCylinder< T >:

[legend]

List of all members.

Public Member Functions
	BoundingCylinder (const BoundingCylinder< T > &orig)
	Copy Constructor.
	BoundingCylinder (int id)
	BoundingCylinder ()
	Constructor(s) and Destructor.
virtual T	GetHeight () const
virtual T	GetRadius () const
BoundingCylinder< T > &	operator= (BoundingCylinder< T > const &orig)
virtual void	ScaledBy (T val)
virtual void	SetHeight (T height)
virtual void	SetRadius (T radius)
virtual std::string	StrInfo () const
	Return this object info as a string.
virtual T	TestOverlapWith (BoundingVolume< T > const *const that) const
virtual bool	TestPointLocation (Vector3< T > const *const pvPoint, TransformationSupport< T > const *const pTransform, Vector3< T > *const pvDistance=NULL) const
	Test if a point is inside this cylinder bounding volume.
virtual bool	TestPointLocation (Vector3< T > const *const pvPoint, Vector3< T > *const pvDistance=NULL) const
	Test if a point is inside this cylinder bounding volume.
virtual	~BoundingCylinder ()
Protected Attributes
T	m_tHeight
T	m_tRadius
Friends
std::ostream &	operator<< (std::ostream &output, BoundingCylinder< T > const &obj)

---

Detailed Description

template<typename T>
class BoundingCylinder< T >

BoundingCylinder class is a subclass of BoundingVolume class.

Data:

Center is a Vector3<T> inherited from BoundingVolume class.

Radius is scalar.

Height is scalar.

Cylinder is orianted in z-direction from the center with the radius and half height from plus z and negative z.

See also:

TAPsCDLib.hpp for details about Collision Detection implemented in TAPs.

Definition at line 32 of file TAPsBoundingCylinder.hpp.

---

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs BoundingCylinder< T >::BoundingCylinder

(

)

[inline]

Constructor(s) and Destructor.

BoundingCylinder class is a subclass of BoundingVolume class.

Definition at line 22 of file TAPsBoundingCylinder.cpp.

    : BoundingVolume<T>( Enum::BOUNDING_CYLINDER ),
      m_tRadius( 1 ),
      m_tHeight( 1 )
{}

template<typename T>

BoundingCylinder< T >::BoundingCylinder

(

int

id

)

[inline]

Definition at line 29 of file TAPsBoundingCylinder.cpp.

    : BoundingVolume<T>( Enum::BOUNDING_CYLINDER, id ),
      m_tRadius( 1 ),
      m_tHeight( 1 )
{}

template<typename T>

BoundingCylinder< T >::BoundingCylinder

(

const BoundingCylinder< T > &

orig

)

[inline]

Copy Constructor.

Definition at line 36 of file TAPsBoundingCylinder.cpp.

    : BoundingVolume<T>( orig ),
      m_tRadius( orig.m_tRadius ),
      m_tHeight( orig.m_tHeight )
{
    m_vCenter = orig.m_vCenter;
}

template<typename T>

BoundingCylinder< T >::~BoundingCylinder

(

)

[inline, virtual]

Definition at line 45 of file TAPsBoundingCylinder.cpp.

{}

---

Member Function Documentation

template<typename T>

virtual T BoundingCylinder< T >::GetHeight

(

)

const [inline, virtual]

Reimplemented from BoundingVolume< T >.

Definition at line 60 of file TAPsBoundingCylinder.hpp.

{return m_tHeight; }

template<typename T>

virtual T BoundingCylinder< T >::GetRadius

(

)

const [inline, virtual]

Reimplemented from BoundingVolume< T >.

Definition at line 58 of file TAPsBoundingCylinder.hpp.

{return m_tRadius; }

template<typename T>

BoundingCylinder<T>& BoundingCylinder< T >::operator=

(

BoundingCylinder< T > const &

orig

)

[inline]

template<typename T>

void BoundingCylinder< T >::ScaledBy

(

T

val

)

[inline, virtual]

Implements BoundingVolume< T >.

Definition at line 79 of file TAPsBoundingCylinder.cpp.

{
    assert( 0.0 <= val );
    GetTransform().PreApplyUniformScale( val );
}

template<typename T>

virtual void BoundingCylinder< T >::SetHeight

(

T

height

)

[inline, virtual]

Reimplemented from BoundingVolume< T >.

Definition at line 61 of file TAPsBoundingCylinder.hpp.

{ m_tHeight = height; }

template<typename T>

virtual void BoundingCylinder< T >::SetRadius

(

T

radius

)

[inline, virtual]

Reimplemented from BoundingVolume< T >.

Definition at line 59 of file TAPsBoundingCylinder.hpp.

{ m_tRadius = radius; }

template<typename T>

std::string BoundingCylinder< T >::StrInfo

(

)

const [inline, virtual]

Return this object info as a string.

Reimplemented from BoundingVolume< T >.

Definition at line 50 of file TAPsBoundingCylinder.cpp.

{
    std::string str = BoundingVolume<T>::StrInfo();
    std::ostringstream ss;
    ss <<   "  Radius: " << m_tRadius;
    ss << "\n  Height: " << m_tHeight;
    return str + ss.str() + "\n";
}

template<typename T>

T BoundingCylinder< T >::TestOverlapWith

(

BoundingVolume< T > const *const

that

)

const [inline, virtual]

This function is inherited from BoundingVolume<T> class

Implements BoundingVolume< T >.

Definition at line 304 of file TAPsBoundingCylinder.cpp.

{
    std::cout << "BoundingCylinder<T>::TestOverlapWith( BoundingVolume<T> ) -- NOT IMPLEMENTED YET!!!\n";
    return 0;
}

template<typename T>

bool BoundingCylinder< T >::TestPointLocation	(	Vector3< T > const *const	pvPoint,
		TransformationSupport< T > const *const	pTransform,
		Vector3< T > *const	pvDistance = NULL
	)			const [inline, virtual]

Test if a point is inside this cylinder bounding volume.

This Test Point Location function returns true if the input point input point to the bounding surface in the world (test point) coordinate.

pvDistance is for returning the shortest vector measuring from the input point to the bounding surface.

Therefore, this fn can be used to tell whether the point is inside or outside the bounding volume and how to move it to the surface of the bounding volume with the shortest distance.

Implements BoundingVolume< T >.

Definition at line 189 of file TAPsBoundingCylinder.cpp.

{
    bool isThePointInsideTheCylinder = false;
    //---------------------------------------------------------------
    TransformationSupport<T> transform; // default ctor is an identity
    if ( pTransform->GetStatusApplyTransformation() ) {
        transform.ReturnMatrixTransform() *= pTransform->GetMatrixTransform();
        // The above statement is equivalent to the below statement
        //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * pTransform->GetMatrixTransform();
        transform.EnableStatusApplyTransformation();
    }
    if ( GetTransform().GetStatusApplyTransformation() ) {
        transform.ReturnMatrixTransform() *= GetTransform().GetMatrixTransform();
        // The above statement is equivalent to the below statement
        //transform.ReturnMatrixTransform() = transform.GetMatrixTransform() * GetTransform().GetMatrixTransform();
        transform.EnableStatusApplyTransformation();
    }
    //---------------------------------------------------------------
    // In the local coordinate of the bounding cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform pvPoint to the cylinder local coordinate
    Vector3<T> location = *pvPoint;
    if ( transform.GetStatusApplyTransformation() ) {
        //location -= transform.GetTranslation();
        //location = transform.GetMatrixRotation().GetInverse() * location;
        location = (transform.GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    }
    // Shift the location of point by the cylinder center
    // i.e. shift the cylinder to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input point has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] );
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                //(*pvDistance).SetXYZ( 0, 0, 0 );
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] >= 0 ? difHeight : -difHeight );
                }
                //-------------------------
                // Now rotate it back by the rotation matrix (from the transform matrix).
                // REMARK: Translation (from the transform matrix) is NOT applied back, 
                //         because pvDistance represents a displacement vector from 
                //         the input point to the cylinder surface.
                if ( transform.GetStatusApplyTransformation() ) {
                    (*pvDistance) = transform.GetMatrixRotation() * (*pvDistance);
                }
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }

    /*
    // TEMPORARY CODE
    //---------------------------------------------------------------
    // Transform the pvDistance to the world coordinate
    if ( pvDistance ) {
        if ( !isThePointInsideTheCylinder ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
        else {
        }
    }
    //*/

    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}

template<typename T>

bool BoundingCylinder< T >::TestPointLocation	(	Vector3< T > const *const	pvPoint,
		Vector3< T > *const	pvDistance = NULL
	)			const [inline, virtual]

Test if a point is inside this cylinder bounding volume.

This Test Point Location function returns true if the input point input point to the bounding surface in the world (test point) coordinate.

pvDistance is for returning the shortest vector measuring from the input point to the bounding surface.

Therefore, this fn can be used to tell whether the point is inside or outside the bounding volume and how to move it to the surface of the bounding volume with the shortest distance.

Implements BoundingVolume< T >.

Definition at line 90 of file TAPsBoundingCylinder.cpp.

{
    bool isThePointInsideTheCylinder = false;
    //---------------------------------------------------------------
    // In the local coordinate of the bounding cylinder, 
    // the cylinder axis is parallel to z-axis 
    // where it is shifted by the cylinder center.
    // The cylinder has radius, height and center.
    // Its height is measured from -z and +z axis
    // where its center is situated between height/2 in -z and +z axis.
    //---------------------------------------------------------------
    // Transform pvPoint to the cylinder local coordinate
    Vector3<T> location = *pvPoint;
    if ( GetTransform().GetStatusApplyTransformation() ) {
        //location -= GetTransform().GetTranslation();
        //location = GetTransform().GetMatrixRotation().GetInverse() * location;
        location = (GetTransform().GetMatrixTransform().GetInverse() * Vector4<T>( location )).GetVector3();
    }
    // Shift the location of point by the cylinder center
    // i.e. shift the cylinder to the origin (0,0,0)
    location -= GetCenter();
    //---------------------------------------------------------------
    // Now the cylinder is centered at the origin with its axis on the z-axis
    // where its height is from -height/2 to +height/2.
    // And the input point has been transformed into the cylinder coordinate.
    // The test can be performed below
    T   halfHeight = GetHeight()/2.0;
    T   ptRadius = sqrt( location[0]*location[0] + location[1]*location[1] );
    //===============================================================
    // If the point is INSIDE the cylinder
    //---------------------------------------------------------------
    // If the point is within the cylinder radius
    if ( ptRadius <= GetRadius() ) { 
        // If the point is within the cylinder height
        if ( -halfHeight <= location[2] && location[2] <= halfHeight ) {
            // Find the shortest distance vector from the point to the surface 
            // of the cylinder
            if ( pvDistance ) {
                T   difRadius = GetRadius() - ptRadius;
                T   difHeight = halfHeight - fabs( location[2] );
                if ( difRadius <= difHeight ) {
                    // If the point is on the z-axis (degenerate case)
                    if ( difRadius >= GetRadius() ) {
                        (*pvDistance).SetXYZ( 0, GetRadius(), 0 );
                    }
                    // If the point is NOT on the z-axis
                    else {
                        Vector2<T> difDirection = Vector2<T>( location[0], location[1] );
                        difDirection.Normalized();
                        difDirection *= difRadius;
                        (*pvDistance).SetXYZ( difDirection[0], difDirection[1], 0 );
                    }
                }
                else {
                    (*pvDistance).SetXYZ( 0, 0, location[2] >= 0 ? difHeight : -difHeight );
                }
                //-------------------------
                // Now rotate it back by the rotation matrix (from the transform matrix).
                // REMARK: Translation (from the transform matrix) is NOT applied back, 
                //         because pvDistance represents a displacement vector from 
                //         the input point to the cylinder surface.
                if ( GetTransform().GetStatusApplyTransformation() ) {
                    (*pvDistance) = GetTransform().GetMatrixRotation() * (*pvDistance);
                }
            }
            //-------------------------
            isThePointInsideTheCylinder = true;
        }
    }
    //===============================================================
    // If the point is NOT INSIDE the cylinder radius
    //---------------------------------------------------------------
    else {
        if ( pvDistance ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
    }

    /*
    // TEMPORARY CODE
    //---------------------------------------------------------------
    // Transform the pvDistance to the world coordinate
    if ( pvDistance ) {
        if ( !isThePointInsideTheCylinder ) {
            (*pvDistance).SetXYZ( 0, 0, 0 );
        }
        else {
        }
    }
    //*/

    //---------------------------------------------------------------
    return isThePointInsideTheCylinder;
}

---

Friends And Related Function Documentation

template<typename T>

std::ostream& operator<<	(	std::ostream &	output,
		BoundingCylinder< T > const &	obj
	)			[friend]

Definition at line 38 of file TAPsBoundingCylinder.hpp.

    {
        output << obj.StrInfo();
        return output;
    }

---

Member Data Documentation

template<typename T>

T BoundingCylinder< T >::m_tHeight [protected]

Definition at line 165 of file TAPsBoundingCylinder.hpp.

template<typename T>

T BoundingCylinder< T >::m_tRadius [protected]

Definition at line 164 of file TAPsBoundingCylinder.hpp.

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/CD/TAPsBoundingCylinder.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/CD/TAPsBoundingCylinder.cpp