OMKJointExtension.cpp

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
                
#include "OMKJointExtension.h"
#include "OMKJoint.h"
#include "OMKExtensibleSimulatedObject.h"
#include "OMKInteractorExtension.h"
#include "OMKParametersAccessor.inl"
#include "OMKInputNT.h"
#include "OMKSessionPrm.h"
#include "OMKTransformType.h"

namespace OMK  
{
  namespace Iii 
  {
//=================================================================
// JointInteractorExtension
//=================================================================
class JointInteractorExtension : public InteractorExtension 
{
  friend class JointExtension ;

public:
  virtual ~JointInteractorExtension() ;
protected:
  JointInteractorExtension( JointExtension* jointExtension ) ;

  virtual bool loadObjectParameters( const ConfigurationParameterDescriptor * node ) ;
  virtual bool loadExtensionParameters( const ConfigurationParameterDescriptor * node ) ;
  virtual void postComputeParameters() ;
  void startRetroPropagation() ;
  void stopRetroPropagation() ;
  Name _referenceId ;
  Name _positionId ;
  bool _connected ;
  JointExtension* _jointExtension ;
} ;
    
//-----------------------------------------------------------------
JointInteractorExtension::JointInteractorExtension( JointExtension* jointExtension ) 
: InteractorExtension( jointExtension->_owner, std::string( jointExtension->_id.getCString() ) + "Interactor", false ),
  _connected( false ),
  _jointExtension( jointExtension ) 
{
  _access._level = 0 ;
}
//-----------------------------------------------------------------
JointInteractorExtension::~JointInteractorExtension() 
{
}
//-----------------------------------------------------------------
bool JointInteractorExtension::loadObjectParameters( const ConfigurationParameterDescriptor * node ) 
{
  bool ok = true ;

  std::pair< Name, Name > connection ;
  ok = ok && ParametersAccessor::get( node, "refPositionConnect", connection, _owner ) ;
  if( ok )
  {
    _referenceId = connection.first ;
    _positionId = connection.second ;
  }

  return ok  ;
}
//-----------------------------------------------------------------
bool JointInteractorExtension::loadExtensionParameters( const ConfigurationParameterDescriptor * node ) 
{
  ParametersAccessor::get( node, "Level", _access._level ); 
  OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has the level " << _access._level ) ;
  startInteractor() ;
  
  // Try to read the category in the configuration of the reference object
  bool found  = false ; // flag to know if the search is ok
  std::string category( "absolute" ) ; // The default value
  // 1/ Search in the current configuration the category
  if( ParametersAccessor::get( node, "Category", category ) )
  {
    OMTRACEID( OMK_DEBUG_III, "The category for the reference is \"" << category << "\" and it " << ( found ? "was found in configuration" : "is the default value" ) ) ;
  }
  else
  {
    // 2/ search the extensions configuration of the reference object
    const ConfigurationParameterDescriptor *extNodeForRef = _owner->getController().getObjectDescriptorOfObject( _referenceId ).getExtensionsParameters() ;
    int nbItems = extNodeForRef ? extNodeForRef->getNumberOfSubItems() : 0 ;
    for( int i = 0 ; i < nbItems && !found ; ++i )
    { 
      // Retrieves configuration for each extension
      const ConfigurationParameterDescriptor * extNode = extNodeForRef->getSubDescriptorByPosition( i ) ;
      // Try to found "Connectors" in it
      const ConfigurationParameterDescriptor * connectorsNode = extNode->getSubDescriptorByName( "Connectors" ) ;
      // Try to found the connector with the same id than the output which is the reference for the joint
      const ConfigurationParameterDescriptor * connectorNode = connectorsNode ? connectorsNode->getSubDescriptorByName( _positionId.getCString() ) : 0 ;
      if( connectorNode )
      { // Ok, so try to read the "Category" field
        ParametersAccessor::get( connectorNode, "Category", category ) ;
        found = true ;
        break ;
      }
      else
      { // Not ok, no connectors has this id
        int nbItems2 = connectorsNode ? connectorsNode->getNumberOfSubItems() : 0 ;
        for( int j = 0 ; j < nbItems2 ; ++j )
        { // Look for connector which has the "Attribute" field equals to the id
          std::string id ;
          const ConfigurationParameterDescriptor * connectorNode = connectorsNode->getSubDescriptorByPosition( j ) ;
          if( ParametersAccessor::get( connectorNode, "Attribute", id ) && id == _positionId )
          { // The "Attribute" field is ok => try to read the "Category" field
            ParametersAccessor::get( connectorNode, "Category", category ) ;
            found = true ;
            break ;
          }
        }
      }
    }
    OMTRACEID( OMK_DEBUG_III, "The category for the reference is \"" << category << "\" and it " << ( found ? "was found in configuration" : "is the default value" ) ) ;
  }
    
  // Creates the interactor output
  InteractorOutput::create( _jointExtension->_referencePosition.getId(), _jointExtension->_referencePosition.getId(), this, category, OMK::Type::AccessGroupLevel(), false ) ;

  return true ;
}
//-----------------------------------------------------------------
void JointInteractorExtension::postComputeParameters() 
{
}
//-----------------------------------------------------------------
void JointInteractorExtension::startRetroPropagation() 
{
  if( !getSessionWith( _referenceId ) )
  {
    startSessionWith( _referenceId ) ;
    OMMESSAGE( "start session" ) ;
  }
  else if( !_connected )
  {
    (*getSessionWith( _referenceId )).c( _jointExtension->_referencePosition.getId() ).c( OMK::Iii::controlTakeOverAndGetCurrentValues ) ;
    _connected = true ;
    OMMESSAGE( "start retro propagation" ) ;
  }
}
//-----------------------------------------------------------------
void JointInteractorExtension::stopRetroPropagation() 
{
  if( _connected ) 
  {
    (*getSessionWith( _referenceId )).c( _jointExtension->_referencePosition.getId() ).c( OMK::Iii::controlRelease ) ;
    _connected = false ;
    OMMESSAGE( "stop retro propagation" ) ;
  }
}
//-----------------------------------------------------------------

//=================================================================
// JointExtension
//=================================================================
    
REGISTER_EXTENSION_FACTORY( JointExtension, "Joint" ) ;
//-----------------------------------------------------------------

// Default constructor
JointExtension::JointExtension( ExtensibleSimulatedObject* owner, const Name& id, bool registerExtension )
: ExtensionT< ExtensibleSimulatedObject >( owner, id, registerExtension ),
  _objectPosition( 0 ),
  _referencePosition( "refPosition", OMK::Type::Transform::sk_identity ),
  _jointPosition( "jointPosition", OMK::Type::Transform::sk_identity ),
  _connected( false ),
  _interactor( 0 ),
  _joint( 0 )
{
  // add the attributes to the object
  _owner->addAttribute( _referencePosition ) ;
  _owner->addAttribute( _jointPosition ) ;
  // Look for the retrto propagation flag
  const ConfigurationParameterDescriptor * node = _owner->getObjectDescriptor().getExtensionsParameters() ;
  const ConfigurationParameterDescriptor * extNode = node ? node->getSubDescriptorByName( _id.getCString() ) : 0 ;
  bool retroAction = false ; // Default is false
  ParametersAccessor::get( extNode, "Retro", retroAction ) ;
  if( retroAction )
  {
    // For retro-propagation the extension must declare the output for the reference position
    _referencePosition.createOutput() ;
    // And create the interactor to update the reference position
    _interactor = new JointInteractorExtension( this ) ;
  }
}

//-----------------------------------------------------------------

// Destructor
JointExtension::~JointExtension()
{
  // delete the associated interactor
  delete _interactor ;
}
//-----------------------------------------------------------------

bool JointExtension::loadObjectParameters( const ConfigurationParameterDescriptor * node ) 
{
  // Calls the interactor loader if neccessary
  return !_interactor || _interactor->loadObjectParameters( node ) ;
}
//-----------------------------------------------------------------

bool JointExtension::loadExtensionParameters( const ConfigurationParameterDescriptor * node ) 
{
  // Gets the name of the position attribute of the object
  Name attributeName( "Position" ) ; // by default "Position"
  ParametersAccessor::get( node, "PositionName", attributeName ) ;
  // Gets the attribute accessor
  _objectPosition = _owner->getBaseAttribute< OMK::Type::Transform >( attributeName ) ;
  bool ok = _objectPosition != 0 ;
  
  // Calls the interactor loader if neccessary
  ok = ok && ( !_interactor || _interactor->loadExtensionParameters( node ) ) ;
  
  // The joint
  std::string jointClass( "Lock" ) ;
  
  ok = ok && ParametersAccessor::get( node, "Joint", jointClass ) ;
  _joint = OMK::Iii::JointFactory::getInstance().create( jointClass )( this, node ) ;
  OMASSERTM( _joint, "Joint  [" << jointClass << "] cannot be created, may be not registered in the main !" ) ;
  
  return ok ;
}
//-----------------------------------------------------------------

void JointExtension::postComputeParameters() 
{
  OMASSERTM( _joint, "The joint must be created" ) ;
  // To be linked the joint must found the position, see if the reference position declares an input and if this one is connected
  bool updatedLinkstate = _objectPosition 
                       && _referencePosition.getInput() 
                       && _referencePosition.getInput()->getConnectedOutput() ;
  if( _connected )
  { 
    if( !updatedLinkstate )
    { // Change the state => no more connected
      _connected = false ;
      // Nothing else to do
      OMMESSAGE( "release" ) ;
    }
    else
    { // Connected and still connected
      // Calculates the new joint position based on the reference position
      _joint->currentJointPosition() ;
      // Does the object move ?
      
      // Retro propagation is activated
      // the object moves itself (by an interactor, its own behavior,...)
      // => calculates the the ideal position for the reference position
      if( _objectPosition->isUpdated() && _joint->retroPropagation() )
      { 
        // Starts retro-propagation
        if( _interactor ) _interactor->startRetroPropagation() ;
      }
      else
      {
        // The object doesn't move itself => it follows the reference, no more retro-propagation
        if( _interactor ) _interactor->stopRetroPropagation() ;
      }
      // Calculates the new joint position based on the joint position
      _joint->currentObjectPosition() ;
    }
  }
  else
  {
    if( updatedLinkstate )
    { // Change the state => The connection has just been connected
      OMMESSAGE( "linked" ) ;
      _connected = true ;
      _joint->establishLink() ;
    }
    // else unconnected and still unconnected => nothing to do
  }
}

  }// namespace Iii
}// namespace OMK

---