OMKParametersAccessor.cpp

Go to the documentation of this file.

/*
 * This file is part of openMask © 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 Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#include <OMKParametersAccessor.inl>
#include <OMKName.h>
#include <OMKSimulatedObject.h>
#include "OMKTransformType.h"
#include "OMKColorType.h"
#include "OMKTracer.h"
#include "OMKConfigurationParameterDescriptor.h"

using namespace OMK ;
//-------------------------------------------------------------------
// Get the node named "name" 
const ConfigurationParameterDescriptor * ParametersAccessor::getNodeValue(
  const ConfigurationParameterDescriptor * node,
  const std::string & name,
  std::string & errorStr )
{
  const ConfigurationParameterDescriptor * nodeValue = node ? node->getSubDescriptorByName( name ) : 0 ;
  if ( !node && errorStr.empty() ) 
    errorStr = "Invalid ConfigurationParameterDescriptor node" ;
  if ( !nodeValue && errorStr.empty() )
    errorStr = "Parameter not found" ;
  return nodeValue ;
}

//-------------------------------------------------------------------
// Return a bool to put it in a test like
// return getValue(...) || displayError(...)
// so return always false 
bool ParametersAccessor::displayError(
  const std::string & name,
  const std::string & functionName,
  SimulatedObject* object,
  const std::string & errorStr )
{
  if( !errorStr.empty() )
  {
    if( object ) 
    {
      OMERROR( "Error in ParametersAccessor::" << functionName 
          << " with parameter [" + name + "] for " << OMK::debugMsg( object ) << std::endl 
          << ">>> :-( " << errorStr ) ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_OMK_OBJ, "Warning in ParametersAccessor::" << functionName 
          << " with parameter [" + name + "]" << std::endl 
          << ">>> :-| " << errorStr ) ;
    }
  } 
  // Return always false 
  return false ;
}

//-------------------------------------------------------------------
// Retrieve a object name and check its existance in the tree
bool ParametersAccessor::getAndCheckObject(
          const ConfigurationParameterDescriptor * node,
          const std::string & name,
          Name & objectName,
          Controller & controller,
          SimulatedObject * object /*= 0 */ )
{
  std::string errorStr ;
  // Get the node for the value
  const ConfigurationParameterDescriptor * nodeValue = getNodeValue( node, name, errorStr ) ;
  // if it is good, get the value else display error
  bool ok = ( nodeValue != NULL ) ;
  ok = ok && getValue( nodeValue, objectName, errorStr ) ;
  if( ok )
  {
    try
    {
      //check wether paramVariable exists: if it does not, a OMKUserException is thrown
      controller.getObjectDescriptorOfObject( objectName );
    }
    catch( UserException e )
    {
      ok = false ;
      errorStr = "Object \"" ;
      errorStr += objectName.getCString();
      errorStr += "\" doesn't exist" ;
    }
  }
  return ok || displayError( name, "getAndCheckObject", object, errorStr ) ;
}
//-------------------------------------------------------------------
// Get value for a bool
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue,
                                     bool & flag,
                                     std::string& errorStr ) 
{
  std::string str;
  if( !getValue( nodeValue, str, errorStr ) )
  { // Error
    return false;
  }
  std::transform( str.begin(), str.end(), str.begin(), toupper );
  flag = ( str == "TRUE" || str == "ON" || str == "ENABLE" || str == "YES" || str == "1" ) ;
  bool ok = flag || ( str == "FALSE" || str == "OFF" || str == "DISABLE" || str == "NO" || str == "0" ) ;
  if( !ok )
  {
    errorStr = "Cannot read the boolean" ;       
  }
  return ok ;
}

//-------------------------------------------------------------------
// Get value for a OMK::Type::Color
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     OMK::Type::Color & color,
                                     std::string& errorStr )
{
  if( !nodeValue )
    return false; // Error no valid node
  
  if( nodeValue->getAssociatedString()[0] == '{' ) 
  {
    // array format => read it 
    // rgb or rgba
    bool ok = ( 3 == nodeValue->getNumberOfSubItems() 
             || 4 == nodeValue->getNumberOfSubItems() ); 
    if ( !ok && errorStr.empty() ) 
      errorStr = "Bad format of OMK::Type::Color (need 3 or 4 arguments)" ;
    // 4 values => rgb + alpha
    bool withAlpha = ( 4 == nodeValue->getNumberOfSubItems() ) ;
    float r = 0.0f;
    float g = 0.0f;
    float b = 0.0f;
    float a = 1.0f; 
    if( ok )
    {
      ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 0 ), r, errorStr ) ;
      ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 1 ), g, errorStr ) ;
      ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 2 ), b, errorStr ) ;
      if( withAlpha ) ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 3 ), a, errorStr ) ;
      if ( !ok ) 
        errorStr += ". Cannot get one of the OMK::Type::Color argument" ;
    }
    // Normalize in [0, 1] set
    if( 1.0f < r || 1.0f < g || 1.0f < b )
    {
      r /= 255.0f;
      g /= 255.0f;
      b /= 255.0f;
    }
    ok = ok 
      && ( 0.0f <= r ) && ( r <= 1.0f )
      && ( 0.0f <= g ) && ( g <= 1.0f )
      && ( 0.0f <= b ) && ( b <= 1.0f )
      && ( 0.0f <= a ) && ( a <= 1.0f ) ;
    if ( !ok && errorStr.empty() )
      errorStr = "One of the OMK::Type::Color argument is not in the good range [0.0 1.0] or [0 255]" ;
        
    if( ok )
    { // Create the color
      color = OMK::Type::Color( r, g, b, a ) ;
    }
    return ok;
  }
  // string format
  return getTxtValue( nodeValue->getAssociatedString(), color );
}


//-------------------------------------------------------------------
// Get value for a Transform
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     OMK::Type::Transform & transform,
                                     std::string& errorStr )
{
  if( !nodeValue )
    return false; // Error no valid node
  
  bool ok = false ;
  if( nodeValue->getAssociatedString()[0] == '{' ) 
  {
    transform = OMK::Type::Transform::sk_identity ;
  
    // array format => read it 
    // rgb or rgba
    ok = ( 1 <= nodeValue->getNumberOfSubItems() 
        && nodeValue->getNumberOfSubItems() <= 3 ); 
    if ( !ok && errorStr.empty() ) 
    {
      errorStr = "Bad format of Transform (need 1 to 3 arguments)" ;
    }
    // get the 3 sub nodes for translation, rotation and scale
    const ConfigurationParameterDescriptor * translationNode = 
        nodeValue->getSubDescriptorByPosition( 0 ) ;
    const ConfigurationParameterDescriptor * rotationNode    = 
        ( 2 <= nodeValue->getNumberOfSubItems() ) ? nodeValue->getSubDescriptorByPosition( 1 ) : 0 ;
    const ConfigurationParameterDescriptor * scaleNode       = 
        ( 3 == nodeValue->getNumberOfSubItems() ) ? nodeValue->getSubDescriptorByPosition( 2 ) : 0 ;
    
    // Translation
    Wm4::Vector3f translation = Wm4::Vector3f::ZERO ;
    if( ok && translationNode )
    {
      ok = 3 == translationNode->getNumberOfSubItems() ;
      float t[ 3 ] = { 0.0f, 0.0f, 0.0f } ;
      for ( int i = 0 ; i < 3 && ok ; i++ ) 
      {
        ok = ok && getValue( translationNode->getSubDescriptorByPosition( i ), t[ i ], errorStr ) ;
      }
      if ( ok ) 
      {
        transform.setTranslate( Wm4::Vector3f( t ) ) ;
      }
      else
      {
        errorStr += ". Cannot get one of the translation of the Transform argument" ;
      }
    }
    
    // Rotation
    Wm4::Matrix3f rotation = Wm4::Matrix3f::IDENTITY ;
    if( ok && rotationNode )
    {
      float rm[ 9 ] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f } ;
      // check for 3 or 9 items
      int nbItems = rotationNode->getNumberOfSubItems() ;
      ok = 9 == nbItems || 4 == nbItems || 3 == nbItems ;
      char angleType( 'r' );
      if( 4 == nbItems )
      { // The 4th flag is the type
        nbItems = 3 ; // only 3 numeric values 
        getValue( rotationNode->getSubDescriptorByPosition( 3 ), angleType, errorStr ) ;
      }
      // gets the items value
      for ( int i = 0 ; i < nbItems && ok ; i++ )
      {
        ok = ok && getValue( rotationNode->getSubDescriptorByPosition( i ), rm[ i ], errorStr ) ;
      }
      if( 9 == nbItems )
      { // Rotation matrix
        if ( ok ) 
        {
          rotation = Wm4::Matrix3f( rm, true ) ; // Row major
          transform.setRotate( rotation ) ;
        }
        else
        {
          errorStr += ". Cannot get one of the rotation matrix of the Transform argument" ;
        }
      }
      else if( 3 == nbItems )
      { // Rotation angles Euler Radian 
        if ( ok ) 
        {
          switch( angleType )
          {
          case 'r' : // Radian nothing to do
            break; 
          case 'd' : // Degrees
            rm[ 0 ] *= Wm4::Mathf::DEG_TO_RAD ;
            rm[ 1 ] *= Wm4::Mathf::DEG_TO_RAD ;
            rm[ 2 ] *= Wm4::Mathf::DEG_TO_RAD ;
            break ;
          case 'g' : // Grad
            rm[ 0 ] *= Wm4::Mathf::DEG_TO_RAD * 0.9f ;
            rm[ 1 ] *= Wm4::Mathf::DEG_TO_RAD * 0.9f ;
            rm[ 2 ] *= Wm4::Mathf::DEG_TO_RAD * 0.9f ;
            break ;
          case 'p' : // Fraction of pi
            rm[ 0 ] *= Wm4::Mathf::PI ;
            rm[ 1 ] *= Wm4::Mathf::PI ;
            rm[ 2 ] *= Wm4::Mathf::PI ;
            break ;
          default :
            ok = false ;
            errorStr += "Unknow type of angle (only 'r', 'd', 'g' and 'p' are allowed)" ;
          }
          rotation.FromEulerAnglesXYZ( rm[ 0 ] ,  
                                       rm[ 1 ] , 
                                       rm[ 2 ] );  // Euler angles
          transform.setRotate( rotation ) ;
        }
        else
        {
          errorStr += ". Cannot get one of the rotation Euler angle of the Transform argument" ;
        }
      }
      else
      {
        errorStr += "Cannot get the rotation of the Transform argument" ;
      }
    }
    
    // Scale
    Wm4::Vector3f scale = Wm4::Vector3f::ONE ;
    if( ok && scaleNode )
    {
      int nbItems = scaleNode->getNumberOfSubItems() ;
      ok = 1 == nbItems || 3 == nbItems ;
      float s[ 3 ] = { 1.0f, 1.0f, 1.0f } ;
      for ( int i = 0 ; i < nbItems && ok ; i++ )
      {
        ok = ok && getValue( scaleNode->getSubDescriptorByPosition( i ), s[ i ], errorStr ) ;
      }
      if( 1 == nbItems )
      { // Uniform scale
        if ( ok ) 
        {
          transform.setUniformScale( s[ 0 ] ) ;
        }
        else
        {
          errorStr += ". Cannot get the uniform scale of the Transform argument" ;
        }
      }
      else if( 3 == nbItems )
      { // No uniform scale
        if ( ok ) 
        {
          transform.setScale( Wm4::Vector3f( s ) ) ;
        }
        else
        {
          errorStr += ". Cannot get one of the scale of the Transform argument" ;
        }
      }
      else
      {
        errorStr += "Cannot get the scale of the Transform argument" ;
      }
    }
  }
  else
  {
    ok = getTxtValue( nodeValue->getAssociatedString(), transform ) ;
  }
  transform.updateFlags() ;
  
  // string format
  return ok ;
}
//-------------------------------------------------------------------
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const bool& value,
                                                                      std::string& errorStr )
{
  return new UniqueConfigurationParameter( value ? "true" : "false" ) ;
}

//-------------------------------------------------------------------
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const OMK::Type::Color& color,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter() ;
  bool ok = true ;
  std::string text ;
  ok = ok && setTxtValue( text, color.getR() ) ;
  if( ok ) node->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
  ok = ok && setTxtValue( text, color.getG() ) ;
  if( ok ) node->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
  ok = ok && setTxtValue( text, color.getB() ) ;
  if( ok ) node->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
  if( color.getA() != 1.0f )
  {
    ok = ok && setTxtValue( text, color.getA() ) ;
    if( ok ) node->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
  }
  if( !ok ) 
  {
    delete node ;
    node = 0 ;
    errorStr = "Unable to convert the color into a node" ;
  }
  return node ;
}

//-------------------------------------------------------------------
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const OMK::Type::Transform& transf,
                                                                      std::string& errorStr )
{
  bool ok = true ;
  bool needScale = !transf.isUniformScale() || transf.getUniformScale() != 1.0f ;
  std::string text ;
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter() ;
  // Translate
  {
    ConfigurationParameterDescriptor *translateNode = new MultipleConfigurationParameter() ;
    node->appendSubDescriptor( translateNode ) ;
    for( int i = 0 ; i < 3 ; i++ )
    {
      ok = ok && setTxtValue( text, transf.getTranslate()[ i ] ) ;
      if( ok ) translateNode->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
    }
  }
  // Rotate
  if( ok && ( needScale || transf.getRotate() != Wm4::Matrix3f::IDENTITY ) )
  {
    ConfigurationParameterDescriptor *rotateNode = new MultipleConfigurationParameter() ;
    node->appendSubDescriptor( rotateNode ) ;
    for( int r = 0 ; r < 3 ; r++ )
    {
      for( int c = 0 ; c < 3 ; c++ )
      {
        ok = ok && setTxtValue( text, transf.getRotate()[r][c] ) ;
        if( ok ) rotateNode->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
      }
    }
  }
  // Scale
  if( ok && needScale )
  {
    ConfigurationParameterDescriptor *scaleNode = new MultipleConfigurationParameter() ;
    node->appendSubDescriptor( scaleNode ) ;
    for( int i = 0 ; i < ( transf.isUniformScale() ? 1 : 3 ) ; i++ )
    {
      ok = ok && setTxtValue( text, transf.getScale()[ i ] ) ;
      if( ok ) scaleNode->appendSubDescriptor( new UniqueConfigurationParameter( text ) ) ;
    }
  }
  // ok ?
  if( !ok ) 
  {
    errorStr = "Unable to convert the tranform into a node" ;
    delete node ;
    node = 0 ;
  }
  return node ;
}
//-------------------------------------------------------------------
ConfigurationParameterDescriptor * ParametersAccessor::set(
                               ConfigurationParameterDescriptor *& node,
                               const std::string& name,
                               ConfigurationParameterDescriptor * newNode ) 
{
  if( newNode )
  {
    if( !node ) node = new MultipleConfigurationParameter() ;
    node->appendSubDescriptorNamed( name, newNode ) ;
  }
  else
  {
    OMERROR( "Warning in ParametersAccessor::Set with parameter [" + name + "]" << std::endl 
        << ">>> :-( The node to append is null" ) ;
  }
  return newNode ;
}

---