}
else if( mdata != NULL )
{
+ if( this->m_UI->Viewer->AddData( mdata, data_name ) )
+ {
+ this->m_UI->Viewer->SetDataColor( data_name, 1, 0, 0 );
+ this->_Block( );
+ this->m_UI->Viewer->ShowData( data_name );
+ this->_UnBlock( );
+
+ } // fi
}
else
QMessageBox::critical(
// Write instantiations
for( auto combIt = combs.begin( ); combIt != combs.end( ); ++combIt )
{
- char* buffer = new char[ combIt->size( ) ];
+ char* buffer = new char[ combIt->size( ) + 1 ];
std::strcpy( buffer, combIt->c_str( ) );
+ buffer[ combIt->size( ) ] = '\0';
char* tok = std::strtok( buffer, "#" );
std::map< std::string, std::string > real_instance;
for( auto lIt = li.begin( ); lIt != li.end( ); ++lIt )
tok = std::strtok( NULL, "#" );
} // rof
+ delete buffer;
std::string real_name = name;
auto riIt = real_instance.begin( );
for( ; riIt != real_instance.end( ); ++riIt )
Replace( real_name, riIt->first, riIt->second );
all_real_classes.push_back( real_name );
- delete buffer;
} // rof
}
--- /dev/null
+#ifndef __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+#define __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+
+#include <vtkPolyDataAlgorithm.h>
+#include <itkImageBase.h>
+
+namespace cpExtensions
+{
+ namespace Visualization
+ {
+ /**
+ */
+ template< class _TPolyLine >
+ class PolyLineParametricPathToPolyData
+ : public vtkPolyDataAlgorithm
+ {
+ public:
+ typedef PolyLineParametricPathToPolyData Self;
+
+ typedef _TPolyLine TPolyLine;
+ typedef itk::ImageBase< TPolyLine::PathDimension > TImage;
+
+ public:
+ vtkTypeMacro( PolyLineParametricPathToPolyData, vtkPolyDataAlgorithm );
+
+ public:
+ static Self* New( );
+
+ const TPolyLine* GetInput( ) const;
+ const TImage* GetReferenceImage( ) const;
+ void SetInput( const TPolyLine* pl );
+ void SetReferenceImage( const TImage* i );
+
+ protected:
+ PolyLineParametricPathToPolyData( );
+ virtual ~PolyLineParametricPathToPolyData( );
+
+ int RequestData(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ );
+ int RequestInformation(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ );
+
+ private:
+ // Purposely not implemented
+ PolyLineParametricPathToPolyData( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ const TPolyLine* m_PolyLine;
+ const TImage* m_ReferenceImage;
+ };
+
+ } // ecapseman
+
+} // ecapseman
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include <cpExtensions/Visualization/PolyLineParametricPathToPolyData.hxx>
+#endif // ITK_MANUAL_INSTANTIATION
+
+#endif // __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__HXX__
+#define __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__HXX__
+
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+typename
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+Self*
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+New( )
+{
+ return( new Self( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+const typename
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+TPolyLine*
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+GetInput( ) const
+{
+ return( this->m_PolyLine );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+const typename
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+TImage*
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+GetReferenceImage( ) const
+{
+ return( this->m_ReferenceImage );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+void
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+SetInput( const TPolyLine* pl )
+{
+ if( this->m_PolyLine != pl )
+ {
+ this->m_PolyLine = pl;
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+void
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+SetReferenceImage( const TImage* i )
+{
+ if( this->m_ReferenceImage != i )
+ {
+ this->m_ReferenceImage = i;
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+PolyLineParametricPathToPolyData( )
+ : vtkPolyDataAlgorithm( ),
+ m_PolyLine( NULL ),
+ m_ReferenceImage( NULL )
+{
+ this->SetNumberOfInputPorts( 0 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+~PolyLineParametricPathToPolyData( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+int
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+RequestData(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ )
+{
+ static const unsigned int dim = _TPolyLine::PathDimension;
+
+ if( this->m_PolyLine == NULL )
+ return( 0 );
+
+ // Get output
+ vtkInformation* info = output->GetInformationObject( 0 );
+ vtkPolyData* out = vtkPolyData::SafeDownCast(
+ info->Get( vtkDataObject::DATA_OBJECT( ) )
+ );
+
+ // Get input data
+ auto lst = this->m_PolyLine->GetVertexList( );
+
+ // Prepare points
+ vtkPoints* points = out->GetPoints( );
+ if( points == NULL )
+ {
+ points = vtkPoints::New( );
+ out->SetPoints( points );
+ points->Delete( );
+
+ } // fi
+ points->SetNumberOfPoints( lst->Size( ) );
+
+ // Prepare cells
+ vtkSmartPointer< vtkCellArray > verts =
+ vtkSmartPointer< vtkCellArray >::New( );
+ vtkSmartPointer< vtkCellArray > lines =
+ vtkSmartPointer< vtkCellArray >::New( );
+
+ for( unsigned int i = 0; i < lst->Size( ); ++i )
+ {
+ auto idx = lst->GetElement( i );
+ if( this->m_ReferenceImage != NULL )
+ {
+ typename TImage::PointType pnt;
+ this->m_ReferenceImage->TransformContinuousIndexToPhysicalPoint( idx, pnt );
+ if( dim == 1 )
+ points->SetPoint( i, pnt[ 0 ], 0, 0 );
+ else if( dim == 2 )
+ points->SetPoint( i, pnt[ 0 ], pnt[ 1 ], 0 );
+ else
+ points->SetPoint( i, pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
+ }
+ else
+ {
+ if( dim == 1 )
+ points->SetPoint( i, idx[ 0 ], 0, 0 );
+ else if( dim == 2 )
+ points->SetPoint( i, idx[ 0 ], idx[ 1 ], 0 );
+ else
+ points->SetPoint( i, idx[ 0 ], idx[ 1 ], idx[ 2 ] );
+
+ } // fi
+ verts->InsertNextCell( 1 );
+ verts->InsertCellPoint( i );
+ if( i > 0 )
+ {
+ lines->InsertNextCell( 2 );
+ lines->InsertCellPoint( i - 1 );
+ lines->InsertCellPoint( i );
+
+ } // fi
+
+ } // rof
+ out->SetPoints( points );
+ out->SetVerts( verts );
+ out->SetLines( lines );
+ return( 1 );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPolyLine >
+int
+cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPolyLine >::
+RequestInformation(
+ vtkInformation* information,
+ vtkInformationVector** input,
+ vtkInformationVector* output
+ )
+{
+ vtkInformation* info = output->GetInformationObject( 0 );
+ /* TODO
+ info->Set(
+ vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES( ), -1
+ );
+ */
+
+ if( this->m_PolyLine != NULL && this->m_ReferenceImage != NULL )
+ {
+ /* TODO
+ typename C::TScalar len = this->m_RGC->GetTotalLength( );
+ typename C::TScalar s0 = this->m_RGC->Gets0( );
+ typename C::TPoint p0 = this->m_RGC->Axis( s0 );
+ typename C::TPoint p1 = this->m_RGC->Axis( s0 + len );
+
+ info->Set(
+ vtkStreamingDemandDrivenPipeline::WHOLE_BOUNDING_BOX( ),
+ double( p0[ 0 ] ), double( p1[ 0 ] ),
+ double( p0[ 1 ] ), double( p1[ 1 ] ),
+ double( p0[ 2 ] ), double( p1[ 2 ] )
+ );
+ */
+
+ } // fi
+ return( 1 );
+}
+
+#endif // __CPEXTENSIONS__VISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__HXX__
+
+// eof - $RCSfile$
cpPlugins_ITKInstances_Image
cpPlugins_ITKInstances_ImageIterators
cpPlugins_ITKInstances_ImageFilters
+ cpPlugins_ITKInstances_Paths
+ cpPlugins_ITKInstances_Mesh
${VTK_LIBRARIES}
)
IF(NOT WIN32)
--- /dev/null
+#include <cpPlugins/Mesh.h>
+
+#include <itkMesh.h>
+#include <itkQuadEdgeMesh.h>
+#include <itkLineCell.h>
+#include <itkTriangleCell.h>
+#include <itkPolygonCell.h>
+
+#include <vtkPolyData.h>
+
+// -------------------------------------------------------------------------
+void cpPlugins::Mesh::
+SetITK( itk::LightObject* o )
+{
+ this->Superclass::SetITK( o );
+ bool r = this->_ITK_2_VTK< itk::Mesh< float, 2 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::Mesh< double, 2 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::Mesh< float, 3 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::Mesh< double, 3 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::QuadEdgeMesh< float, 2 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::QuadEdgeMesh< double, 2 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::QuadEdgeMesh< float, 3 > >( o );
+ if( !r ) r = this->_ITK_2_VTK< itk::QuadEdgeMesh< double, 3 > >( o );
+}
+
+// -------------------------------------------------------------------------
+void cpPlugins::Mesh::
+SetVTK( vtkObjectBase* o )
+{
+ typedef itk::Mesh< double, 3 > _TMesh;
+ typedef _TMesh::CellType _TCell;
+ typedef _TCell::CellAutoPointer _TCellAutoPointer;
+ typedef itk::LineCell< _TCell > _TLine;
+ typedef itk::TriangleCell< _TCell > _TTriangle;
+ typedef itk::PolygonCell< _TCell > _TPolygon;
+
+ vtkPolyData* mesh = dynamic_cast< vtkPolyData* >( o );
+ if( mesh == NULL )
+ {
+ this->m_ITKObject = NULL;
+ this->Modified( );
+ return;
+
+ } // fi
+
+ if( this->m_VTKObject.GetPointer( ) != mesh )
+ {
+ this->m_VTKObject = mesh;
+
+ // Copy points
+ /* TODO
+ _TMesh::Pointer imesh = _TMesh::New( );
+ double point[ 3 ];
+ for( long i = 0; i < mesh->GetNumberOfPoints( ); ++i )
+ {
+ mesh->GetPoint( i, point );
+ _TMesh::PointType ipoint;
+ ipoint[ 0 ] = point[ 0 ];
+ ipoint[ 1 ] = point[ 1 ];
+ ipoint[ 2 ] = point[ 2 ];
+ imesh->SetPoint( i, ipoint );
+
+ } // rof
+
+ // Copy cells
+ for( long i = 0; i < mesh->GetNumberOfCells( ); ++i )
+ {
+ auto cell = mesh->GetCell( i );
+ long nPoints = cell->GetNumberOfPoints( );
+ _TCellAutoPointer icell;
+ if( nPoints == 2 )
+ {
+ icell.TakeOwnership( new _TLine );
+ icell->SetPointId( 0, cell->GetPointId( 0 ) );
+ icell->SetPointId( 1, cell->GetPointId( 1 ) );
+ }
+ else if( nPoints == 3 )
+ {
+ icell.TakeOwnership( new _TTriangle );
+ icell->SetPointId( 0, cell->GetPointId( 0 ) );
+ icell->SetPointId( 1, cell->GetPointId( 1 ) );
+ icell->SetPointId( 2, cell->GetPointId( 2 ) );
+ }
+ else if( nPoints > 3 )
+ {
+ _TPolygon* polygon = new _TPolygon( );
+ for( long j = 0; j < nPoints; ++j )
+ polygon->AddPointId( cell->GetPointId( j ) );
+ icell.TakeOwnership( polygon );
+
+ } // fi
+ imesh->SetCell( imesh->GetNumberOfCells( ), icell );
+
+ } // rof
+
+ this->m_ITKObject = imesh;
+ */
+ this->m_ITKObject = NULL; // TODO: replace this
+ this->Modified( );
+
+ } // fi
+}
+// -------------------------------------------------------------------------
+cpPlugins::Mesh::
+Mesh( )
+ : Superclass( )
+{
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::Mesh::
+~Mesh( )
+{
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __CPPLUGINS__MESH__H__
+#define __CPPLUGINS__MESH__H__
+
+#include <cpPlugins/DataObject.h>
+
+// Some forward declarations
+class vtkObject;
+
+namespace cpPlugins
+{
+ /**
+ */
+ class cpPlugins_EXPORT Mesh
+ : public DataObject
+ {
+ public:
+ typedef Mesh Self;
+ typedef DataObject Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( Mesh, DataObject );
+ cpPlugins_Id_Macro( Mesh, Object );
+
+ public:
+ virtual void SetITK( itk::LightObject* o ) override;
+ virtual void SetVTK( vtkObjectBase* o ) override;
+
+ protected:
+ Mesh( );
+ virtual ~Mesh( );
+
+ template< class M >
+ inline bool _ITK_2_VTK( itk::LightObject* o );
+
+ private:
+ // Purposely not implemented
+ Mesh( const Self& );
+ Self& operator=( const Self& );
+ };
+
+} // ecapseman
+
+#include <cpPlugins/Mesh.hxx>
+
+#endif // __CPPLUGINS__MESH__H__
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __CPPLUGINS__MESH__HXX__
+#define __CPPLUGINS__MESH__HXX__
+
+#include <map>
+#include <vtkSmartPointer.h>
+#include <vtkCellArray.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+
+// -------------------------------------------------------------------------
+template< class M >
+bool cpPlugins::Mesh::
+_ITK_2_VTK( itk::LightObject* o )
+{
+ M* mesh = dynamic_cast< M* >( o );
+ if( mesh == NULL )
+ return( false );
+
+ long numPoints = mesh->GetNumberOfPoints( );
+ if( numPoints == 0 )
+ return( false );
+
+ vtkSmartPointer< vtkPoints > vpoints =
+ vtkSmartPointer< vtkPoints >::New( );
+ vpoints->SetNumberOfPoints( numPoints );
+ auto points = mesh->GetPoints( );
+
+ // Copy points
+ vtkIdType VTKId = 0;
+ std::map< vtkIdType, long > IndexMap;
+ for( auto i = points->Begin( ); i != points->End( ); ++i, VTKId++ )
+ {
+ IndexMap[ VTKId ] = i->Index( );
+ if( M::PointDimension == 2 )
+ vpoints->SetPoint(
+ VTKId,
+ i->Value( )[ 0 ], i->Value( )[ 1 ], 0
+ );
+ else if( M::PointDimension == 3 )
+ vpoints->SetPoint(
+ VTKId,
+ i->Value( )[ 0 ], i->Value( )[ 1 ], i->Value( )[ 2 ]
+ );
+
+ } // rof
+
+ // Copy cells
+ vtkSmartPointer< vtkCellArray > vcells =
+ vtkSmartPointer< vtkCellArray >::New( );
+ auto cells = mesh->GetCells( );
+ for( auto j = cells->Begin( ); j != cells->End( ); ++j )
+ {
+ auto cell = j->Value( );
+ vcells->InsertNextCell( cell->GetNumberOfPoints( ) );
+ for( auto k = cell->PointIdsBegin( ); k != cell->PointIdsEnd( ); ++k )
+ vcells->InsertCellPoint( IndexMap[ *k ] );
+
+ } // rof
+
+ // Final assignations
+ vtkSmartPointer< vtkPolyData > vmesh =
+ vtkSmartPointer< vtkPolyData >::New( );
+ vmesh->SetPoints( vpoints );
+ vmesh->SetPolys( vcells );
+ this->m_VTKObject = vmesh;
+ this->Modified( );
+ return( true );
+}
+
+#endif // __CPPLUGINS__MESH__HXX__
+
+// eof - $RCSfile$
Image
ImageIterators
ImageFilters
+ Paths
+ Mesh
)
FOREACH(lib_SRC ${libs_SOURCES})
SET(desc_NAME "${lib_SRC}_explicit_description.txt")
cpPlugins_ITKInstances_ImageFilters
cpPlugins_ITKInstances_ImageIterators
)
+TARGET_LINK_LIBRARIES(
+ cpPlugins_ITKInstances_Paths
+ cpPlugins_ITKInstances_Base
+ )
+TARGET_LINK_LIBRARIES(
+ cpPlugins_ITKInstances_Mesh
+ cpPlugins_ITKInstances_Base
+ )
# # ===================================
# # = Integrate all source file names =
--- /dev/null
+#include <cpPlugins_ITKInstances/Mesh.h>
+
+// ...aaand that's all folks!
+
+// eof - $RCSfile$
--- /dev/null
+f cpPlugins_ITKInstances/Base.h
+i itkPointSet.h
+i itkMesh.h
+i itkQuadEdgeMesh.h
+i itkLineCell.h
+i itkPolygonCell.h
+i itkTriangleCell.h
+c itk::VectorContainer< unsigned long, itk::Point< #1 , #2 > >
+c itk::MapContainer< unsigned long , itk::QuadEdgeMeshPoint< #1 , #2 , itk::GeometricalQuadEdge< unsigned long, unsigned long, bool, bool, true > > >
+c itk::PointSet< #1 , #2 >
+c itk::Mesh< #1 , #2 >
+c itk::QuadEdgeMesh< #1 , #2 >
+c #3 < itk::CellInterface< #1 , itk::CellTraitsInfo< #2 , float , float , unsigned long , unsigned long , unsigned long , itk::Point< float , #2 > , itk::VectorContainer< unsigned long , itk::Point< float , #2 > > , std::set< unsigned long , std::less< unsigned long > , std::allocator< unsigned long > > > > >
+a #1 = #floats
+a #2 = #all_visual_dims
+a #3 = itk::LineCell;itk::PolygonCell;itk::TriangleCell
--- /dev/null
+#include <cpPlugins_ITKInstances/Paths.h>
+
+// ...aaand that's all folks!
+
+// eof - $RCSfile$
--- /dev/null
+f cpPlugins_ITKInstances/Base.h
+i itkPolyLineParametricPath.h
+c itk::VectorContainer< unsigned int, itk::ContinuousIndex< double, #1 > >
+c itk::PolyLineParametricPath< #1 >
+a #1 = #all_visual_dims
SUBDIRS(
cpPluginsIO
cpPluginsImageFilters
+ cpPluginsVisualization
cpPluginsWidgets
)
// Configure filter
_TFilter* filter = this->_CreateITK< _TFilter >( );
+ filter->SetInput( image );
/*
- filter->SetInput( image );
filter->SetLowerThreshold( lower_val );
filter->SetUpperThreshold( upper_val );
filter->SetInsideValue( in_val );
filter->SetOutsideValue( out_val );
filter->Update( );
-
- // Connect output
- this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
*/
+
+ // Connect output
+ this->GetOutputData( "Output" )->SetITK( filter->GetOutput( ) );
return( "ImageToHistogramFilter: not ready yet." );
}
--- /dev/null
+SET(lib_NAME cpPluginsVisualization)
+SET(lib_DIR cpPluginsVisualization)
+
+## ===============
+## = Source code =
+## ===============
+
+FILE(GLOB lib_HEADERS_H "*.h")
+FILE(GLOB lib_HEADERS_HPP "*.hpp")
+FILE(GLOB lib_HEADERS_HXX "*.hxx")
+FILE(GLOB lib_SOURCES_C "*.c")
+FILE(GLOB lib_SOURCES_CPP "*.cpp")
+FILE(GLOB lib_SOURCES_CXX "*.cxx")
+
+# ===================================
+# = Integrate all source file names =
+# ===================================
+
+SET(
+ lib_HEADERS
+ ${lib_HEADERS_H}
+ ${lib_HEADERS_HPP}
+ ${lib_HEADERS_HXX}
+ )
+
+SET(
+ lib_SOURCES
+ ${lib_SOURCES_C}
+ ${lib_SOURCES_CPP}
+ ${lib_SOURCES_CXX}
+ )
+
+SET(
+ target_LIBRARIES
+ cpExtensions
+ cpPlugins
+ )
+
+## =====================
+## = Compilation rules =
+## =====================
+
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${lib_NAME}_Host.cxx
+ DEPENDS cpPlugins_HostCreator ${LIB_HEADERS_H}
+ COMMAND cpPlugins_HostCreator ${lib_NAME}_Host.cxx ${lib_HEADERS_H}
+ )
+ADD_LIBRARY(${lib_NAME} SHARED ${lib_NAME}_Host.cxx ${lib_SOURCES})
+SET_TARGET_PROPERTIES(
+ ${lib_NAME} PROPERTIES
+ VERSION "${prj_VER}"
+ SOVERSION "${prj_sVER}"
+ )
+GENERATE_EXPORT_HEADER(
+ ${lib_NAME}
+ BASE_NAME ${lib_NAME}
+ EXPORT_MACRO_NAME ${lib_NAME}_EXPORT
+ EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/plugins/${lib_DIR}/${lib_NAME}_Export.h
+ STATIC_DEFINE ${lib_NAME}_BUILT_AS_STATIC
+ )
+TARGET_LINK_LIBRARIES(${lib_NAME} ${target_LIBRARIES})
+
+## ========================
+## -- Installation rules --
+## ========================
+
+INSTALL(
+ TARGETS ${lib_NAME}
+ RUNTIME DESTINATION bin
+ LIBRARY DESTINATION lib
+ ARCHIVE DESTINATION lib/static
+ )
+
+## eof - $RCSfile$
--- /dev/null
+#include <cpPluginsVisualization/PolyLineParametricPathToPolyData.h>
+#include <cpPlugins/Mesh.h>
+
+#include <cpExtensions/Visualization/PolyLineParametricPathToPolyData.h>
+#include <cpExtensions/Visualization/PolyLineParametricPathToPolyData.hxx>
+#include <itkPolyLineParametricPath.h>
+
+// -------------------------------------------------------------------------
+cpPluginsVisualization::PolyLineParametricPathToPolyData::
+PolyLineParametricPathToPolyData( )
+ : Superclass( )
+{
+ this->_AddInput( "Input" );
+ this->_AddInput( "ReferenceImage", false );
+ this->_AddOutput< cpPlugins::Mesh >( "Output" );
+}
+
+// -------------------------------------------------------------------------
+cpPluginsVisualization::PolyLineParametricPathToPolyData::
+~PolyLineParametricPathToPolyData( )
+{
+}
+
+// -------------------------------------------------------------------------
+std::string cpPluginsVisualization::PolyLineParametricPathToPolyData::
+_GenerateData( )
+{
+ typedef itk::PolyLineParametricPath< 2 > _2DPath;
+ typedef itk::PolyLineParametricPath< 3 > _3DPath;
+
+ auto path = this->GetInputData( "Input" )->GetITK< itk::DataObject >( );
+ auto path2D = dynamic_cast< _2DPath* >( path );
+ auto path3D = dynamic_cast< _3DPath* >( path );
+ if( path2D != NULL )
+ return( this->_GD0( path2D ) );
+ else if( path3D != NULL )
+ return( this->_GD0( path3D ) );
+ else
+ return( "cpPluginsVisualization::PolyLineParametricPathToPolyData: no valid input." );
+}
+
+// -------------------------------------------------------------------------
+template< class _TPath >
+std::string cpPluginsVisualization::PolyLineParametricPathToPolyData::
+_GD0( _TPath* path )
+{
+ typedef
+ cpExtensions::Visualization::PolyLineParametricPathToPolyData< _TPath >
+ _TFilter;
+ typedef typename _TFilter::TImage _TImage;
+
+ // Configure filter
+ _TFilter* filter = this->_CreateVTK< _TFilter >( );
+ filter->SetInput( path );
+ filter->SetReferenceImage(
+ this->GetInputData( "Input" )->GetITK< _TImage >( )
+ );
+ filter->Update( );
+
+ // Connect output
+ this->GetOutputData( "Output" )->SetVTK( filter->GetOutput( ) );
+ return( "" );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#ifndef __CPPLUGINSVISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+#define __CPPLUGINSVISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+
+#include <plugins/cpPluginsVisualization/cpPluginsVisualization_Export.h>
+#include <cpPlugins/ProcessObject.h>
+
+namespace cpPluginsVisualization
+{
+ /**
+ */
+ class cpPluginsVisualization_EXPORT PolyLineParametricPathToPolyData
+ : public cpPlugins::ProcessObject
+ {
+ public:
+ typedef PolyLineParametricPathToPolyData Self;
+ typedef cpPlugins::ProcessObject Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( PolyLineParametricPathToPolyData, cpPlugins::ProcessObject );
+ cpPlugins_Id_Macro( PolyLineParametricPathToPolyData, Visualization );
+
+ protected:
+ PolyLineParametricPathToPolyData( );
+ virtual ~PolyLineParametricPathToPolyData( );
+
+ virtual std::string _GenerateData( );
+
+ template< class _TPath >
+ inline std::string _GD0( _TPath* path );
+
+ /* TODO
+ template< class _TImage, class _TBinaryPixel >
+ inline std::string _GD1( _TImage* image );
+ */
+
+ private:
+ // Purposely not implemented
+ PolyLineParametricPathToPolyData( const Self& );
+ Self& operator=( const Self& );
+ };
+
+} // ecapseman
+
+#endif // __CPPLUGINSVISUALIZATION__POLYLINEPARAMETRICPATHTOPOLYDATA__H__
+
+// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff