basic/kinematics/LinkBase.cpp

Go to the documentation of this file.

#include <math/math2.h>
#include <string\string2.h>
#include <assert.h>
#include "streams\mystreams.h"
#include "Kinematics\DH_Link.h"
#include "Kinematics\LinkBase.h"
#include "additional\streams\IfstreamWithComments.h"
#include <stdio.h>

#pragma warning( disable : 4786 )

LinkBase::LinkBase (FrameManager* frameManager)
  : 
        baseFrame( 0 ), //IMPROVE: is this initialization needed?
        frameManager( frameManager ),
        jointMax( 180 ),
        jointMin( -180 ),
        jointWraps( false ) 
{
    //nothing
}

LinkBase::LinkBase (const LinkBase& right)
  : 
        NamedElement( right ),
        baseFrame( right.baseFrame ),
        frameManager( right.frameManager ),
        jointMax( right.jointMax ),
        jointMin( right.jointMin ),
        jointWraps( right.jointWraps ),
        positioningFrame( right.positioningFrame )
{
        controlledFrames.clear() ;
    int i;
        for( i = 0; i < right.controlledFrames.size(); i++ )
        {
                controlledFrames.push_back( right.controlledFrames[ i ] ) ;
        }

        //copy all the objects
        for( i = 0; i < right.objects.size(); i++ )
        {
                ObjectBase* cloneMe = right.objects[ i ];
                ObjectBase* cloned = dynamic_cast<ObjectBase*>( cloneMe->Clone() );
                objects.push_back( cloned ) ;
        }
        
}


LinkBase::~LinkBase()
{
  //## begin LinkBase::~LinkBase%.body preserve=yes

        for( int i = 0 ; i < objects.size(); i++ )
        {
                delete objects[ i ] ;
                objects[ i ] = NULL ;
        }
  //## end LinkBase::~LinkBase%.body
}



//## Other Operations (implementation)
void LinkBase::SetBaseFrame (const unsigned int frame)
{
  //## begin LinkBase::SetBaseFrame%924379573.body preserve=yes
        baseFrame = frame ;
  //## end LinkBase::SetBaseFrame%924379573.body
}

unsigned int LinkBase::BaseFrameNum () const
{
  //## begin LinkBase::BaseFrameNum%924379575.body preserve=yes
        return( baseFrame ) ;
  //## end LinkBase::BaseFrameNum%924379575.body
}

void LinkBase::SetFrameManager (FrameManager* frameManager)
{
  //## begin LinkBase::SetFrameManager%924978290.body preserve=yes
        this->frameManager = frameManager ;
        this->frameManager->AddFrame();
  //## end LinkBase::SetFrameManager%924978290.body
}

double LinkBase::JointMax () const
{
  //## begin LinkBase::JointMax%928194468.body preserve=yes
        return jointMax ;
  //## end LinkBase::JointMax%928194468.body
}

double LinkBase::JointMin () const
{
  //## begin LinkBase::JointMin%928194469.body preserve=yes
        return jointMin ;
  //## end LinkBase::JointMin%928194469.body
}

bool LinkBase::JointWraps () const
{
  //## begin LinkBase::JointWraps%928194470.body preserve=yes
        return jointWraps ;
  //## end LinkBase::JointWraps%928194470.body
}

void LinkBase::SetJointMax (const double jointMax)
{
  //## begin LinkBase::SetJointMax%928263336.body preserve=yes
        this->jointMax = jointMax ;
  //## end LinkBase::SetJointMax%928263336.body
}

void LinkBase::SetJointMin (const double jointMin)
{
  //## begin LinkBase::SetJointMin%928263337.body preserve=yes
        this->jointMin = jointMin ;
  //## end LinkBase::SetJointMin%928263337.body
}

void LinkBase::SetJointLimits (const double limit1, const double limit2)
{
  //## begin LinkBase::SetJointLimits%928263338.body preserve=yes
        SetJointMax( Max( limit1, limit2 ) ) ;
        SetJointMin( Min( limit1, limit2 ) ) ;
  //## end LinkBase::SetJointLimits%928263338.body
}

void LinkBase::Serialize (ostream& os) const
{
  //## begin LinkBase::Serialize%933801285.body preserve=yes
        using std::endl ;

        //IMPROVE: does this output enough data
        os << "#linkbase" << endl ;
        os << baseFrame << '\t' ;
        os << jointMin << '\t' ;
        os << jointMax << '\t' ;
        os << jointWraps << '\t' ;
        os << endl ;
        os << "#end_linkbase" << endl ;
  //## end LinkBase::Serialize%933801285.body
}

LinkBase* LinkBase::DeSerializeAbstract (IfstreamWithComments& is, FrameManager* frameManager)
{
  //## begin LinkBase::DeSerializeAbstract%935084509.body preserve=yes
        char marker[ 300 ] = "" ;

        //verify the first few lines - header lines
        is.eatwhite() ;
        is.getline( marker, 300 ) ;
    if( strcmp( marker, "#link" ) != 0 )
    {
        printf( "LinkBase::DeSerializeAbstract - expected #link got '%s'\n", marker );
            assert( strcmp( marker, "#link" ) == 0 ) ;
    }

        is.eatwhite() ;
        is.getline( marker, 300 ) ;
        
        LinkBase* link = NULL ;
        if( stricmp( marker, "#DH_LINK" ) == 0 )
        {
                link = new DH_Link( frameManager ) ;            //IMPROVE: null is a bad idea here
        }
        if (link == NULL)
                return NULL;

        if (link->DeSerialize( is ) == false)
        {
                delete link;
                return NULL;
        }

        is.GetSolidLine( marker, 300 ) ;
        assert( stricmp( marker, "#end_link" ) == 0 ) ;

        return link ;
  //## end LinkBase::DeSerializeAbstract%935084509.body
}

void LinkBase::SetPositioningFrame (const Matrix4x4& positioningFrame)
{
  //## begin LinkBase::SetPositioningFrame%969569781.body preserve=yes
        this->positioningFrame.SetValues( positioningFrame );
  //## end LinkBase::SetPositioningFrame%969569781.body
}

bool LinkBase::DeSerialize (IfstreamWithComments& is)
{
  //## begin LinkBase::DeSerialize%935084510.body preserve=yes
        is.eatwhite() ;
        char marker[ 300 ] = "";

        //read in the linkbase marker
        is.getline( marker, 300 ) ;

        is.eatwhite() ;
        is >> baseFrame ;
        is >> jointMin ;
        is >> jointMax ;

        int jointWrapsInt ;
        is >> jointWrapsInt ;
        jointWraps = ( jointWrapsInt != 0 );    //convert to bool

        eatwhite( is ) ;
        is.getline( marker, 300 ) ;
        assert( strcmp( marker, "#end_linkbase" ) == 0 ) ;
        return true;
  //## end LinkBase::DeSerialize%935084510.body
}

// Additional Declarations
  //## begin LinkBase%3707C4E603CA.declarations preserve=yes
//-----------------------------------------------------------------------------
std::ostream & operator<<( std::ostream &os, const LinkBase& v )
{
        //IMPROVE: this is an abstract class - can this ever be called?
        assert( false ) ;
        return os ;
};
//-----------------------------------------------------------------------------
std::istream & operator>>( std::istream &is, LinkBase& v )
{
        //IMPROVE: this is an abstract class - can this ever be called?
        assert( false ) ;
        return is ;
};
//-----------------------------------------------------------------------------

  //## end LinkBase%3707C4E603CA.declarations
//## begin module%3707C4E603CA.epilog preserve=yes
//## end module%3707C4E603CA.epilog

---