CoordinateAxis.h

Go to the documentation of this file.

#ifndef SimTK_COORDINATEAXIS_H 
#define SimTK_COORDINATEAXIS_H 

/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTK Simmatrix(tm)                       *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK Core biosimulation toolkit originating from      *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org.               *
 *                                                                            *
 * Portions copyright (c) 2005-10 Stanford University and the Authors.        *
 * Authors: Michael Sherman and Paul Mitiguy                                  *
 * Contributors:                                                              *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
 * -------------------------------------------------------------------------- */

#include <cassert>

namespace SimTK {

class CoordinateAxis {
public:
    explicit CoordinateAxis( int i ) : m_myAxisId(i) {assertIndexIsInRange(i);}

    operator int() const {return m_myAxisId;}

    CoordinateAxis getNextAxis() const 
    {   return CoordinateAxis((m_myAxisId+1) % 3); }

    CoordinateAxis getPreviousAxis() const 
    {   return CoordinateAxis((m_myAxisId+2) % 3); }

    CoordinateAxis getThirdAxis( const CoordinateAxis& axis2 ) const { 
       assert( isDifferentAxis(axis2) );
       CoordinateAxis nextAxis = getNextAxis();
       return nextAxis.isDifferentAxis(axis2) ? nextAxis : axis2.getNextAxis();
    }

    bool isXAxis() const {return m_myAxisId == 0;}
    bool isYAxis() const {return m_myAxisId == 1;}
    bool isZAxis() const {return m_myAxisId == 2;}
    bool isNextAxis( const CoordinateAxis& axis2 ) const
    {   return int(getNextAxis()) == int(axis2); }
    bool isPreviousAxis( const CoordinateAxis& axis2 ) const
    {   return int(getPreviousAxis()) == int(axis2); }
    bool isSameAxis( const CoordinateAxis& axis2 ) const
    {   return m_myAxisId == int(axis2); }
    bool areAllSameAxes( const CoordinateAxis& axis2, const CoordinateAxis &axis3 ) const       
    {   return isSameAxis(axis2) && isSameAxis(axis3); }
    bool isDifferentAxis( const CoordinateAxis& axis2 ) const                                   
    {   return m_myAxisId != int(axis2); }
    bool areAllDifferentAxes( const CoordinateAxis& axis2, const CoordinateAxis& axis3 ) const  
    {   return isDifferentAxis(axis2) && isDifferentAxis(axis3) && axis2.isDifferentAxis(axis3); }
    bool isForwardCyclical( const CoordinateAxis& axis2 ) const                                
    {   return isNextAxis(axis2); }
    bool isReverseCyclical( const CoordinateAxis& axis2 ) const                                 
    {   return isPreviousAxis(axis2); }

    int dotProduct(  const CoordinateAxis& axis2 ) const
    {   return isSameAxis(axis2) ? 1 : 0; }
    int crossProductSign( const CoordinateAxis& axis2 ) const
    {   return isSameAxis(axis2) ? 0 : (isNextAxis(axis2) ? 1 : -1); }
    CoordinateAxis crossProductAxis( const CoordinateAxis& axis2 ) const
    {   return isSameAxis(axis2) ? CoordinateAxis(m_myAxisId) 
                                 : getThirdAxis(axis2); }
    CoordinateAxis crossProduct( const CoordinateAxis& axis2, int& sign ) const
    {   sign = crossProductSign(axis2); return crossProductAxis(axis2); }

    static const CoordinateAxis& getCoordinateAxis( int i );

    static bool  isIndexInRange( int i )        { return 0<=i && i<=2; }
    static void  assertIndexIsInRange( int i )  { assert( isIndexInRange(i) ); } 

    // Forward declarations for subsequent helper classes
    class XCoordinateAxis; class YCoordinateAxis; class ZCoordinateAxis;
protected: // turn off doxygen here; these aren't for users
    class XTypeAxis{};
    class YTypeAxis{};
    class ZTypeAxis{};

    CoordinateAxis( const XTypeAxis& ) : m_myAxisId(0) {}
    CoordinateAxis( const YTypeAxis& ) : m_myAxisId(1) {}
    CoordinateAxis( const ZTypeAxis& ) : m_myAxisId(2) {}
private:            

    int m_myAxisId;
};


// Helper classes that allow compile time recognition of axis directions.
class CoordinateAxis::XCoordinateAxis : public CoordinateAxis {
  public: XCoordinateAxis() : CoordinateAxis(XTypeAxis()) {}
};
class CoordinateAxis::YCoordinateAxis : public CoordinateAxis {
  public: YCoordinateAxis() : CoordinateAxis(YTypeAxis()) {}
};
class CoordinateAxis::ZCoordinateAxis : public CoordinateAxis {
  public: ZCoordinateAxis() : CoordinateAxis(ZTypeAxis()) {}
};

static const CoordinateAxis::XCoordinateAxis  XAxis;
static const CoordinateAxis::YCoordinateAxis  YAxis;
static const CoordinateAxis::ZCoordinateAxis  ZAxis;

inline const CoordinateAxis& CoordinateAxis::getCoordinateAxis(int i) {
    assertIndexIsInRange(i);
    return (i==0 ? static_cast<const CoordinateAxis&>(XAxis) 
         : (i==1 ? static_cast<const CoordinateAxis&>(YAxis) 
                 : static_cast<const CoordinateAxis&>(ZAxis)));
}

inline bool operator==(const CoordinateAxis& a1, const CoordinateAxis& a2)
{   return a1.isSameAxis(a2); }

inline bool operator!=(const CoordinateAxis& a1, const CoordinateAxis& a2)
{   return a1.isDifferentAxis(a2); }


class CoordinateDirection {
public:
    class Negative {};

    CoordinateDirection(const CoordinateAxis& axis)
    :   m_axis(axis), m_direction(1) {}

    CoordinateDirection(const CoordinateAxis& axis, Negative)
    :   m_axis(axis), m_direction(-1) {}

    CoordinateDirection(const CoordinateAxis& axis, int direction)
    :   m_axis(axis), m_direction(direction) 
    {   assert(direction==1 || direction==-1); }

    CoordinateAxis getAxis() const {return m_axis;}
    int getDirection() const {return m_direction;}

    bool hasSameAxis(const CoordinateDirection& dir2) const
    {   return m_axis.isSameAxis(dir2.getAxis()); }

    bool isSameAxisAndDirection(const CoordinateDirection& dir2) const
    {   return m_axis==dir2.getAxis() && m_direction==dir2.getDirection(); }

    int dotProduct(  const CoordinateDirection& dir2 ) const
    {   if (m_axis != dir2.getAxis()) return 0;
        return m_direction == dir2.getDirection() ? 1 : -1; }

    int crossProductSign( const CoordinateDirection& dir2 ) const
    {   if (m_axis == dir2.getAxis()) return 0;
        return m_axis.crossProductSign(dir2.getAxis())
               * m_direction * dir2.getDirection(); }

    CoordinateAxis crossProductAxis( const CoordinateDirection& dir2 ) const
    {   return m_axis.crossProductAxis(dir2.getAxis()); }

    CoordinateAxis crossProduct( const CoordinateDirection& dir2, int& sign ) const
    {   sign = crossProductSign(dir2); return crossProductAxis(dir2); }

    // Local class declarations for helper classes.
    class NegXDirection; class NegYDirection; class NegZDirection;
private:
    CoordinateAxis m_axis;      // XAxis, YAxis, or ZAxis
    int            m_direction; // 1 or -1
};


// Helper classes that allow compile time recognition of negative axis
// directions.
class CoordinateDirection::NegXDirection : public CoordinateDirection {
  public: NegXDirection() : CoordinateDirection(XAxis,Negative()) {}
};
class CoordinateDirection::NegYDirection : public CoordinateDirection {
  public: NegYDirection() : CoordinateDirection(YAxis,Negative()) {}
};
class CoordinateDirection::NegZDirection : public CoordinateDirection {
  public: NegZDirection() : CoordinateDirection(ZAxis,Negative()) {}
};

// Predefine constants for the negative X,Y,Z directions.
static const CoordinateDirection::NegXDirection  NegXAxis;
static const CoordinateDirection::NegYDirection  NegYAxis;
static const CoordinateDirection::NegZDirection  NegZAxis;

inline bool operator==(const CoordinateDirection& d1, 
                       const CoordinateDirection& d2)
{   return d1.isSameAxisAndDirection(d2); }

inline bool operator!=(const CoordinateDirection& d1, 
                       const CoordinateDirection& d2)
{   return !d1.isSameAxisAndDirection(d2); }

inline const CoordinateDirection::NegXDirection&
operator-(const CoordinateAxis::XCoordinateAxis&){return NegXAxis;}
inline const CoordinateDirection::NegYDirection&
operator-(const CoordinateAxis::YCoordinateAxis&){return NegYAxis;}
inline const CoordinateDirection::NegZDirection&
operator-(const CoordinateAxis::ZCoordinateAxis&){return NegZAxis;}

inline CoordinateDirection
operator-(const CoordinateAxis& axis)
{   return CoordinateDirection(axis,CoordinateDirection::Negative()); }

inline CoordinateDirection
operator+(const CoordinateAxis& axis)
{   return CoordinateDirection(axis); }

inline const CoordinateAxis::XCoordinateAxis&
operator-(const CoordinateDirection::NegXDirection&){return XAxis;}
inline const CoordinateAxis::YCoordinateAxis&
operator-(const CoordinateDirection::NegYDirection&){return YAxis;}
inline const CoordinateAxis::ZCoordinateAxis&
operator-(const CoordinateDirection::NegZDirection&){return ZAxis;}

inline CoordinateDirection
operator-(const CoordinateDirection& dir)
{   return CoordinateDirection(dir.getAxis(), -dir.getDirection()); }

}  // End of namespace

#endif // SimTK_COORDINATEAXIS_H