HyperplaneCoordinateSystem.h

Go to the documentation of this file.

#ifndef __GfxTL_HYPERPLANECOORDINATESYSTEM_HEADER__
#define __GfxTL_HYPERPLANECOORDINATESYSTEM_HEADER__
#include <GfxTL/MathHelper.h>
#include <GfxTL/VectorXD.h>
 
namespace GfxTL
{
 
    template <class Scalar, unsigned int D>
    class HyperplaneCoordinateSystem
    {
    public:
        enum
        {
            Dim = D,
            HDim = Dim - 1
        };
    };
 
    template <class ScalarT>
    class HyperplaneCoordinateSystem<ScalarT, 2>
    {
    public:
        enum
        {
            Dim = 2,
            HDim = Dim - 1
        };
 
        typedef ScalarT ScalarType;
        typedef VectorXD<Dim, ScalarType> PointType;
 
        template <class V>
        void
        FromNormal(const V& v)
        {
            m_axis[0][0] = -v[1];
            m_axis[0][1] = v[0];
        }
 
        PointType&
        operator[](unsigned int i)
        {
            return m_axis[i];
        }
 
        const PointType&
        operator[](unsigned int i) const
        {
            return m_axis[i];
        }
 
    private:
        PointType m_axis[Dim - 1];
    };
 
    template <class Scalar>
    class HyperplaneCoordinateSystem<Scalar, 3>
    {
    public:
        enum
        {
            Dim = 3,
            HDim = Dim - 1
        };
 
        typedef Scalar ScalarType;
        typedef VectorXD<Dim, ScalarType> PointType;
 
        HyperplaneCoordinateSystem()
        {
            for (unsigned int i = 0; i < Dim - 1; ++i)
            {
                _axis[i].Zero();
            }
        }
 
        HyperplaneCoordinateSystem(ScalarType x, ScalarType y, ScalarType z)
        {
            FromNormal(PointType(x, y, z));
        }
 
        template <class V>
        HyperplaneCoordinateSystem(V n)
        {
            FromNormal(n);
        }
 
        void
        FromNormal(ScalarType x, ScalarType y, ScalarType z)
        {
            FromNormal(PointType(x, y, z));
        }
 
        template <class V>
        void
        FromNormal(const V& n)
        {
            FromNormal(PointType(n[0], n[1], n[2]));
        }
 
        void
        FromNormal(const PointType& n)
        {
            // perform arbitrary axis algorithm as
            // specified by AutoCAD
            if (Math<ScalarType>::Abs(n[0]) < ScalarType(0.015625f) &&
                Math<ScalarType>::Abs(n[1]) < ScalarType(0.015625f))
            {
                _axis[0] = PointType(0, 1, 0) % n;
            }
            else
            {
                _axis[0] = PointType(0, 0, 1) % n;
            }
            _axis[0].Normalize();
            _axis[1] = n % _axis[0];
            _axis[1].Normalize();
        }
 
        PointType&
        operator[](unsigned int i)
        {
            return _axis[i];
        }
 
        const PointType&
        operator[](unsigned int i) const
        {
            return _axis[i];
        }
 
    private:
        PointType _axis[Dim - 1];
    };
 
}; // namespace GfxTL
 
#endif