--- /dev/null
+// =========================================================================
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// =========================================================================
+
+$include "Value.e"
+
+#include <cpPlugins/Pipeline.h>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/tokenizer.hpp>
+
+// -------------------------------------------------------------------------
+cpPlugins::Pipeline::TAdjMatrix::
+TAdjMatrix( )
+{
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::Pipeline::TAdjMatrix::
+~TAdjMatrix( )
+{
+}
+
+// -------------------------------------------------------------------------
+bool cpPlugins::Pipeline::TAdjMatrix::
+HasConnection(
+ const std::string& oObj, const std::string& dObj,
+ const std::string& oPort, const std::string& dPort
+ ) const
+{
+ TMatrix::const_iterator m = this->m_Matrix.find( oObj );
+ if( m != this->m_Matrix.end( ) )
+ {
+ TRow::const_iterator r = m->second.find( dObj );
+ if( r != m->second.end( ) )
+ return( r->second.find( TEdge( oPort, dPort ) ) != r->second.end( ) );
+ else
+ return( false );
+ }
+ else
+ return( false );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::Pipeline::TAdjMatrix::
+TEdges& cpPlugins::Pipeline::TAdjMatrix::
+operator()( const std::string& o, const std::string& d )
+{
+ TMatrix::iterator m = this->m_Matrix.find( o );
+ if( m != this->m_Matrix.end( ) )
+ {
+ TRow::iterator r = m->second.find( d );
+ if( r != m->second.end( ) )
+ return( r->second );
+ } // end if
+
+ // If not found...
+ this->m_Matrix[ o ][ d ] = TEdges( );
+ return( this->operator()( o, d ) );
+}
+
+// -------------------------------------------------------------------------
+const cpPlugins::Pipeline::TAdjMatrix::
+TEdges& cpPlugins::Pipeline::TAdjMatrix::
+operator()( const std::string& o, const std::string& d ) const
+{
+ TMatrix::const_iterator m = this->m_Matrix.find( o );
+ if( m != this->m_Matrix.end( ) )
+ {
+ TRow::const_iterator r = m->second.find( d );
+ if( r != m->second.end( ) )
+ return( r->second );
+ } // end if
+
+ // If not found...
+ cpPluginsErrorMacro( << "Connection not found." );
+}
+
+// -------------------------------------------------------------------------
+template< >
+void cpPlugins::Pipeline::TAdjMatrix::
+SaveXML( boost::property_tree::ptree* node ) const
+{
+ TMatrix::const_iterator m = this->m_Matrix.begin( );
+ for( ; m != this->m_Matrix.end( ); ++m )
+ {
+ TRow::const_iterator r = m->second.begin( );
+ for( ; r != m->second.end( ); r++ )
+ {
+ for( const TEdge& e: r->second )
+ {
+ boost::property_tree::ptree c;
+ c.put( "<xmlattr>.from", e.first + "@" + m->first );
+ c.put( "<xmlattr>.to", e.second + "@" + r->first );
+ node->add_child( "pipeline.connection", c );
+
+ } // end for
+ } // end for
+ } // end for
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+Clear( )
+{
+ // TODO
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::ProcessObject* cpPlugins::Pipeline::
+CreateNode( const std::string& class_name, const std::string& node_name )
+{
+ // Create object
+ cpPlugins::ProcessObject::SharedPtr p = this->m_Mgr.Create( class_name );
+ if( !p )
+ cpPluginsErrorMacro(
+ << "Something went wrong creating an object of type \""
+ << class_name << "\""
+ );
+
+ // Assign an unique name to it
+ std::string u = ( node_name == "" )? class_name: node_name;
+ while( !( this->m_Nodes.insert( TNodes::value_type( u, p ) ).second ) )
+ u += "_";
+ p->SetName( u );
+ p->SetPipeline( this );
+ p->SetExecutionDebug( this->GetExecutionDebug( ) );
+
+ // Connect parameters
+ std::set< std::string > names;
+ {{#t}}
+ names = p->Get{{t}}ValueNames( );
+ for( const std::string& n: names )
+ this->Configure{{t}}Value( n + "@" + u, p->Get{{t}}ValueTemplate( n ) );
+ names.clear( );
+ {{/t}}
+
+ // TODO: connect set/sequences
+
+ return( p.get( ) );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::ProcessObject* cpPlugins::Pipeline::
+GetNode( const std::string& name )
+{
+ TNodes::iterator i = this->m_Nodes.find( name );
+ if( i != this->m_Nodes.end( ) )
+ return( i->second.get( ) );
+ else
+ return( NULL );
+}
+
+// -------------------------------------------------------------------------
+const cpPlugins::ProcessObject* cpPlugins::Pipeline::
+GetNode( const std::string& name ) const
+{
+ TNodes::const_iterator i = this->m_Nodes.find( name );
+ if( i != this->m_Nodes.end( ) )
+ return( i->second.get( ) );
+ else
+ return( NULL );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+Connect(
+ const std::string& oObj, const std::string& dObj,
+ const std::string& oPort, const std::string& dPort
+ )
+{
+ TNodes::iterator oIt = this->m_Nodes.find( oObj );
+ TNodes::iterator dIt = this->m_Nodes.find( dObj );
+ TNodes::iterator eIt = this->m_Nodes.end( );
+ if( oIt == eIt || dIt == eIt )
+ cpPluginsErrorMacro( this, << "Connection not possible." );
+ if( this->m_AdjMatrix.HasConnection( oObj, dObj, oPort, dPort ) )
+ return;
+
+ // Check destination node
+ cpPlugins::ProcessObject::SharedPtr dest = dIt->second;
+ if( !dest )
+ cpPluginsErrorMacro(
+ this, << "Invalid destination \"" << dObj << "\"."
+ );
+
+ // Process source node
+ cpPlugins::Filter* src = oIt->second->Cast< cpPlugins::Filter >( );
+ if( src == NULL )
+ this->_Connect(
+ oIt->second->Cast< cpPlugins::Functor >( ), oPort, dest.get( ), dPort
+ );
+ else
+ this->_Connect( src, oPort, dest.get( ), dPort );
+
+ // Update adjacency matrix
+ this->m_AdjMatrix( oObj, dObj ).insert( TEdge( oPort, dPort ) );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+Connect( const std::string& src, const std::string& dest )
+{
+ std::string oObj, dObj, oPort, dPort;
+ Self::_ParseComponentName( src, oObj, oPort );
+ Self::_ParseComponentName( dest, dObj, dPort );
+ this->Connect( oObj, dObj, oPort, dPort );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+LoadXML( const std::string& fname )
+{
+ boost::property_tree::ptree xml;
+ boost::property_tree::read_xml( fname, xml );
+
+ // Check for a single pipeline
+ const boost::property_tree::ptree* pipeline = NULL;
+ for( const boost::property_tree::ptree::value_type& v: xml )
+ {
+ if( v.first == "pipeline" )
+ {
+ if( pipeline != NULL )
+ cpPluginsErrorMacro( << "Multiple pipelines are not supported." );
+ pipeline = &( v.second );
+
+ } // end if
+ } // end for
+
+ // Ok, seems ok to reset current pipeline
+ this->Clear( );
+
+ // Get description
+ boost::optional< std::string > desc =
+ pipeline->get_optional< std::string >( "<xmlattr>.desc" );
+ if( desc )
+ this->m_Description = desc.get( );
+
+ // Load nodes
+ for( const boost::property_tree::ptree::value_type& node: *pipeline )
+ {
+ if( node.first == "node" )
+ {
+ std::string name = node.second.get< std::string >( "<xmlattr>.name" );
+ std::string cname = node.second.get< std::string >( "<xmlattr>.class" );
+ cpPlugins::ProcessObject* n = this->CreateNode( cname, name );
+ n->LoadXML( node );
+
+ } // end if
+ } // end for
+
+ // Load connections
+ for( const boost::property_tree::ptree::value_type& c: *pipeline )
+ if( c.first == "connection" )
+ this->Connect(
+ c.second.get< std::string >( "<xmlattr>.from" ),
+ c.second.get< std::string >( "<xmlattr>.to" )
+ );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+SaveXML( const std::string& fname ) const
+{
+ boost::property_tree::ptree d;
+ if( this->m_Description != "" )
+ d.put( "pipeline.<xmlattr>.desc", this->m_Description );
+
+ // Save nodes
+ TNodes::const_iterator n = this->m_Nodes.begin( );
+ for( ; n != this->m_Nodes.end( ); ++n )
+ n->second->SaveXML( &d );
+
+ // Save connections
+ this->m_AdjMatrix.SaveXML( &d );
+
+ // Real write
+ boost::property_tree::xml_writer_settings< std::string > s( ' ', 2 );
+ boost::property_tree::write_xml( fname, d, std::locale( ), s );
+}
+
+// -------------------------------------------------------------------------
+bool cpPlugins::Pipeline::
+GetExecutionDebug( ) const
+{
+ return( this->m_PipelineExecutionDebug );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+SetExecutionDebug( bool d )
+{
+ this->m_PipelineExecutionDebug = d;
+ for( TNodes::value_type& n: this->m_Nodes )
+ n.second->SetExecutionDebug( d );
+}
+
+// -------------------------------------------------------------------------
+{{#t}}
+void cpPlugins::Pipeline::
+Modified{{t}}Value( const std::string& name )
+{
+ // Guess information
+ std::string n, v;
+ Self::_ParseComponentName( name, n, v );
+
+ // Find node
+ TNodes::iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+
+ // Get configured value and continue
+ node->second->Set{{t}}Value( v, this->Get{{t}}Value( name ) );
+ this->Superclass::Modified{{t}}Value( name );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+Modified{{t}}Set( const std::string& name )
+{
+ std::cout << "Modified{{t}}Set: " << name << std::endl;
+ this->Superclass::Modified{{t}}Set( name );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+Modified{{t}}Sequence( const std::string& name )
+{
+ std::cout << "Modified{{t}}Sequence: " << name << std::endl;
+ this->Superclass::Modified{{t}}Sequence( name );
+}
+{{/t}}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+ModifiedChoice( const std::string& name )
+{
+ std::cout << "ModifiedChoice: " << name << std::endl;
+ this->Superclass::ModifiedChoice( name );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+DefineInput(
+ const std::string& input, const std::string& node, const std::string& port
+ )
+{
+ if(
+ this->m_InputRelations.insert(
+ TPortRelations::value_type( input, TEdge( node, port ) )
+ ).second
+ )
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+SetInput( const std::string& name, cpPlugins::DataObject* data )
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_InputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ node->second->SetInput( o, data );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::DataObject* cpPlugins::Pipeline::
+GetInput( const std::string& name, const unsigned int id )
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_InputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ return( node->second->GetInput( o, id ) );
+}
+
+// -------------------------------------------------------------------------
+const cpPlugins::DataObject* cpPlugins::Pipeline::
+GetInput( const std::string& name, const unsigned int id ) const
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_InputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::const_iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ return( node->second->GetInput( o, id ) );
+}
+
+// -------------------------------------------------------------------------
+bool cpPlugins::Pipeline::
+HasInput( const std::string& name ) const
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_InputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::const_iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ return( node->second->HasInput( n ) );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+DefineOutput(
+ const std::string& output, const std::string& node, const std::string& port
+ )
+{
+ if(
+ this->m_OutputRelations.insert(
+ TPortRelations::value_type( output, TEdge( node, port ) )
+ ).second
+ )
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::DataObject* cpPlugins::Pipeline::
+GetOutput( const std::string& name )
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_OutputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ cpPlugins::Filter* f = node->second->Cast< cpPlugins::Filter >( );
+ if( f != NULL )
+ return( f->GetOutput( o ) );
+ else
+ cpPluginsErrorMacro(
+ this, << "Node \"" << n << "\" does not have outputs."
+ );
+}
+
+// -------------------------------------------------------------------------
+const cpPlugins::DataObject* cpPlugins::Pipeline::
+GetOutput( const std::string& name ) const
+{
+ // Guess information
+ std::string n, o;
+ TPortRelations::const_iterator rIt = this->m_OutputRelations.find( name );
+ if( rIt != this->m_OutputRelations.end( ) )
+ {
+ n = rIt->second.first;
+ o = rIt->second.second;
+ }
+ else
+ Self::_ParseComponentName( name, n, o );
+
+ // Find node
+ TNodes::const_iterator node = this->m_Nodes.find( n );
+ if( node == this->m_Nodes.end( ) )
+ cpPluginsErrorMacro(
+ this, << "Unknown node \"" << n << "\"."
+ );
+ const cpPlugins::Filter* f = node->second->Cast< cpPlugins::Filter >( );
+ if( f != NULL )
+ return( f->GetOutput( o ) );
+ else
+ cpPluginsErrorMacro(
+ this, << "Node \"" << n << "\" does not have outputs."
+ );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::Pipeline::
+Pipeline( )
+ : Superclass( ),
+ m_Description( "" ),
+ m_PipelineExecutionDebug( false )
+{
+ this->m_Mgr.Configure( );
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::Pipeline::
+~Pipeline( )
+{
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+_GenerateData( )
+{
+ for( TNodes::value_type& v: this->m_Nodes )
+ v.second->Cast< cpPlugins::ProcessObject >( )->Update( );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+_Connect(
+ Filter* src, const std::string& srcPort,
+ ProcessObject* dest, const std::string& destPort
+ )
+{
+ if( src->HasOutValue( srcPort ) && dest->HasInValue( destPort ) )
+ {
+ }
+ else if( src->HasOutput( srcPort ) && dest->HasInput( destPort ) )
+ dest->SetInput( destPort, src->GetOutput( srcPort ) );
+ else
+ cpPluginsErrorMacro(
+ this,
+ << "Invalid connection from \"" << src->GetName( ) << "\" to \""
+ << dest->GetName( ) << " (" << srcPort << "->" << destPort << ")"
+ );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+_Connect(
+ Functor* functor, const std::string& functorValue,
+ ProcessObject* dest, const std::string& destValue
+ )
+{
+ if( functorValue == "Functor" )
+ {
+ Filter* filter = dynamic_cast< Filter* >( dest );
+ if( filter != NULL )
+ filter->SetFunctor( destValue, functor );
+ else
+ cpPluginsErrorMacro( this, << "Invalid functor connection." );
+ }
+ else
+ {
+ if(
+ functor->HasOutValue( functorValue ) && dest->HasInValue( destValue )
+ )
+ dest->SetInValuePtr(
+ destValue, functor->GetOutValuePtr( functorValue )
+ );
+ else
+ cpPluginsErrorMacro(
+ this,
+ << "Invalid connection from \"" << functor->GetName( ) << "\" to \""
+ << dest->GetName( ) << " (" << functorValue << "->"
+ << destValue << ")"
+ );
+ } // end if
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Pipeline::
+_ParseComponentName(
+ const std::string& name,
+ std::string& node,
+ std::string& component
+ )
+{
+ typedef boost::char_separator< char > _TSep;
+ typedef boost::tokenizer< _TSep > _TTok;
+
+ // Get parameter info
+ _TTok tok( name, _TSep( "@" ) );
+ std::vector< std::string > tokens;
+ for( _TTok::const_iterator tIt = tok.begin( ); tIt != tok.end( ); ++tIt )
+ tokens.push_back( *tIt );
+
+ // Try another distribution
+ if( tokens.size( ) != 2 )
+ {
+ } // end if
+
+ // Nothing else to do?
+ if( tokens.size( ) != 2 )
+ cpPluginsErrorMacro(
+ << "Unknown input value parameter \"" << name << "\"."
+ );
+
+ // Names
+ component = tokens[ 0 ];
+ node = tokens[ 1 ];
+}
+
+// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / cpPlugins.git / blobdiff