${PROJECT_BINARY_DIR}/plugins
${PROJECT_SOURCE_DIR}/lib/third_party
${PROJECT_BINARY_DIR}/lib/third_party
+ ${PROJECT_SOURCE_DIR}/lib/third_party/dirent
+ ${PROJECT_BINARY_DIR}/lib/third_party/dirent
${PROJECT_SOURCE_DIR}/lib/ItkVtkGlue
${PROJECT_BINARY_DIR}/lib/ItkVtkGlue
)
this->m_PluginsPath = info.canonicalPath( ).toStdString( );
this->_LoadPluginsFromPath( this->m_PluginsPath );
}
- else
+ /*
+ else
this->_UpdateLoadedPlugins( );
+ */
} // fi
+ QDir exec_dir( "." );
+ if( exec_dir.exists( ) )
+ this->_LoadPluginsFromPath( exec_dir.canonicalPath( ).toStdString( ) );
/* TODO
this->m_Interface = new cpPlugins::Interface( );
{
try
{
- this->m_Interface.LoadPluginFile( fIt->toStdString( ) );
+ this->m_Interface.LoadPluginFile(
+ ( dir.absolutePath( ) + QDir::separator( ) + *fIt ).toStdString( )
+ );
}
- catch( ... )
+ catch( std::exception& err )
{
// Just ignore un-loadable libraries
- }
+ } // yrt
- } // yrt
+ } // rof
this->_UpdateLoadedPlugins( );
}
"Error loading default plugins",
"No plugins loaded: remember to load some!!!"
);
+ this->_UnBlock( );
return;
} // fi
}
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(
: public QObject
{
protected:
- virtual bool eventFilter( QObject* obj, QEvent* event ) override;
+ virtual bool eventFilter( QObject* obj, QEvent* event ) ITK_OVERRIDE;
};
-/*
- class PipelineEditor;
- struct PipelineEditor_Application
- {
- QApplication Application;
- PipelineEditor Window;
- PipelineEditor_Blocker Blocker;
- PipelineEditor_Application( int argc, char* argv[] );
- void Show( );
- int Exec( );
- void Block( );
- void UnBlock( );
- };
-*/
-
// -------------------------------------------------------------------------
namespace Ui
{
// 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
}
-SET(
- examples_SOURCES
- example_LoadPluginsFile
- example_LoadPluginsDirectory
- example_ReadWriteImage
- example_ReadWriteImageWithWorkspace
+SUBDIRS(
+ extensions
+ plugins
)
-FOREACH(example ${examples_SOURCES})
- ADD_EXECUTABLE(${example} ${example}.cxx)
- TARGET_LINK_LIBRARIES(${example} cpPlugins)
-ENDFOREACH(example)
-
## eof - $RCSfile$
--- /dev/null
+SET(
+ examples_SOURCES
+ example_KalmanVelocity
+ )
+
+FOREACH(example ${examples_SOURCES})
+ ADD_EXECUTABLE(${example} ${example}.cxx)
+ TARGET_LINK_LIBRARIES(${example} cpExtensions)
+ENDFOREACH(example)
+
+## eof - $RCSfile$
--- /dev/null
+#include <iostream>
+
+#include <cpExtensions/Algorithms/KalmanVelocityFilter.h>
+
+// -------------------------------------------------------------------------
+const unsigned int Dim = 1;
+typedef double TScalar;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ // Kalman filters
+ typedef
+ cpExtensions::Algorithms::KalmanVelocityFilter< TScalar >
+ _TKalman;
+ _TKalman::Pointer kalman01 = _TKalman::New( );
+ kalman01->Configure( 1 );
+ kalman01->SetTimeOffset( TScalar( 1 ) );
+
+ _TKalman::TMatrix P0 = kalman01->GetP0( );
+ P0.set_identity( );
+ P0 *= TScalar( 10 );
+ kalman01->SetP0( P0 );
+
+ _TKalman::TMatrix sigma = kalman01->GetSigma( );
+ sigma.set_identity( );
+ sigma *= TScalar( 1e-5 );
+ kalman01->SetSigma( sigma );
+
+ _TKalman::TMatrix R = kalman01->GetR( );
+ R.set_identity( );
+ R *= TScalar( 0.09 );
+ kalman01->SetR( R );
+
+ TScalar read;
+ std::cin >> read;
+
+ _TKalman::TVector x0 = kalman01->Getx0( );
+ x0[ 0 ] = read;
+ kalman01->Setx0( x0 );
+ kalman01->Initialize( );
+
+ while( !std::cin.eof( ) )
+ {
+ std::cin >> read;
+
+ _TKalman::TVector m = kalman01->Getm( );
+ m[ 0 ] = read;
+ kalman01->Setm( m );
+ kalman01->OneStep( );
+
+ std::cout << m[ 0 ] << " " << kalman01->Getxp( )[ 0 ] << std::endl;
+
+ } // eliwh
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+SET(
+ examples_SOURCES
+ example_LoadPluginsFile
+ example_LoadPluginsDirectory
+ example_ReadWriteImage
+ example_ReadWriteImageWithWorkspace
+ )
+
+FOREACH(example ${examples_SOURCES})
+ ADD_EXECUTABLE(${example} ${example}.cxx)
+ TARGET_LINK_LIBRARIES(${example} cpPlugins)
+ENDFOREACH(example)
+
+## eof - $RCSfile$
{
if( argc < 2 )
{
- std::cerr << "Usage: " << argv[ 0 ] << " plugins_libraries" << std::endl;
+ std::cerr << "Usage: " << argv[ 0 ] << " plugins_libraries_dir" << std::endl;
return( 1 );
} // fi
// Load interface
cpPlugins::Interface interface;
- for( int i = 1; i < argc; ++i )
+ try
{
- try
- {
- interface.LoadPluginFile( argv[ i ] );
- }
- catch( ... )
- {
- } // yrt
+ interface.LoadPluginDir( argv[ 1 ] );
+ }
+ catch( std::exception& err )
+ {
+ std::cerr << "Error caught: " << err.what( ) << std::endl;
+ return( 1 );
- } // rof
+ } // yrt
// Show loaded filters
auto filters = interface.GetFilters( );
virtual ~ImageToVTKImageFilter();
private:
- ImageToVTKImageFilter(const Self&) = delete;
- void operator=(const Self&) = delete;
+ ImageToVTKImageFilter(const Self&) ITK_DELETE_FUNCTION;
+ void operator=(const Self&) ITK_DELETE_FUNCTION;
ExporterFilterPointer m_Exporter;
vtkImageImport * m_Importer;
virtual ~VTKImageToImageFilter();
private:
- VTKImageToImageFilter(const Self&) = delete;
- void operator=(const Self&) = delete;
+ VTKImageToImageFilter(const Self&) ITK_DELETE_FUNCTION;
+ void operator=(const Self&) ITK_DELETE_FUNCTION;
typedef vtkSmartPointer<vtkImageExport> ImageExportPointer;
ImageExportPointer m_Exporter;
void SetTimeOffset( TScalar t );
/// Iteration methods
- virtual void Initialize( );
+ virtual void Initialize( );
protected:
KalmanVelocityFilter( );
--- /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$
void SetMPRViewer( TMPRWidget* v );
void SetSingleInteractor( vtkRenderWindowInteractor* i );
- virtual bool IsInteractive( ) override;
+ virtual bool IsInteractive( ) ITK_OVERRIDE;
virtual void SetInteractionObjects(
const std::vector< void* >& objs
- ) override;
+ ) ITK_OVERRIDE;
protected:
BaseWidget( );
cpPlugins_ITKInstances_Image
cpPlugins_ITKInstances_ImageIterators
cpPlugins_ITKInstances_ImageFilters
+ cpPlugins_ITKInstances_Paths
+ cpPlugins_ITKInstances_Mesh
${VTK_LIBRARIES}
)
IF(NOT WIN32)
* Some functions
* =========================================================================
*/
+#include <iostream>
namespace cpPlugins
{
struct PathHelper
// ---------------------------------------------------------------------
inline static std::string CanonicalPath( const std::string& path )
{
+ std::string ret = "";
#ifdef cpPlugins_SYS_WINDOWS
TCHAR buffer[ 4096 ] = TEXT( "" );
TCHAR** lppPart = { NULL };
GetFullPathName( path.c_str( ), 4096, buffer, lppPart );
- return( std::string( buffer ) );
+ ret = std::string( buffer );
#else // cpPlugins_SYS_WINDOWS
- return( std::string( realpath( path.c_str( ), NULL ) ) );
+ char* canonical_path = realpath( path.c_str( ), NULL );
+ if( canonical_path != NULL )
+ {
+ ret = canonical_path;
+ free( canonical_path );
+
+ } // fi
#endif // cpPlugins_SYS_WINDOWS
+ return( ret );
}
};
cpPlugins_Id_Macro( Image, Object );
public:
- virtual void SetITK( itk::LightObject* o ) override;
- virtual void SetVTK( vtkObjectBase* o ) override;
+ virtual void SetITK( itk::LightObject* o ) ITK_OVERRIDE;
+ virtual void SetVTK( vtkObjectBase* o ) ITK_OVERRIDE;
protected:
Image( );
#else // cpPlugins_SYS_WINDOWS
# include <dlfcn.h>
#endif // cpPlugins_SYS_WINDOWS
+#include <cpPlugins_dirent.h>
// -------------------------------------------------------------------------
cpPlugins::Interface::
{
// Open library with its canonical path name
auto canonical_fn = cpPlugins::PathHelper::CanonicalPath( filename );
+ if( canonical_fn == "" )
+ throw std::runtime_error(
+ std::string( "cpPlugins::Interface: Library \"" ) +
+ filename +
+ std::string( "\" does not exist." )
+ );
void* hnd = Self::_DLOpen( canonical_fn );
if( hnd == NULL )
throw std::runtime_error(
std::string( "cpPlugins::Interface: Could not load library \"" ) +
- canonical_fn +
+ filename +
std::string( "\"" )
);
Self::_DLClose( hnd );
}
+// -------------------------------------------------------------------------
+void cpPlugins::Interface::
+LoadPluginDir( const std::string& dirname )
+{
+#error ACA VOY
+ DIR *dir;
+ struct dirent *ent;
+ if( (dir = opendir ( dirname.c_str( ) ) ) != NULL)
+ {
+ while ((ent = readdir (dir)) != NULL) {
+ printf ("%s\n", ent->d_name);
+ }
+ closedir (dir);
+ } else {
+ std::cerr << "error" << std::endl;
+ }
+}
+
// -------------------------------------------------------------------------
void cpPlugins::Interface::
UnloadAll( )
bool LoadConfiguration( const std::string& filename );
bool SaveConfiguration( const std::string& filename ) const;
void LoadPluginFile( const std::string& filename );
+ void LoadPluginDir( const std::string& dirname );
void UnloadAll( );
cpPlugins::ProcessObject::Pointer Create(
--- /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 ) ITK_OVERRIDE;
+ virtual void SetVTK( vtkObjectBase* o ) ITK_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$
QPointF GetViewCoords( ) const;
#endif // cpPlugins_QT4
- virtual void Modified( ) const override;
- virtual itk::ModifiedTimeType GetMTime( ) const override;
+ virtual void Modified( ) const ITK_OVERRIDE;
+ virtual itk::ModifiedTimeType GetMTime( ) const ITK_OVERRIDE;
virtual void SetITK( itk::LightObject* o );
virtual void SetVTK( vtkObjectBase* o );
--- /dev/null
+#ifndef __CPPLUGINS_CONFIG__H__
+#define __CPPLUGINS_CONFIG__H__
+
+#include <itkMacro.h>
+
+#ifndef ITK_DELETE_FUNCTION
+# define ITK_DELETE_FUNCTION
+#endif // ITK_DELETE_FUNCTION
+
+#ifndef ITK_OVERRIDE
+# define ITK_OVERRIDE
+#endif // ITK_OVERRIDE
+
+#endif // __CPPLUGINS_CONFIG__H__
+
+// eof - $RCSfile$
+f cpPlugins_Config.h
i complex
i map
i string
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(
+ dirent
tinyxml
)
--- /dev/null
+## eof - $RCSfile$
--- /dev/null
+/*
+ * dirent.h - dirent API for Microsoft Visual Studio
+ *
+ * Copyright (C) 2006-2012 Toni Ronkko
+ * Modified by Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * ``Software''), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * $Id: dirent.h,v 1.20 2014/03/19 17:52:23 tronkko Exp $
+ */
+#ifndef __CPPLUGINS_DIRENT___H__
+#define __CPPLUGINS_DIRENT___H__
+
+// florez-l: use this file in windows environments
+#if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+/*
+ * Define architecture flags so we don't need to include windows.h.
+ * Avoiding windows.h makes it simpler to use windows sockets in conjunction
+ * with dirent.h.
+ */
+#if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_IX86)
+# define _X86_
+#endif
+#if !defined(_68K_) && !defined(_MPPC_) && !defined(_X86_) && !defined(_IA64_) && !defined(_AMD64_) && defined(_M_AMD64)
+#define _AMD64_
+#endif
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <windef.h>
+#include <winbase.h>
+#include <wchar.h>
+#include <string.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+/* Indicates that d_type field is available in dirent structure */
+#define ___CPPLUGINS_DIRENT___H__AVE_D_TYPE
+
+/* Indicates that d_namlen field is available in dirent structure */
+#define ___CPPLUGINS_DIRENT___H__AVE_D_NAMLEN
+
+/* Entries missing from MSVC 6.0 */
+#if !defined(FILE_ATTRIBUTE_DEVICE)
+# define FILE_ATTRIBUTE_DEVICE 0x40
+#endif
+
+/* File type and permission flags for stat() */
+#if !defined(S_IFMT)
+# define S_IFMT _S_IFMT /* File type mask */
+#endif
+#if !defined(S_IFDIR)
+# define S_IFDIR _S_IFDIR /* Directory */
+#endif
+#if !defined(S_IFCHR)
+# define S_IFCHR _S_IFCHR /* Character device */
+#endif
+#if !defined(S_IFFIFO)
+# define S_IFFIFO _S_IFFIFO /* Pipe */
+#endif
+#if !defined(S_IFREG)
+# define S_IFREG _S_IFREG /* Regular file */
+#endif
+#if !defined(S_IREAD)
+# define S_IREAD _S_IREAD /* Read permission */
+#endif
+#if !defined(S_IWRITE)
+# define S_IWRITE _S_IWRITE /* Write permission */
+#endif
+#if !defined(S_IEXEC)
+# define S_IEXEC _S_IEXEC /* Execute permission */
+#endif
+#if !defined(S_IFIFO)
+# define S_IFIFO _S_IFIFO /* Pipe */
+#endif
+#if !defined(S_IFBLK)
+# define S_IFBLK 0 /* Block device */
+#endif
+#if !defined(S_IFLNK)
+# define S_IFLNK 0 /* Link */
+#endif
+#if !defined(S_IFSOCK)
+# define S_IFSOCK 0 /* Socket */
+#endif
+
+#if defined(_MSC_VER)
+# define S_IRUSR S_IREAD /* Read user */
+# define S_IWUSR S_IWRITE /* Write user */
+# define S_IXUSR 0 /* Execute user */
+# define S_IRGRP 0 /* Read group */
+# define S_IWGRP 0 /* Write group */
+# define S_IXGRP 0 /* Execute group */
+# define S_IROTH 0 /* Read others */
+# define S_IWOTH 0 /* Write others */
+# define S_IXOTH 0 /* Execute others */
+#endif
+
+/* Maximum length of file name */
+#if !defined(PATH_MAX)
+# define PATH_MAX MAX_PATH
+#endif
+#if !defined(FILENAME_MAX)
+# define FILENAME_MAX MAX_PATH
+#endif
+#if !defined(NAME_MAX)
+# define NAME_MAX FILENAME_MAX
+#endif
+
+/* File type flags for d_type */
+#define DT_UNKNOWN 0
+#define DT_REG S_IFREG
+#define DT_DIR S_IFDIR
+#define DT_FIFO S_IFIFO
+#define DT_SOCK S_IFSOCK
+#define DT_CHR S_IFCHR
+#define DT_BLK S_IFBLK
+#define DT_LNK S_IFLNK
+
+/* Macros for converting between st_mode and d_type */
+#define IFTODT(mode) ((mode) & S_IFMT)
+#define DTTOIF(type) (type)
+
+/*
+ * File type macros. Note that block devices, sockets and links cannot be
+ * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are
+ * only defined for compatibility. These macros should always return false
+ * on Windows.
+ */
+#define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
+#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
+#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
+#define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
+#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
+#define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
+#define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
+
+/* Return the exact length of d_namlen without zero terminator */
+#define _D_EXACT_NAMLEN(p) ((p)->d_namlen)
+
+/* Return number of bytes needed to store d_namlen */
+#define _D_ALLOC_NAMLEN(p) (PATH_MAX)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Wide-character version */
+struct _wdirent {
+ long d_ino; /* Always zero */
+ unsigned short d_reclen; /* Structure size */
+ size_t d_namlen; /* Length of name without \0 */
+ int d_type; /* File type */
+ wchar_t d_name[PATH_MAX]; /* File name */
+};
+typedef struct _wdirent _wdirent;
+
+struct _WDIR {
+ struct _wdirent ent; /* Current directory entry */
+ WIN32_FIND_DATAW data; /* Private file data */
+ int cached; /* True if data is valid */
+ HANDLE handle; /* Win32 search handle */
+ wchar_t *patt; /* Initial directory name */
+};
+typedef struct _WDIR _WDIR;
+
+static _WDIR *_wopendir (const wchar_t *dirname);
+static struct _wdirent *_wreaddir (_WDIR *dirp);
+static int _wclosedir (_WDIR *dirp);
+static void _wrewinddir (_WDIR* dirp);
+
+
+/* For compatibility with Symbian */
+#define wdirent _wdirent
+#define WDIR _WDIR
+#define wopendir _wopendir
+#define wreaddir _wreaddir
+#define wclosedir _wclosedir
+#define wrewinddir _wrewinddir
+
+
+/* Multi-byte character versions */
+struct dirent {
+ long d_ino; /* Always zero */
+ unsigned short d_reclen; /* Structure size */
+ size_t d_namlen; /* Length of name without \0 */
+ int d_type; /* File type */
+ char d_name[PATH_MAX]; /* File name */
+};
+typedef struct dirent dirent;
+
+struct DIR {
+ struct dirent ent;
+ struct _WDIR *wdirp;
+};
+typedef struct DIR DIR;
+
+static DIR *opendir (const char *dirname);
+static struct dirent *readdir (DIR *dirp);
+static int closedir (DIR *dirp);
+static void rewinddir (DIR* dirp);
+
+
+/* Internal utility functions */
+static WIN32_FIND_DATAW *dirent_first (_WDIR *dirp);
+static WIN32_FIND_DATAW *dirent_next (_WDIR *dirp);
+
+static int dirent_mbstowcs_s(
+ size_t *pReturnValue,
+ wchar_t *wcstr,
+ size_t sizeInWords,
+ const char *mbstr,
+ size_t count);
+
+static int dirent_wcstombs_s(
+ size_t *pReturnValue,
+ char *mbstr,
+ size_t sizeInBytes,
+ const wchar_t *wcstr,
+ size_t count);
+
+static void dirent_set_errno (int error);
+
+/*
+ * Open directory stream DIRNAME for read and return a pointer to the
+ * internal working area that is used to retrieve individual directory
+ * entries.
+ */
+static _WDIR*
+_wopendir(
+ const wchar_t *dirname)
+{
+ _WDIR *dirp = NULL;
+ int error;
+
+ /* Must have directory name */
+ if (dirname == NULL || dirname[0] == '\0') {
+ dirent_set_errno (ENOENT);
+ return NULL;
+ }
+
+ /* Allocate new _WDIR structure */
+ dirp = (_WDIR*) malloc (sizeof (struct _WDIR));
+ if (dirp != NULL) {
+ DWORD n;
+
+ /* Reset _WDIR structure */
+ dirp->handle = INVALID_HANDLE_VALUE;
+ dirp->patt = NULL;
+ dirp->cached = 0;
+
+ /* Compute the length of full path plus zero terminator */
+ n = GetFullPathNameW (dirname, 0, NULL, NULL);
+
+ /* Allocate room for absolute directory name and search pattern */
+ dirp->patt = (wchar_t*) malloc (sizeof (wchar_t) * n + 16);
+ if (dirp->patt) {
+
+ /*
+ * Convert relative directory name to an absolute one. This
+ * allows rewinddir() to function correctly even when current
+ * working directory is changed between opendir() and rewinddir().
+ */
+ n = GetFullPathNameW (dirname, n, dirp->patt, NULL);
+ if (n > 0) {
+ wchar_t *p;
+
+ /* Append search pattern \* to the directory name */
+ p = dirp->patt + n;
+ if (dirp->patt < p) {
+ switch (p[-1]) {
+ case '\\':
+ case '/':
+ case ':':
+ /* Directory ends in path separator, e.g. c:\temp\ */
+ /*NOP*/;
+ break;
+
+ default:
+ /* Directory name doesn't end in path separator */
+ *p++ = '\\';
+ }
+ }
+ *p++ = '*';
+ *p = '\0';
+
+ /* Open directory stream and retrieve the first entry */
+ if (dirent_first (dirp)) {
+ /* Directory stream opened successfully */
+ error = 0;
+ } else {
+ /* Cannot retrieve first entry */
+ error = 1;
+ dirent_set_errno (ENOENT);
+ }
+
+ } else {
+ /* Cannot retrieve full path name */
+ dirent_set_errno (ENOENT);
+ error = 1;
+ }
+
+ } else {
+ /* Cannot allocate memory for search pattern */
+ error = 1;
+ }
+
+ } else {
+ /* Cannot allocate _WDIR structure */
+ error = 1;
+ }
+
+ /* Clean up in case of error */
+ if (error && dirp) {
+ _wclosedir (dirp);
+ dirp = NULL;
+ }
+
+ return dirp;
+}
+
+/*
+ * Read next directory entry. The directory entry is returned in dirent
+ * structure in the d_name field. Individual directory entries returned by
+ * this function include regular files, sub-directories, pseudo-directories
+ * "." and ".." as well as volume labels, hidden files and system files.
+ */
+static struct _wdirent*
+_wreaddir(
+ _WDIR *dirp)
+{
+ WIN32_FIND_DATAW *datap;
+ struct _wdirent *entp;
+
+ /* Read next directory entry */
+ datap = dirent_next (dirp);
+ if (datap) {
+ size_t n;
+ DWORD attr;
+
+ /* Pointer to directory entry to return */
+ entp = &dirp->ent;
+
+ /*
+ * Copy file name as wide-character string. If the file name is too
+ * long to fit in to the destination buffer, then truncate file name
+ * to PATH_MAX characters and zero-terminate the buffer.
+ */
+ n = 0;
+ while (n + 1 < PATH_MAX && datap->cFileName[n] != 0) {
+ entp->d_name[n] = datap->cFileName[n];
+ n++;
+ }
+ dirp->ent.d_name[n] = 0;
+
+ /* Length of file name excluding zero terminator */
+ entp->d_namlen = n;
+
+ /* File type */
+ attr = datap->dwFileAttributes;
+ if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
+ entp->d_type = DT_CHR;
+ } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
+ entp->d_type = DT_DIR;
+ } else {
+ entp->d_type = DT_REG;
+ }
+
+ /* Reset dummy fields */
+ entp->d_ino = 0;
+ entp->d_reclen = sizeof (struct _wdirent);
+
+ } else {
+
+ /* Last directory entry read */
+ entp = NULL;
+
+ }
+
+ return entp;
+}
+
+/*
+ * Close directory stream opened by opendir() function. This invalidates the
+ * DIR structure as well as any directory entry read previously by
+ * _wreaddir().
+ */
+static int
+_wclosedir(
+ _WDIR *dirp)
+{
+ int ok;
+ if (dirp) {
+
+ /* Release search handle */
+ if (dirp->handle != INVALID_HANDLE_VALUE) {
+ FindClose (dirp->handle);
+ dirp->handle = INVALID_HANDLE_VALUE;
+ }
+
+ /* Release search pattern */
+ if (dirp->patt) {
+ free (dirp->patt);
+ dirp->patt = NULL;
+ }
+
+ /* Release directory structure */
+ free (dirp);
+ ok = /*success*/0;
+
+ } else {
+ /* Invalid directory stream */
+ dirent_set_errno (EBADF);
+ ok = /*failure*/-1;
+ }
+ return ok;
+}
+
+/*
+ * Rewind directory stream such that _wreaddir() returns the very first
+ * file name again.
+ */
+static void
+_wrewinddir(
+ _WDIR* dirp)
+{
+ if (dirp) {
+ /* Release existing search handle */
+ if (dirp->handle != INVALID_HANDLE_VALUE) {
+ FindClose (dirp->handle);
+ }
+
+ /* Open new search handle */
+ dirent_first (dirp);
+ }
+}
+
+/* Get first directory entry (internal) */
+static WIN32_FIND_DATAW*
+dirent_first(
+ _WDIR *dirp)
+{
+ WIN32_FIND_DATAW *datap;
+
+ /* Open directory and retrieve the first entry */
+ dirp->handle = FindFirstFileW (dirp->patt, &dirp->data);
+ if (dirp->handle != INVALID_HANDLE_VALUE) {
+
+ /* a directory entry is now waiting in memory */
+ datap = &dirp->data;
+ dirp->cached = 1;
+
+ } else {
+
+ /* Failed to re-open directory: no directory entry in memory */
+ dirp->cached = 0;
+ datap = NULL;
+
+ }
+ return datap;
+}
+
+/* Get next directory entry (internal) */
+static WIN32_FIND_DATAW*
+dirent_next(
+ _WDIR *dirp)
+{
+ WIN32_FIND_DATAW *p;
+
+ /* Get next directory entry */
+ if (dirp->cached != 0) {
+
+ /* A valid directory entry already in memory */
+ p = &dirp->data;
+ dirp->cached = 0;
+
+ } else if (dirp->handle != INVALID_HANDLE_VALUE) {
+
+ /* Get the next directory entry from stream */
+ if (FindNextFileW (dirp->handle, &dirp->data) != FALSE) {
+ /* Got a file */
+ p = &dirp->data;
+ } else {
+ /* The very last entry has been processed or an error occured */
+ FindClose (dirp->handle);
+ dirp->handle = INVALID_HANDLE_VALUE;
+ p = NULL;
+ }
+
+ } else {
+
+ /* End of directory stream reached */
+ p = NULL;
+
+ }
+
+ return p;
+}
+
+/*
+ * Open directory stream using plain old C-string.
+ */
+static DIR*
+opendir(
+ const char *dirname)
+{
+ struct DIR *dirp;
+ int error;
+
+ /* Must have directory name */
+ if (dirname == NULL || dirname[0] == '\0') {
+ dirent_set_errno (ENOENT);
+ return NULL;
+ }
+
+ /* Allocate memory for DIR structure */
+ dirp = (DIR*) malloc (sizeof (struct DIR));
+ if (dirp) {
+ wchar_t wname[PATH_MAX];
+ size_t n;
+
+ /* Convert directory name to wide-character string */
+ error = dirent_mbstowcs_s (&n, wname, PATH_MAX, dirname, PATH_MAX);
+ if (!error) {
+
+ /* Open directory stream using wide-character name */
+ dirp->wdirp = _wopendir (wname);
+ if (dirp->wdirp) {
+ /* Directory stream opened */
+ error = 0;
+ } else {
+ /* Failed to open directory stream */
+ error = 1;
+ }
+
+ } else {
+ /*
+ * Cannot convert file name to wide-character string. This
+ * occurs if the string contains invalid multi-byte sequences or
+ * the output buffer is too small to contain the resulting
+ * string.
+ */
+ error = 1;
+ }
+
+ } else {
+ /* Cannot allocate DIR structure */
+ error = 1;
+ }
+
+ /* Clean up in case of error */
+ if (error && dirp) {
+ free (dirp);
+ dirp = NULL;
+ }
+
+ return dirp;
+}
+
+/*
+ * Read next directory entry.
+ *
+ * When working with text consoles, please note that file names returned by
+ * readdir() are represented in the default ANSI code page while any output to
+ * console is typically formatted on another code page. Thus, non-ASCII
+ * characters in file names will not usually display correctly on console. The
+ * problem can be fixed in two ways: (1) change the character set of console
+ * to 1252 using chcp utility and use Lucida Console font, or (2) use
+ * _cprintf function when writing to console. The _cprinf() will re-encode
+ * ANSI strings to the console code page so many non-ASCII characters will
+ * display correcly.
+ */
+static struct dirent*
+readdir(
+ DIR *dirp)
+{
+ WIN32_FIND_DATAW *datap;
+ struct dirent *entp;
+
+ /* Read next directory entry */
+ datap = dirent_next (dirp->wdirp);
+ if (datap) {
+ size_t n;
+ int error;
+
+ /* Attempt to convert file name to multi-byte string */
+ error = dirent_wcstombs_s(
+ &n, dirp->ent.d_name, PATH_MAX, datap->cFileName, PATH_MAX);
+
+ /*
+ * If the file name cannot be represented by a multi-byte string,
+ * then attempt to use old 8+3 file name. This allows traditional
+ * Unix-code to access some file names despite of unicode
+ * characters, although file names may seem unfamiliar to the user.
+ *
+ * Be ware that the code below cannot come up with a short file
+ * name unless the file system provides one. At least
+ * VirtualBox shared folders fail to do this.
+ */
+ if (error && datap->cAlternateFileName[0] != '\0') {
+ error = dirent_wcstombs_s(
+ &n, dirp->ent.d_name, PATH_MAX,
+ datap->cAlternateFileName, PATH_MAX);
+ }
+
+ if (!error) {
+ DWORD attr;
+
+ /* Initialize directory entry for return */
+ entp = &dirp->ent;
+
+ /* Length of file name excluding zero terminator */
+ entp->d_namlen = n - 1;
+
+ /* File attributes */
+ attr = datap->dwFileAttributes;
+ if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) {
+ entp->d_type = DT_CHR;
+ } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
+ entp->d_type = DT_DIR;
+ } else {
+ entp->d_type = DT_REG;
+ }
+
+ /* Reset dummy fields */
+ entp->d_ino = 0;
+ entp->d_reclen = sizeof (struct dirent);
+
+ } else {
+ /*
+ * Cannot convert file name to multi-byte string so construct
+ * an errornous directory entry and return that. Note that
+ * we cannot return NULL as that would stop the processing
+ * of directory entries completely.
+ */
+ entp = &dirp->ent;
+ entp->d_name[0] = '?';
+ entp->d_name[1] = '\0';
+ entp->d_namlen = 1;
+ entp->d_type = DT_UNKNOWN;
+ entp->d_ino = 0;
+ entp->d_reclen = 0;
+ }
+
+ } else {
+ /* No more directory entries */
+ entp = NULL;
+ }
+
+ return entp;
+}
+
+/*
+ * Close directory stream.
+ */
+static int
+closedir(
+ DIR *dirp)
+{
+ int ok;
+ if (dirp) {
+
+ /* Close wide-character directory stream */
+ ok = _wclosedir (dirp->wdirp);
+ dirp->wdirp = NULL;
+
+ /* Release multi-byte character version */
+ free (dirp);
+
+ } else {
+
+ /* Invalid directory stream */
+ dirent_set_errno (EBADF);
+ ok = /*failure*/-1;
+
+ }
+ return ok;
+}
+
+/*
+ * Rewind directory stream to beginning.
+ */
+static void
+rewinddir(
+ DIR* dirp)
+{
+ /* Rewind wide-character string directory stream */
+ _wrewinddir (dirp->wdirp);
+}
+
+/* Convert multi-byte string to wide character string */
+static int
+dirent_mbstowcs_s(
+ size_t *pReturnValue,
+ wchar_t *wcstr,
+ size_t sizeInWords,
+ const char *mbstr,
+ size_t count)
+{
+ int error;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+
+ /* Microsoft Visual Studio 2005 or later */
+ error = mbstowcs_s (pReturnValue, wcstr, sizeInWords, mbstr, count);
+
+#else
+
+ /* Older Visual Studio or non-Microsoft compiler */
+ size_t n;
+
+ /* Convert to wide-character string (or count characters) */
+ n = mbstowcs (wcstr, mbstr, sizeInWords);
+ if (!wcstr || n < count) {
+
+ /* Zero-terminate output buffer */
+ if (wcstr && sizeInWords) {
+ if (n >= sizeInWords) {
+ n = sizeInWords - 1;
+ }
+ wcstr[n] = 0;
+ }
+
+ /* Length of resuting multi-byte string WITH zero terminator */
+ if (pReturnValue) {
+ *pReturnValue = n + 1;
+ }
+
+ /* Success */
+ error = 0;
+
+ } else {
+
+ /* Could not convert string */
+ error = 1;
+
+ }
+
+#endif
+
+ return error;
+}
+
+/* Convert wide-character string to multi-byte string */
+static int
+dirent_wcstombs_s(
+ size_t *pReturnValue,
+ char *mbstr,
+ size_t sizeInBytes, /* max size of mbstr */
+ const wchar_t *wcstr,
+ size_t count)
+{
+ int error;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+
+ /* Microsoft Visual Studio 2005 or later */
+ error = wcstombs_s (pReturnValue, mbstr, sizeInBytes, wcstr, count);
+
+#else
+
+ /* Older Visual Studio or non-Microsoft compiler */
+ size_t n;
+
+ /* Convert to multi-byte string (or count the number of bytes needed) */
+ n = wcstombs (mbstr, wcstr, sizeInBytes);
+ if (!mbstr || n < count) {
+
+ /* Zero-terminate output buffer */
+ if (mbstr && sizeInBytes) {
+ if (n >= sizeInBytes) {
+ n = sizeInBytes - 1;
+ }
+ mbstr[n] = '\0';
+ }
+
+ /* Lenght of resulting multi-bytes string WITH zero-terminator */
+ if (pReturnValue) {
+ *pReturnValue = n + 1;
+ }
+
+ /* Success */
+ error = 0;
+
+ } else {
+
+ /* Cannot convert string */
+ error = 1;
+
+ }
+
+#endif
+
+ return error;
+}
+
+/* Set errno variable */
+static void
+dirent_set_errno(
+ int error)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+
+ /* Microsoft Visual Studio 2005 and later */
+ _set_errno (error);
+
+#else
+
+ /* Non-Microsoft compiler or older Microsoft compiler */
+ errno = error;
+
+#endif
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+// florez-l: use the standard linux header
+#else // defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+#include <dirent.h>
+#endif // defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+#endif /*__CPPLUGINS_DIRENT___H__*/
+
SUBDIRS(
cpPluginsIO
cpPluginsImageFilters
+ cpPluginsVisualization
cpPluginsWidgets
)
public:
// Qt dialog creation
- virtual cpPlugins::ParametersQtDialog* CreateQtDialog( ) override;
+ virtual cpPlugins::ParametersQtDialog* CreateQtDialog( ) ITK_OVERRIDE;
protected:
DicomSeriesReader( );
ImageReader( );
virtual ~ImageReader( );
- virtual std::string _GenerateData( ) override;
+ virtual std::string _GenerateData( ) ITK_OVERRIDE;
template< unsigned int _Dim >
inline std::string _GD0( itk::ImageIOBase* io );
ImageWriter( );
virtual ~ImageWriter( );
- virtual std::string _GenerateData( ) override;
+ virtual std::string _GenerateData( ) ITK_OVERRIDE;
template< class _TInput >
inline std::string _GD0( _TInput* image );
// 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