CoordinateAxis.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_COORDINATE_AXIS_H_ 
#define SimTK_SimTKCOMMON_COORDINATE_AXIS_H_ 

/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK 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/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2005-12 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon/internal/common.h"
#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()) {}
};

extern SimTK_SimTKCOMMON_EXPORT const CoordinateAxis::XCoordinateAxis  XAxis;
extern SimTK_SimTKCOMMON_EXPORT const CoordinateAxis::YCoordinateAxis  YAxis;
extern SimTK_SimTKCOMMON_EXPORT 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.
extern SimTK_SimTKCOMMON_EXPORT const CoordinateDirection::NegXDirection  
    NegXAxis; 
extern SimTK_SimTKCOMMON_EXPORT const CoordinateDirection::NegYDirection  
    NegYAxis; 
extern SimTK_SimTKCOMMON_EXPORT 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_SimTKCOMMON_COORDINATE_AXIS_H_