cinosmovepathcurve.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
#ifndef INC_CINOSMOVEPATHCURVE_H
#define INC_CINOSMOVEPATHCURVE_H
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <inos.h>
#include<cinosmovepathinterpolator.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// forwards
//------------------------------------------------------------------------------
 
struct SIndelMotionParamSet;
struct SIndelMotionMoveState;
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
// 
class CINOSMovePathCurve
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        // segment handling
 
        uint32 AddSegment(CINOSMovePathSegment* apSegment);
 
        void RemSegment(CINOSMovePathSegment* apSegment, bool abDelete = true);
 
        void RemSegment(CINOSMovePathSegment* apFirst, CINOSMovePathSegment* apLast);
 
        void InsSegment(CINOSMovePathSegment* apStart, CINOSMovePathSegment* apSegment);
 
        uint32 AppendCurve(CINOSMovePathCurve* apOtherCurve);
 
        CINOSMovePathSegment* GetSegment(uint32 auIndex);
 
        CINOSMovePathSegment* GetSegment(double adP);
 
 
        uint32 GetSegmentId(double adP);
 
        CINOSMovePathSegment* GetSegmentFirst()
        {
            // return pointer to first segment
            return m_pFstSegment;
        }
 
        CINOSMovePathSegment* GetSegmentLast()
        {
            // return pointer to last segment
            return m_pLstSegment;
        }
 
        // position handling
 
        bool GetPosition(uint32 auIndex, TINOSMovePathVec& ovPos);
 
 
        bool GetPosition(double adP, TINOSMovePathVec& ovPos);
 
 
        bool GetPosition(double& adP,  CINOSMovePathSegment*& opSegment, TINOSMovePathVec& ovPos);
 
 
        bool GetDirection(double adP, TINOSMovePathVec& ovDir);
 
 
        void GetDirectionLast(TINOSMovePathVec& ovDir);
 
        void GetDerivative(uint32 auLevel, double adP, TINOSMovePathVec& ovDer);
 
        bool GetD2max(double adP, TINOSMovePathVec& ovDir);
 
        bool GetD3max(double adP, TINOSMovePathVec& ovDir);
 
 
        void GetPositionFirst(TINOSMovePathVec& ovPos);
 
        void GetPositionLast(TINOSMovePathVec& ovPos);
 
        void GetPositionLast(CINOSMovePathSegment*& opSegment, TINOSMovePathVec& ovPos);
 
        void SetStart(TINOSMovePathVec& ivPos)
        {
            // set start vector
            m_vStart = ivPos;
            // mark all positions as valid
            m_uStartValid = (1<<DF_INOS_MOVEPATH_MAX_AXES)-1;
        }
 
        void SetStart(uint8 auIndex, double adPosition)
        {
            // ensure a valid index
            if (auIndex < DF_INOS_MOVEPATH_MAX_AXES){
                // set start vector
                m_vStart[auIndex] = adPosition;
                // mark position as valid
                m_uStartValid |= (1<<auIndex);
            }
        }
 
        void GetStart(TINOSMovePathVec& ovPos)
        {
            // set start vector
            ovPos = m_vStart;
        }
 
        virtual double GetLength()
        {
            // return curve length
            return m_dLength;
        };
 
        virtual void SetLength(double dLength)
        {
            // return curve length
            m_dLength = dLength;
        };
 
        virtual uint32 GetSegments()
        {
            // return number of curve segments
            return m_uSegments;
        };
 
        uint32 GetFlags()
        {
            // return flags
            return m_uFlags;
        };
 
        void SetFlags(uint32 auFlags)
        {
            // set flags
            m_uFlags |= auFlags;
        }
 
        void ClearFlags(uint32 auFlags)
        {
            // set flags
            m_uFlags &= ~auFlags;
        }
        virtual uint32 Recalc(CINOSMovePathSegment* apSegment, double adEpsilon);
 
        virtual uint32 Prepare(TINOSMovePathVec& ivAct, double& adActP,
                double adTolerance, double adEpsilon);
 
 
        virtual void Reset(
            uint32 auFlags = DF_INOS_MOVEPATH_FLAG_INC|DF_INOS_MOVEPATH_FLAG_RELOCATABLE|DF_INOS_MOVEPATH_FLAG_PURE_LINEAR,
            double adTolerance = DF_INOS_MOVEPATH_TOLERANCE_DEFAULT,
            double adVelocity = DF_INOS_MOVEPATH_VELOCITY_DEFAULT);
 
 
        uint32 GetInvolved()
        {
            // return mask of involved axes
            return m_uInvolved;
        }
 
        virtual bool IsRelocatable()
        {
            return (m_uFlags & DF_INOS_MOVEPATH_FLAG_RELOCATABLE);
        }
 
        virtual bool IsZeroBased()
        {
            return (m_uFlags & DF_INOS_MOVEPATH_FLAG_OFFSET_ZERO);
        }
 
        virtual bool IsPureLinear()
        {
            return (m_uFlags & DF_INOS_MOVEPATH_FLAG_PURE_LINEAR);
        }
 
        virtual bool IsIncomplete()
        {
            return (m_uFlags & DF_INOS_MOVEPATH_FLAG_INCOMPLETE);
        }
 
        virtual bool IsContinuation()
        {
            return (m_uFlags & DF_INOS_MOVEPATH_FLAG_CONTINUATION);
        }
 
 
        virtual bool IsContinuous(uint32 auLevel);
 
        virtual bool IsContinuous(CINOSMovePathSegment* apSeg1,
            CINOSMovePathSegment* apSeg2, uint32 auLevel);
 
        double GetTolerance()
        {
            // return tolerance
            return m_dTolerance;
        }
 
        double GetTolerance(CINOSMovePathSegment* apSegment,
            double adDefaultTolerance = DF_INOS_MOVEPATH_TOLERANCE_DEFAULT);
 
        double GetVelocity()
        {
            // return velocity
            return m_dVelocity;
        }
 
        double GetVelocity(double adP);
 
        double GetVelocity(CINOSMovePathSegment* apSegment,
            double adDefaultVelocity = DF_INOS_MOVEPATH_VELOCITY_DEFAULT);
 
        CINOSMovePathInterpolator* GetInterpolator() {
            return m_pInterpolator;
        }
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSMovePath;
 
    // constructor / destructor
    public :
        CINOSMovePathCurve ()
            : m_pInterpolator(0),
              m_uFlags(DF_INOS_MOVEPATH_FLAG_INC|DF_INOS_MOVEPATH_FLAG_RELOCATABLE|DF_INOS_MOVEPATH_FLAG_PURE_LINEAR),
              m_uSegments(0), m_uInvolved(0),
              m_dLength(0.0),
              m_dTolerance(DF_INOS_MOVEPATH_TOLERANCE_DEFAULT),
              m_dVelocity(DF_INOS_MOVEPATH_VELOCITY_DEFAULT),
              m_uLstIndex(0), m_pLstIndex(0),
              m_dLstP(0.0), m_pLstP(0),
              m_uStartValid(0),
              m_pFstSegment(0), m_pLstSegment(0)
        {
            // reset position vectors
            m_vStart = 0.0;
            m_vActual = 0.0;
        }
 
        virtual ~CINOSMovePathCurve ()
        {
            // destroy segments
            DestroySegments();
 
            // destroy interpolator if i'm the owner
            if (m_pInterpolator){
                // do it
                delete m_pInterpolator;
                // done
                m_pInterpolator = 0;
            } // end if
        }
 
        virtual uint32 SetInterpolator(CINOSMovePathInterpolator* apInterpolator);
 
 
        // destroy segments
        virtual void DestroySegments();
 
 
        virtual CINCOObject* RequestRegister();
 
        void ReleaseRegister();
 
    // protected methods
    protected :
        CINCOObject* GetRegister()
        {
            return m_pRegister;
        }
 
    // protected members
    protected :
        CINOSMovePathInterpolator* m_pInterpolator;
        uint32 m_uFlags;
        uint32 m_uSegments;
        uint32 m_uInvolved;
        double m_dLength;
        double m_dTolerance;
        double m_dVelocity;
        // search helpers
 
        uint32 m_uLstIndex;
        CINOSMovePathSegment* m_pLstIndex;
        double m_dLstP;
        CINOSMovePathSegment* m_pLstP;
 
        uint32 m_uStartValid;
        TINOSMovePathVec m_vStart;
        TINOSMovePathVec m_vActual;
 
        uint32 m_uRegisterCnt = 0;
        CINCOObject* m_pRegister = nullptr;
 
        CINOSMovePathSegment* m_pFstSegment;
        CINOSMovePathSegment* m_pLstSegment;
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSMovePathCurve);
};
 
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSMOVEPATHCURVE_H