+SUBDIRS(
+ bash
+ )
+
IF(BUILD_EXAMPLES)
SUBDIRS(
examples
#include "ImageMPR.h"
#include "ui_ImageMPR.h"
-#include <cpPlugins/Interface/ParametersQtDialog.h>
-
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
// Start: load all disponible plugins
this->_LoadPlugins(
std::string( PLUGIN_PREFIX ) +
- std::string( "cpPlugins." ) +
+ std::string( "cpPluginsIO." ) +
std::string( PLUGIN_EXT )
);
}
this->m_ImageWriterClass = "";
this->m_MeshReaderClass = "";
this->m_MeshWriterClass = "";
- this->m_ImageToImageFilters.clear( );
- this->m_ImageToMeshFilters.clear( );
+ this->m_UI->MenuImageToImage->clear( );
+ this->m_UI->MenuImageToMesh->clear( );
- this->m_Plugins.UnloadAll( );
if( !( this->m_Plugins.Load( filename ) ) )
- {
- this->m_Plugins.UnloadAll( );
return( false );
- } // fi
-
typedef TPluginsInterface::TClasses _TClasses;
_TClasses::const_iterator cIt = this->m_Plugins.GetClasses( ).begin( );
for( ; cIt != this->m_Plugins.GetClasses( ).end( ); ++cIt )
this->m_MeshWriterClass = name;
else if( category == "ImageToImageFilter" )
{
- this->m_ImageToImageFilters.insert( name );
QAction* action =
this->m_UI->MenuImageToImage->addAction( QString( name.c_str( ) ) );
QObject::connect(
}
else if( category == "ImageToMeshFilter" )
{
- this->m_ImageToMeshFilters.insert( name );
QAction* action =
this->m_UI->MenuImageToMesh->addAction( QString( name.c_str( ) ) );
QObject::connect(
return( true );
}
+// -------------------------------------------------------------------------
+std::string ImageMPR::
+_LoadImage( TPluginImage::Pointer& image, const QStringList& names )
+{
+ // Block application
+ QApplication::setOverrideCursor( Qt::WaitCursor );
+ this->setEnabled( false );
+
+ std::string ret = "";
+ image = NULL;
+
+ // Get a reader from loaded plugins
+ TPluginFilter::Pointer reader =
+ this->m_Plugins.CreateProcessObject( this->m_ImageReaderClass );
+ if( reader.IsNotNull( ) )
+ {
+ // Configure reader
+ TParameters params = reader->GetDefaultParameters( );
+ QStringList::const_iterator qIt = names.begin( );
+ for( ; qIt != names.end( ); ++qIt )
+ params.AddValueToStringList( "FileNames", qIt->toStdString( ) );
+ params.SetValueAsBool( "VectorType", false );
+ reader->SetParameters( params );
+
+ // Execute and get error message, if any
+ ret = reader->Update( );
+
+ // Assign fresh image, if any
+ if( ret == "" )
+ {
+ image = reader->GetOutput< TPluginImage >( 0 );
+ reader->DisconnectOutputs( );
+
+ } // fi
+ }
+ else
+ ret = "No suitable reader object found in loaded plugins.";
+
+ // Finish reading
+ QApplication::restoreOverrideCursor( );
+ this->setEnabled( true );
+ return( ret );
+}
+
// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionOpenPlugins( )
if( !( dialog.exec( ) ) )
return;
- this->m_InputImage = NULL;
-
- // Get a reader from plugins
- TPluginFilter::Pointer reader =
- this->m_Plugins.CreateProcessObject( this->m_ImageReaderClass );
-
- // Configure reader
- TParameters reader_params = reader->GetDefaultParameters( );
- QStringList q_fnames = dialog.selectedFiles( );
- QStringList::const_iterator qIt = q_fnames.begin( );
- for( ; qIt != q_fnames.end( ); ++qIt )
- reader_params.AddValueToStringList( "FileNames", qIt->toStdString( ) );
- reader->SetParameters( reader_params );
-
- // Execute and get error message, if any
- QApplication::setOverrideCursor( Qt::WaitCursor );
- this->setEnabled( false );
- std::string err = reader->Update( );
- QApplication::restoreOverrideCursor( );
- this->setEnabled( true );
-
- // Assign fresh image, if any
+ // Read image
+ std::string err =
+ this->_LoadImage( this->m_InputImage, dialog.selectedFiles( ) );
if( err == "" )
{
- this->m_InputImage = reader->GetOutput< TPluginImage >( 0 );
- reader->DisconnectOutputs( );
- if( this->m_InputImage.IsNotNull( ) )
+ vtkImageData* vtk_id = this->m_InputImage->GetVTKImageData( );
+ if( vtk_id != NULL )
{
- vtkImageData* vtk_id = this->m_InputImage->GetVTKImageData( );
- if( vtk_id != NULL )
- {
- this->m_MPRObjects->SetImage( vtk_id );
- this->m_MPRObjects->ActivateInteractors( );
- this->m_MPRObjects->ResetCameras( );
- this->m_MPRObjects->RenderAll( );
- }
- else
- QMessageBox::critical(
- this,
- tr( "Error message" ),
- tr( "Read image does not have a valid VTK converter." )
- );
-
- } // fi
+ this->m_MPRObjects->SetImage( vtk_id );
+ this->m_MPRObjects->ActivateInteractors( );
+ this->m_MPRObjects->ResetCameras( );
+ this->m_MPRObjects->RenderAll( );
+ }
+ else
+ QMessageBox::critical(
+ this,
+ tr( "Error message" ),
+ tr( "Read image does not have a valid VTK converter." )
+ );
}
else
QMessageBox::critical(
void ImageMPR::
_triggered_actionOpenSegmentation( )
{
+ if( this->m_InputImage.IsNull( ) )
+ {
+ QMessageBox::critical(
+ this,
+ tr( "Error message" ),
+ tr( "Before reading a segmentation, first load a raw image." )
+ );
+ return;
+
+ } // fi
+
// Show dialog and check if it was accepted
QFileDialog dialog( this );
dialog.setFileMode( QFileDialog::ExistingFiles );
if( !( dialog.exec( ) ) )
return;
- this->m_InputImage = NULL;
-
- // Get a reader from plugins
- TPluginFilter::Pointer reader =
- this->m_Plugins.CreateProcessObject( this->m_ImageReaderClass );
-
- // Configure reader
- TParameters reader_params = reader->GetDefaultParameters( );
- QStringList q_fnames = dialog.selectedFiles( );
- QStringList::const_iterator qIt = q_fnames.begin( );
- for( ; qIt != q_fnames.end( ); ++qIt )
- reader_params.AddValueToStringList( "FileNames", qIt->toStdString( ) );
- reader->SetParameters( reader_params );
-
- // Execute and get error message, if any
- QApplication::setOverrideCursor( Qt::WaitCursor );
- this->setEnabled( false );
- std::string err = reader->Update( );
- QApplication::restoreOverrideCursor( );
- this->setEnabled( true );
-
- // Assign fresh image, if any
+ // Read image
+ std::string err =
+ this->_LoadImage( this->m_InputSegmentation, dialog.selectedFiles( ) );
if( err == "" )
{
- this->m_InputSegmentation = reader->GetOutput< TPluginImage >( 0 );
- reader->DisconnectOutputs( );
- if( this->m_InputSegmentation.IsNotNull( ) )
+ vtkImageData* vtk_id = this->m_InputSegmentation->GetVTKImageData( );
+ if( vtk_id != NULL )
{
- vtkImageData* vtk_id = this->m_InputSegmentation->GetVTKImageData( );
- if( vtk_id != NULL )
- {
- /*
- this->m_MPRObjects->SetImage( vtk_id );
- this->m_MPRObjects->ResetCameras( );
- this->m_MPRObjects->RenderAll( );
- */
- }
- else
- QMessageBox::critical(
- this,
- tr( "Error message" ),
- tr( "Read image does not have a valid VTK converter." )
- );
-
- } // fi
+ this->m_MPRObjects->AddAuxiliaryImage( vtk_id );
+ this->m_MPRObjects->RenderAll( );
+ }
+ else
+ QMessageBox::critical(
+ this,
+ tr( "Error message" ),
+ tr( "Read image does not have a valid VTK converter." )
+ );
}
else
QMessageBox::critical(
#ifndef __IMAGEMPR__H__
#define __IMAGEMPR__H__
-// Standard stuff
-#include <map>
-#include <set>
+#include <vector>
// Qt stuff
#include <QMainWindow>
typedef cpPlugins::Interface::ProcessObject TPluginFilter;
typedef cpPlugins::Interface::Parameters TParameters;
- typedef std::set< std::string > TStringContainer;
typedef cpExtensions::Visualization::MPRObjects TMPRObjects;
public:
protected:
bool _LoadPlugins( const std::string& filename );
+ std::string _LoadImage(
+ TPluginImage::Pointer& image, const QStringList& names
+ );
private slots:
void _triggered_actionOpenPlugins( );
std::string m_ImageWriterClass;
std::string m_MeshReaderClass;
std::string m_MeshWriterClass;
- TStringContainer m_ImageToImageFilters;
- TStringContainer m_ImageToMeshFilters;
// Real data
TPluginImage::Pointer m_InputImage;
--- /dev/null
+## =========================
+## = Command line programs =
+## =========================
+
+SET(
+ BASH_PROGRAMS
+ cpPlugins_createHost
+ )
+
+FOREACH(prog ${BASH_PROGRAMS})
+ ADD_EXECUTABLE(${prog} ${prog}.cxx)
+ INSTALL(
+ TARGETS ${prog}
+ RUNTIME DESTINATION bin
+ LIBRARY DESTINATION lib
+ ARCHIVE DESTINATION lib/static
+ )
+ENDFOREACH(prog)
+
+## eof - $RCSfile$
--- /dev/null
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+// -------------------------------------------------------------------------
+std::string GetFileName( const std::string& path )
+{
+ // Extract filename
+ char* buffer = new char[ path.size( ) + 1 ];
+ std::memcpy( buffer, path.c_str( ), path.size( ) );
+ buffer[ path.size( ) ] = '\0';
+ char* tok = std::strtok( buffer, "/\\" );
+ char* ptr_fname = tok;
+ while( tok != NULL )
+ {
+ ptr_fname = tok;
+ tok = std::strtok( NULL, "/\\" );
+
+ } // elihw
+ std::string fname( ptr_fname );
+ delete [] buffer;
+
+ // Delete extension
+ std::size_t pos = fname.find_last_of( "." );
+ if( pos != std::string::npos )
+ fname = fname.substr( 0, pos );
+
+ return( fname );
+}
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ // Open file
+ if( argc < 4 )
+ {
+ std::cerr
+ << "Usage: " << argv[ 0 ]
+ << " output_code namespace filter1 filter2 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::ofstream output_code( argv[ 1 ] );
+ if( !output_code )
+ {
+ std::cerr
+ << "Could not open file \"" << argv[ 1 ] << "\" for writing"
+ << std::endl;
+ return( 1 );
+
+ } // fi
+
+ output_code << "#include <Pluma/Connector.hpp>" << std::endl;
+ for( int i = 3; i < argc; ++i )
+ output_code << "#include \"" << argv[ i ] << "\"" << std::endl;
+ output_code
+ << std::endl
+ << "PLUMA_CONNECTOR" << std::endl
+ << "bool connect( pluma::Host& host )" << std::endl
+ << "{" << std::endl
+ << " using namespace " << argv[ 2 ] << ";" << std::endl;
+
+ for( int i = 3; i < argc; ++i )
+ output_code
+ << " host.add( new "
+ << GetFileName( argv[ i ] )
+ << "Provider( ) );"
+ << std::endl;
+
+ output_code
+ << " return( true );" << std::endl
+ << "}" << std::endl;
+
+ // Finish
+ output_code.close( );
+ return( 0 );
+}
+
+// eof - $RCSfile$
example_TestParameters
example_LoadPlugins
example_ReadWriteImage
- example_MarchingCubes
- example_OtsuFilter
- example_RGBImageToHSVChannels
- example_RGBImageToYPbPrChannels
+ ##example_MarchingCubes
+ ##example_OtsuFilter
+ ##example_RGBImageToHSVChannels
+ ##example_RGBImageToYPbPrChannels
## example_ReadImageSeriesWriteImage
## example_ReadQuadEdgeMesh
## example_RenderQuadEdgeMesh
- example_MPR
+ ##example_MPR
)
{
if( argc < 2 )
{
- std::cerr << "Usage: " << argv[ 0 ] << " plugins_file" << std::endl;
+ std::cerr << "Usage: " << argv[ 0 ] << " plugins_file(s)" << std::endl;
return( 1 );
} // fi
- std::string plugins_file = argv[ 1 ];
// Create interface
typedef cpPlugins::Interface::Interface TInterface;
typedef TInterface::TClasses TClasses;
TInterface plugins;
- if( !plugins.Load( plugins_file ) )
- {
- std::cerr << "Error loading plugins file." << std::endl;
- return( 1 );
+ for( int i = 1; i < argc; ++i )
+ if( !plugins.Load( argv[ i ] ) )
+ std::cerr
+ << "Error loading plugins file \""
+ << argv[ i ] << "\""
+ << std::endl;
- } // fi
-
std::cout << "---------------------------------------------" << std::endl;
std::cout << "Loaded classes:" << std::endl;
TClasses::const_iterator cIt = plugins.GetClasses( ).begin( );
for( ; cIt != plugins.GetClasses( ).end( ); ++cIt )
std::cout << " := " << cIt->first << std::endl;
std::cout << "---------------------------------------------" << std::endl;
+
return( 0 );
}
#include <cpPlugins/Interface/Interface.h>
#include <cpPlugins/Interface/ProcessObject.h>
-
#include <cpPlugins/Interface/Image.h>
+// -------------------------------------------------------------------------
+typedef cpPlugins::Interface::Interface TInterface;
+typedef cpPlugins::Interface::ProcessObject TProcessObject;
+typedef cpPlugins::Interface::DataObject TDataObject;
+typedef cpPlugins::Interface::Parameters TParameters;
+typedef TInterface::TClasses TClasses;
+
+// -------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
if( argc < 4 )
} // fi
// Create interface
- typedef cpPlugins::Interface::Interface TInterface;
- typedef TInterface::TClasses TClasses;
TInterface plugins;
if( !plugins.Load( argv[ 1 ] ) )
{
} // fi
// Create objects
- typedef cpPlugins::Interface::ProcessObject TProcessObject;
- typedef cpPlugins::Interface::DataObject TDataObject;
- typedef cpPlugins::Interface::Parameters TParameters;
- cpPlugins::Interface::ProcessObject::Pointer reader, writer;
- reader = plugins.CreateProcessObject( "cpPlugins::ImageReader" );
- if( reader.IsNull( ) )
+ TProcessObject::Pointer reader, writer;
+ reader = plugins.CreateProcessObject( "cpPlugins::IO::ImageReader" );
+ writer = plugins.CreateProcessObject( "cpPlugins::IO::ImageWriter" );
+ if( reader.IsNull( ) || writer.IsNull( ) )
{
- std::cerr << "No suitable reader found in plugins." << std::endl;
- return( 1 );
-
- } // fi
- writer = plugins.CreateProcessObject( "cpPlugins::ImageWriter" );
- if( writer.IsNull( ) )
- {
- std::cerr << "No suitable writer found in plugins." << std::endl;
+ std::cerr
+ << "No suitable reader found in plugins." << std::endl
+ << "Reader: " << reader.GetPointer( ) << std::endl
+ << "Writer: " << writer.GetPointer( ) << std::endl
+ << std::endl;
return( 1 );
} // fi
# -- Some configurations variables --
# ===================================
-SET(cpPlugins_with_QT4 "@QT4_FOUND@")
+SET(USE_QT4 "@QT4_FOUND@")
+
+# =======================
+# -- Find dependencies --
+# =======================
+
+# Find ITK and VTK
+SET(ITK_DIR @ITK_DIR@)
+FIND_PACKAGE(ITK REQUIRED)
+INCLUDE(${ITK_USE_FILE})
+
+SET(VTK_DIR @VTK_DIR@)
+FIND_PACKAGE(VTK REQUIRED)
+INCLUDE(${VTK_USE_FILE})
+
+# Do not use itk-vtk glue --> problems ahead!!!
+IF(ITKVtkGlue_LOADED)
+ MESSAGE(FATAL_ERROR "ITKVtkGlue module is available. Please re-compile your ITK without it. It could lead to nasty compilation problems... Just waiting for Kitware to solve it.")
+ENDIF(ITKVtkGlue_LOADED)
+
+IF(USE_QT4 EQUAL "1")
+ SET(QT_QMAKE_EXECUTABLE @QT_QMAKE_EXECUTABLE@)
+ FIND_PACKAGE(Qt4 REQUIRED)
+ INCLUDE(${QT_USE_FILE})
+
+ ## Check for required vtk-qt4 modules
+ SET(
+ vtk_required_modules
+ vtkGUISupportQt
+ vtkGUISupportQtOpenGL
+ )
+ FOREACH(vtk_module ${vtk_required_modules})
+ IF(NOT ${vtk_module}_LOADED)
+ MESSAGE(
+ FATAL_ERROR
+ "${vtk_module} module is required but not available."
+ )
+ ENDIF(NOT ${vtk_module}_LOADED)
+ ENDFOREACH(vtk_module)
+ENDIF(USE_QT4 EQUAL "1")
+
# =========================
# -- Include directories --
SET(cpPlugins_Interface_LIBRARY cpPlugins_Interface)
SET(cpPlugins_LIBRARY cpPlugins)
+# ======================
+# -- Executable names --
+# ======================
+
+FIND_PROGRAM(
+ cpPlugins_createHost_APP
+ NAMES cpPlugins_createHost
+ HINTS /usr /usr/local
+ PATHS @CMAKE_INSTALL_PREFIX@/bin @PROJECT_BINARY_DIR@
+ PATH_SUFFIXES bin sbin
+ DOC "Where is cpPlugins_createHost?"
+ )
+
## eof - $RCSfile$
+++ /dev/null
-// -------------------------------------------------------------------------
-// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
-// -------------------------------------------------------------------------
-
-#include <cpExtensions/Algorithms/SecondRankDiffusionTensorToPolyData.h>
-#include <itkImage.h>
-#include <itkSymmetricSecondRankTensor.h>
-#include <itkImageRegionConstIteratorWithIndex.h>
-#include <vtkInformation.h>
-#include <vtkInformationVector.h>
-#include <vtkPoints.h>
-#include <vtkPointData.h>
-#include <vtkSmartPointer.h>
-#include <vtkDoubleArray.h>
-
-// -------------------------------------------------------------------------
-template< class I >
-typename cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-Self* cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-New( )
-{
- return( new Self );
-}
-
-// -------------------------------------------------------------------------
-template< class I >
-void cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-SetInputData( const I* image )
-{
- this->m_ITKImage = image;
- this->Modified( );
-}
-
-// -------------------------------------------------------------------------
-template< class I >
-cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-SecondRankDiffusionTensorToPolyData( )
- : vtkPolyDataAlgorithm( )
-{
- this->SetNumberOfInputPorts( 0 );
-}
-
-// -------------------------------------------------------------------------
-template< class I >
-cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-~SecondRankDiffusionTensorToPolyData( )
-{
-}
-
-// -------------------------------------------------------------------------
-template< class I >
-int cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I >::
-RequestData(
- vtkInformation* request,
- vtkInformationVector** inputVector,
- vtkInformationVector* outputVector
- )
-{
- if( this->m_ITKImage.IsNull( ) )
- return( 0 );
-
- // get the info objects
- vtkInformation* outInfo = outputVector->GetInformationObject( 0 );
- vtkPolyData* polyData = vtkPolyData::SafeDownCast(
- outInfo->Get(vtkDataObject::DATA_OBJECT())
- );
-
- itk::ImageRegionConstIteratorWithIndex< I > tensorIt( this->m_ITKImage, this->m_ITKImage->GetRequestedRegion() );
-
- vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
- vtkSmartPointer<vtkDoubleArray> vtkTensors = vtkSmartPointer<vtkDoubleArray>::New();
- vtkTensors->SetNumberOfComponents(9);
- for ( tensorIt.GoToBegin(); !tensorIt.IsAtEnd(); ++tensorIt )
- {
- typename I::IndexType tensorIndex = tensorIt.GetIndex();
- typename I::PixelType tensor = tensorIt.Get();
- typename I::PointType ptensor;
-
- // TODO: std::cout << "\n Index [" << tensorIndex[0] << ", " << tensorIndex[1] << ", " << tensorIndex[2] << "]" << std::endl;
- this->m_ITKImage->TransformIndexToPhysicalPoint( tensorIndex, ptensor );
- vtkIdType vtkPointID = points->InsertNextPoint(ptensor[0], ptensor[1], ptensor[2]);
-
- /**
- * Definition included in cdifTypes.
- * typedef itk::SymmetricSecondRankTensor< double > Diffusion2ndRankTensor;
- */
- //Diffusion2ndRankTensor Diffusion2ndRankTensor;
-
-
- /**
- * SYMMETRIC SECOND RANK TENSOR
- *
- * The upper-right triangle of the matrix:
- *
- * | 0 1 2 |
- * | X 3 4 |
- * | X X 5 |
- *
- * | xx xy xz |
- * | X yy yz |
- * | X X zz |
- */
- /*
- Diffusion2ndRankTensor = tensor[0];
- Diffusion2ndRankTensor = tensor[1];
- Diffusion2ndRankTensor = tensor[2];
- Diffusion2ndRankTensor = tensor[3];
- Diffusion2ndRankTensor = tensor[4];
- Diffusion2ndRankTensor = tensor[5];
- */
- typename I::PixelType::EigenValuesArrayType evalues;
- typename I::PixelType::EigenVectorsMatrixType evectors;
-
- /**
- * Return an array containing EigenValues,
- * and a matrix containing Eigenvectors.
- */
- tensor.ComputeEigenAnalysis(evalues, evectors);
-
- /*
- std::cout << "[C-DIFFUSION - NRRD Tensors Example] Eigen values: " << evalues[0] << ", " << evalues[1] << ", " << evalues[2] << std::endl;
-
- std::cout << "[C-DIFFUSION - NRRD Tensors Example] Eigen vectors: "
-
- << "(" << evectors(0,0) << ", " << evectors(0,1) << ", " << evectors(0,2) << "), "
- << "(" << evectors(1,0) << ", " << evectors(1,1) << ", " << evectors(1,2) << "), "
- << "(" << evectors(2,0) << ", " << evectors(2,1) << ", " << evectors(2,2) << ")" << std::endl;
- */
- evectors.GetVnlMatrix().scale_row(0, evalues[0]);
- evectors.GetVnlMatrix().scale_row(1, evalues[1]);
- evectors.GetVnlMatrix().scale_row(2, evalues[2]);
-
- /*
- std::cout << "[C-DIFFUSION - NRRD Tensors Example] Eigen values x Eigen vectors : "
-
- << "(" << evectors(0,0) << ", " << evectors(0,1) << ", " << evectors(0,2) << "), "
- << "(" << evectors(1,0) << ", " << evectors(1,1) << ", " << evectors(1,2) << "), "
- << "(" << evectors(2,0) << ", " << evectors(2,1) << ", " << evectors(2,2) << ")" << std::endl;
- */
- vtkTensors->InsertTuple9(
- vtkPointID,
- evectors(0,0), evectors(0,1), evectors(0,2),
- evectors(1,0), evectors(1,1), evectors(1,2),
- evectors(2,0), evectors(2,1), evectors(2,2)
- );
- } // rof
-
- polyData->SetPoints( points );
- vtkSmartPointer<vtkPointData> pointData = polyData->GetPointData();
- pointData->SetTensors( vtkTensors );
- return( 1 );
-
- /**
- * VISUALISATION CODE BELOW
- */
-
-// vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
-// cubeSource->Update();
-//
-// vtkSmartPointer<vtkTensorGlyph> tensorGlyph = vtkSmartPointer<vtkTensorGlyph>::New();
-//#if VTK_MAJOR_VERSION <= 5
-// tensorGlyph->SetInput(polyData);
-//#else
-// tensorGlyph->SetInputData(polyData);
-//#endif
-// tensorGlyph->SetSourceConnection(cubeSource->GetOutputPort());
-// tensorGlyph->ColorGlyphsOff();
-// tensorGlyph->ThreeGlyphsOff();
-// tensorGlyph->ExtractEigenvaluesOff();
-// tensorGlyph->Update();
-// .
-// .
-// .
-
-}
-
-// -------------------------------------------------------------------------
-template class cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< itk::Image< itk::SymmetricSecondRankTensor< float, 3 >, 3 > >;
-template class cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< itk::Image< itk::SymmetricSecondRankTensor< double, 3 >, 3 > >;
-
-// eof - $RCSfile$
+++ /dev/null
-// -------------------------------------------------------------------------
-// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
-// -------------------------------------------------------------------------
-
-#ifndef __CPEXTENSIONS__ALGORITHMS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-#define __CPEXTENSIONS__ALGORITHMS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-
-#include <cpExtensions/cpExtensions_Export.h>
-
-#include <vtkPolyDataAlgorithm.h>
-
-namespace cpExtensions
-{
- namespace Algorithms
- {
- /**
- */
- template< class I >
- class cpExtensions_EXPORT SecondRankDiffusionTensorToPolyData
- : public vtkPolyDataAlgorithm
- {
- public:
- typedef SecondRankDiffusionTensorToPolyData Self;
-
- public:
- static Self* New( );
- vtkTypeMacro( SecondRankDiffusionTensorToPolyData, vtkPolyDataAlgorithm );
-
- void SetInputData( const I* image );
-
- protected:
- SecondRankDiffusionTensorToPolyData( );
- virtual ~SecondRankDiffusionTensorToPolyData( );
-
- virtual int RequestData(
- vtkInformation* , vtkInformationVector**, vtkInformationVector*
- );
-
- private:
- SecondRankDiffusionTensorToPolyData( const Self& other );
- Self& operator=( const Self& other );
-
- protected:
- typename I::ConstPointer m_ITKImage;
- };
-
- } // ecapseman
-
-} // ecapseman
-
-#endif // __CPEXTENSIONS__ALGORITHMS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-
-// eof - $RCSfile$
## = 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")
+SET(LIB_HEADERS_H "")
+SET(LIB_HEADERS_HPP "")
+SET(LIB_HEADERS_HXX "")
+SET(LIB_SOURCES_C "")
+SET(LIB_SOURCES_CPP "")
+SET(LIB_SOURCES_CXX "")
-FILE(GLOB LIB_DataStructures_HEADERS_H "DataStructures/*.h")
-FILE(GLOB LIB_DataStructures_HEADERS_HPP "DataStructures/*.hpp")
-FILE(GLOB LIB_DataStructures_HEADERS_HXX "DataStructures/*.hxx")
-FILE(GLOB LIB_DataStructures_SOURCES_C "DataStructures/*.c")
-FILE(GLOB LIB_DataStructures_SOURCES_CPP "DataStructures/*.cpp")
-FILE(GLOB LIB_DataStructures_SOURCES_CXX "DataStructures/*.cxx")
-
-FILE(GLOB LIB_Algorithms_HEADERS_H "Algorithms/*.h")
-FILE(GLOB LIB_Algorithms_HEADERS_HPP "Algorithms/*.hpp")
-FILE(GLOB LIB_Algorithms_HEADERS_HXX "Algorithms/*.hxx")
-FILE(GLOB LIB_Algorithms_SOURCES_C "Algorithms/*.c")
-FILE(GLOB LIB_Algorithms_SOURCES_CPP "Algorithms/*.cpp")
-FILE(GLOB LIB_Algorithms_SOURCES_CXX "Algorithms/*.cxx")
+SET(
+ lib_DIRECTORIES
+ .
+ DataStructures
+ Algorithms
+ IO
+ Visualization
+ )
+FOREACH(dir ${lib_DIRECTORIES})
+ FILE(GLOB dir_LIB_HEADERS_H "${dir}/*.h")
+ FILE(GLOB dir_LIB_HEADERS_HPP "${dir}/*.hpp")
+ FILE(GLOB dir_LIB_HEADERS_HXX "${dir}/*.hxx")
+ FILE(GLOB dir_LIB_SOURCES_C "${dir}/*.c")
+ FILE(GLOB dir_LIB_SOURCES_CPP "${dir}/*.cpp")
+ FILE(GLOB dir_LIB_SOURCES_CXX "${dir}/*.cxx")
-FILE(GLOB LIB_IO_HEADERS_H "IO/*.h")
-FILE(GLOB LIB_IO_HEADERS_HPP "IO/*.hpp")
-FILE(GLOB LIB_IO_HEADERS_HXX "IO/*.hxx")
-FILE(GLOB LIB_IO_SOURCES_C "IO/*.c")
-FILE(GLOB LIB_IO_SOURCES_CPP "IO/*.cpp")
-FILE(GLOB LIB_IO_SOURCES_CXX "IO/*.cxx")
+ SET(LIB_HEADERS_H "${LIB_HEADERS_H};${dir_LIB_HEADERS_H}")
+ SET(LIB_HEADERS_HPP "${LIB_HEADERS_HPP};${dir_LIB_HEADERS_HPP}")
+ SET(LIB_HEADERS_HXX "${LIB_HEADERS_HXX};${dir_LIB_HEADERS_HXX}")
+ SET(LIB_SOURCES_C "${LIB_SOURCES_C};${dir_LIB_SOURCES_C}")
+ SET(LIB_SOURCES_CPP "${LIB_SOURCES_CPP};${dir_LIB_SOURCES_CPP}")
+ SET(LIB_SOURCES_CXX "${LIB_SOURCES_CXX};${dir_LIB_SOURCES_CXX}")
-FILE(GLOB LIB_Visualization_HEADERS_H "Visualization/*.h")
-FILE(GLOB LIB_Visualization_HEADERS_HPP "Visualization/*.hpp")
-FILE(GLOB LIB_Visualization_HEADERS_HXX "Visualization/*.hxx")
-FILE(GLOB LIB_Visualization_SOURCES_C "Visualization/*.c")
-FILE(GLOB LIB_Visualization_SOURCES_CPP "Visualization/*.cpp")
-FILE(GLOB LIB_Visualization_SOURCES_CXX "Visualization/*.cxx")
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpExtensions
+ FILES_MATCHING PATTERN "*.h"
+ )
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpExtensions
+ FILES_MATCHING PATTERN "*.hpp"
+ )
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpExtensions
+ FILES_MATCHING PATTERN "*.hxx"
+ )
+ENDFOREACH(dir)
## =====================
## = Compilation rules =
${LIB_SOURCES_C}
${LIB_SOURCES_CPP}
${LIB_SOURCES_CXX}
- ${LIB_DataStructures_SOURCES_C}
- ${LIB_DataStructures_SOURCES_CPP}
- ${LIB_DataStructures_SOURCES_CXX}
- ${LIB_Algorithms_SOURCES_C}
- ${LIB_Algorithms_SOURCES_CPP}
- ${LIB_Algorithms_SOURCES_CXX}
- ${LIB_IO_SOURCES_C}
- ${LIB_IO_SOURCES_CPP}
- ${LIB_IO_SOURCES_CXX}
- ${LIB_Visualization_SOURCES_C}
- ${LIB_Visualization_SOURCES_CPP}
- ${LIB_Visualization_SOURCES_CXX}
)
GENERATE_EXPORT_HEADER(
${LIBRARY_NAME}
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib/static
)
-SET(
- local_install_dirs
- Algorithms
- DataStructures
- IO
- Visualization
- )
-FOREACH(dir ${local_install_dirs})
- INSTALL(
- DIRECTORY ${dir}
- DESTINATION include/cpExtensions
- FILES_MATCHING PATTERN "*.h"
- )
- INSTALL(
- DIRECTORY ${dir}
- DESTINATION include/cpExtensions
- FILES_MATCHING PATTERN "*.hxx"
- )
- INSTALL(
- DIRECTORY ${dir}
- DESTINATION include/cpExtensions
- FILES_MATCHING PATTERN "*.hpp"
- )
-ENDFOREACH(dir)
-
INSTALL(
FILES
${PROJECT_BINARY_DIR}/lib/cpExtensions/${LIBRARY_NAME}_Export.h
this->WindowLevelCurrentPosition[ 1 ]
) / double( size[ 1 ] );
- double w = this->WindowLevelInitial[ 0 ] * ( double( 1 ) + sw );
- double l = this->WindowLevelInitial[ 1 ] * ( double( 1 ) + sl );
+ double w = this->WindowLevelInitial[ 0 ] + ( sw * 1000.0 );
+ double l = this->WindowLevelInitial[ 1 ] + ( sl * 1000.0 );
double minw = this->m_MPRActors->GetMinWindow( 0 );
double maxw = this->m_MPRActors->GetMaxWindow( 0 );
double minl = this->m_MPRActors->GetMinLevel( 0 );
if( l < minl ) l = minl;
if( maxl < l ) l = maxl;
- this->m_MPRActors->SetWindow( 0, w );
- this->m_MPRActors->SetLevel( 0, l );
+ this->m_MPRActors->SetWindowLevel( 0, w, l );
this->Interactor->Render( );
this->_RenderAssociateInteractors( );
}
void cpExtensions::Visualization::ImageSliceActors::
AddInputConnection( vtkAlgorithmOutput* aout, int axis )
{
- unsigned int nImages = this->SliceMappers.size( );
-
vtkSmartPointer< vtkImageSliceMapper > mapper =
vtkSmartPointer< vtkImageSliceMapper >::New( );
this->SliceMappers.push_back( mapper );
mapper->SetInputConnection( aout );
- mapper->SetOrientation(
- ( nImages == 0 )? axis: this->SliceMappers[ 0 ]->GetOrientation( )
- );
- mapper->Update( );
-
- vtkSmartPointer< vtkImageActor > actor =
- vtkSmartPointer< vtkImageActor >::New( );
- this->ImageActors.push_back( actor );
- actor->SetMapper( mapper );
- actor->Modified( );
-
- if( nImages == 0 )
- {
- this->AddItem( this->TextActor );
- this->AddItem( this->PlaneActor );
-
- } // fi
- this->AddItem( actor );
- this->Modified( );
+ this->_ConfigureNewInput( axis );
}
// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
AddInputData( vtkImageData* data, int axis )
{
- unsigned int nImages = this->SliceMappers.size( );
-
vtkSmartPointer< vtkImageSliceMapper > mapper =
vtkSmartPointer< vtkImageSliceMapper >::New( );
this->SliceMappers.push_back( mapper );
mapper->SetInputData( data );
- mapper->SetOrientation(
- ( nImages == 0 )? axis: this->SliceMappers[ 0 ]->GetOrientation( )
- );
- mapper->Update( );
-
- vtkSmartPointer< vtkImageActor > actor =
- vtkSmartPointer< vtkImageActor >::New( );
- this->ImageActors.push_back( actor );
- actor->SetMapper( mapper );
- actor->Modified( );
-
- if( nImages == 0 )
- {
- this->AddItem( this->TextActor );
- this->AddItem( this->PlaneActor );
-
- } // fi
- this->AddItem( actor );
- this->Modified( );
+ this->_ConfigureNewInput( axis );
}
// -------------------------------------------------------------------------
return( this->PlaneActor );
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+SetInterpolate( bool v )
+{
+ if( this->Interpolate != v )
+ {
+ for( unsigned int i = 0; i < this->ImageActors.size( ); ++i )
+ this->ImageActors[ i ]->SetInterpolate( v );
+ this->Interpolate = v;
+ this->Modified( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+InterpolateOn( )
+{
+ this->SetInterpolate( true );
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+InterpolateOff( )
+{
+ this->SetInterpolate( false );
+}
+
// -------------------------------------------------------------------------
double* cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( ) const
void cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( double bounds[ 6 ] ) const
{
- if( this->ImageActors.size( ) > 0 )
+ if( this->ImageActors.size( ) == 0 )
+ {
+ bounds[ 0 ] = bounds[ 2 ] = bounds[ 4 ] = double( -1 );
+ bounds[ 1 ] = bounds[ 3 ] = bounds[ 5 ] = double( -1 );
+ }
+ else
this->ImageActors[ 0 ]->GetDisplayBounds( bounds );
}
this->PlaneSource->Modified( );
this->PlaneMapper->Modified( );
this->PlaneActor->Modified( );
- this->Modified( );
+ this->UpdateText( );
}
// -------------------------------------------------------------------------
this->Modified( );
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+UpdateText( const double& w, const double& l )
+{
+ if( this->SliceMappers.size( ) > 0 )
+ {
+ char axis;
+ int axId = this->SliceMappers[ 0 ]->GetOrientation( );
+ if ( axId == 0 ) axis = 'X';
+ else if( axId == 1 ) axis = 'Y';
+ else if( axId == 2 ) axis = 'Z';
+
+ std::sprintf(
+ this->TextBuffer, "Axis: %c (%d) | W/L (%.2f/%.2f)",
+ axis, this->SliceMappers[ 0 ]->GetSliceNumber( ), w, l
+ );
+ }
+ else
+ this->TextBuffer[ 0 ] = '\0';
+ this->TextActor->SetInput( this->TextBuffer );
+ this->TextActor->Modified( );
+ this->Modified( );
+}
+
// -------------------------------------------------------------------------
cpExtensions::Visualization::ImageSliceActors::
ImageSliceActors( )
- : Superclass( )
+ : Superclass( ),
+ Interpolate( false )
{
this->Clear( );
}
{
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+_ConfigureNewInput( int axis )
+{
+ unsigned int nImages = this->ImageActors.size( );
+
+ // Configure mapper
+ vtkImageSliceMapper* mapper = this->SliceMappers[ nImages ];
+ if( nImages == 0 )
+ mapper->SetOrientation( axis );
+ else
+ mapper->SetOrientation( this->SliceMappers[ 0 ]->GetOrientation( ) );
+ mapper->Update( );
+
+ // Create actor
+ vtkSmartPointer< vtkImageActor > actor =
+ vtkSmartPointer< vtkImageActor >::New( );
+ this->ImageActors.push_back( actor );
+ actor->SetMapper( mapper );
+ actor->SetInterpolate( this->Interpolate );
+ actor->Modified( );
+
+ if( nImages == 0 )
+ {
+ this->AddItem( this->TextActor );
+ this->AddItem( this->PlaneActor );
+
+ } // fi
+ this->AddItem( actor );
+
+ if( nImages > 1 )
+ this->SetSliceNumber( this->GetSliceNumber( ) );
+ this->Modified( );
+}
+
// eof - $RCSfile$
vtkActor* GetPlaneActor( );
const vtkActor* GetPlaneActor( ) const;
+ void SetInterpolate( bool v );
+ void InterpolateOn( );
+ void InterpolateOff( );
+
double* GetDisplayBounds( ) const;
void GetDisplayBounds( double bounds[ 6 ] ) const;
int GetSliceNumberMaxValue( ) const;
void SetSliceNumber( const int& slice );
void UpdateText( );
+ void UpdateText( const double& w, const double& l );
protected:
ImageSliceActors( );
virtual ~ImageSliceActors( );
+ void _ConfigureNewInput( int axis );
+
private:
// Purposely not implemented
ImageSliceActors( const Self& );
// Multiple actors
std::vector< vtkSmartPointer< vtkImageSliceMapper > > SliceMappers;
std::vector< vtkSmartPointer< vtkImageActor > > ImageActors;
+ bool Interpolate;
// Unique objects
vtkSmartPointer< vtkPolyData > PlaneSource;
#include <cpExtensions/Visualization/MPRActors.h>
+#include <cmath>
+
#include <vtkAlgorithmOutput.h>
#include <vtkImageData.h>
#include <vtkInformation.h>
+#include <vtkLookupTable.h>
#include <vtkOutlineSource.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
this->ImageMaps[ 0 ]->SetInputConnection( aout );
this->SetLookupTableToWindowLevel( 0 );
this->_Update( 0 );
+ this->ResetWindowLevel( 0 );
return( 0 );
}
else
vtkSmartPointer< vtkImageMapToColors >::New( )
);
this->ImageMaps[ N ]->SetInputConnection( aout );
- this->SetLookupTableToWindowLevel( N );
+ this->SetLookupTableToColor(
+ N, double( 1 ), double( 0 ), double( 0 )
+ );
this->_Update( N );
return( N );
}
this->ImageMaps[ 0 ]->SetInputData( image );
this->SetLookupTableToWindowLevel( 0 );
this->_Update( 0 );
+ this->ResetWindowLevel( 0 );
return( 0 );
}
else
vtkSmartPointer< vtkImageMapToColors >::New( )
);
this->ImageMaps[ N ]->SetInputData( image );
- this->SetLookupTableToWindowLevel( N );
+ this->SetLookupTableToColor(
+ N, double( 1 ), double( 0 ), double( 0 )
+ );
this->_Update( N );
return( N );
}
w->RemoveActor( this->ImageOutlineActor );
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::MPRActors::
+LinkInteractors( )
+{
+ this->_Update( 0 );
+ this->_Update( 1 );
+ this->_Update( 2 );
+}
+
// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetLookupTable( unsigned int i, vtkScalarsToColors* lut )
} // fi
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::MPRActors::
+SetWindowLevel( unsigned int i, const double& w, const double& l )
+{
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
+ if( lut != NULL )
+ {
+ lut->SetWindow( w );
+ lut->SetLevel( l );
+ lut->Build( );
+ this->ImageMaps[ i ]->Modified( );
+
+ for( unsigned int j = 0; j < 3; ++j )
+ this->Slices[ 0 ][ j ]->UpdateText( w, l );
+
+ this->Modified( );
+
+ } // fi
+}
+
// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
ResetWindowLevel( unsigned int i )
double r[ 2 ];
image->GetScalarRange( r );
lut->SetTableRange( r );
+ lut->SetWindow( r[ 1 ] - r[ 0 ] );
+ lut->SetLevel( ( r[ 1 ] + r[ 0 ] ) / double( 2 ) );
lut->Build( );
this->ImageMaps[ i ]->Modified( );
this->Modified( );
} // fi
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::MPRActors::
+SetLookupTableToColor(
+ unsigned int i, const double& r, const double& g, const double& b
+ )
+{
+ static const double _0 = double( 0 );
+ static const double _1 = double( 1 );
+ static const double _2 = double( 2 );
+ static const double _4 = double( 4 );
+ static const double _6 = double( 6 );
+ static const double _OPACITY = double( 0.6 );
+
+ // Check if the input has been configured
+ vtkImageData* image = this->_Image( i );
+ if( image == NULL )
+ return;
+
+ double range[ 2 ];
+ image->GetScalarRange( range );
+
+ // Get HSV from display color
+ double cmax = ( r > g )? r: g; cmax = ( b > cmax )? b: cmax;
+ double cmin = ( r < g )? r: g; cmin = ( b < cmin )? b: cmin;
+ double d = cmax - cmin;
+
+ double saturation = ( std::fabs( cmax ) > _0 )? d / cmax: _0;
+ double value = cmax;
+ double hue = _0;
+ if( d > _0 )
+ {
+ if( r == cmax )
+ hue = std::fmod( ( g - b ) / d, _6 );
+ else if( g == cmax )
+ hue = ( ( b - r ) / d ) + _2;
+ else if( b == cmax )
+ hue = ( ( r - g ) / d ) + _4;
+ hue *= _1 / _6;
+
+ } // fi
+
+ // Define new lookup table
+ vtkSmartPointer< vtkLookupTable > lut =
+ vtkSmartPointer< vtkLookupTable >::New( );
+ lut->SetScaleToLinear( );
+ lut->SetAboveRangeColor( _0, _0, _0, _0 );
+ lut->SetBelowRangeColor( _0, _0, _0, _0 );
+ lut->SetNanColor( _0, _0, _0, _0 );
+ lut->SetTableRange( range[ 0 ], range[ 1 ] );
+ lut->SetAlphaRange( _0, _OPACITY );
+ lut->SetHueRange( _0, hue );
+ lut->SetSaturationRange( _0, saturation );
+ lut->SetValueRange( _0, value );
+ lut->Build( );
+
+ this->SetLookupTable( i, lut );
+}
+
// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
GetSliceNumberMinValue( const int& axis ) const
vtkAlgorithm* algo = this->ImageMaps[ i ]->GetInputAlgorithm( );
vtkInformation* info = algo->GetOutputInformation( 0 );
return(
- vtkImageData::SafeDownCast( info->Get( vtkDataObject::DATA_OBJECT( ) ) )
+ vtkImageData::SafeDownCast(
+ info->Get( vtkDataObject::DATA_OBJECT( ) )
+ )
);
}
else
);
this->Slices[ j ][ k ]->UpdateText( );
+ // Add all of slice's props
+ this->Slices[ j ][ k ]->InitTraversal( );
+ vtkProp* prop = this->Slices[ j ][ k ]->GetNextProp( );
+ while( prop != NULL )
+ {
+ this->AddItem( prop );
+ prop = this->Slices[ j ][ k ]->GetNextProp( );
+
+ } // elihw
+
} // rof
} // rof
int AddInputConnection( vtkAlgorithmOutput* aout );
int AddInputData( vtkImageData* image );
- /*
- void SetInputConnection( vtkAlgorithmOutput* aout );
- void SetInputData( vtkImageData* image );
- */
-
void PushDataInto(
vtkRenderer* x,
vtkRenderer* y,
vtkRenderer* z,
vtkRenderer* w
);
- void LinkInteractors( )
- {
- this->_Update( 0 );
- this->_Update( 1 );
- this->_Update( 2 );
- }
+ void LinkInteractors( );
// Lookup table methods
void SetLookupTable( unsigned int i, vtkScalarsToColors* lut );
double GetLevel( unsigned int i ) const;
void SetWindow( unsigned int i, const double& w );
void SetLevel( unsigned int i, const double& l );
+ void SetWindowLevel( unsigned int i, const double& w, const double& l );
void ResetWindowLevel( unsigned int i );
+ // Color lookup table
+ void SetLookupTableToColor(
+ unsigned int i,
+ const double& r = double( 1 ),
+ const double& g = double( 0 ),
+ const double& b = double( 0 )
+ );
+
// Slice access
int GetSliceNumberMinValue( const int& axis ) const;
int GetSliceNumberMaxValue( const int& axis ) const;
#include <cpExtensions/Visualization/MPRObjects.h>
+#include <cmath>
+#include <vtkImageData.h>
+#include <vtkLookupTable.h>
+
// -------------------------------------------------------------------------
cpExtensions::Visualization::MPRObjects*
cpExtensions::Visualization::MPRObjects::
this->m_Renderers[ 3 ]
);
- // Correct cameras positions
- /* TODO
- vtkCamera* zCam = this->m_Renderers[ 2 ]->GetActiveCamera( );
- zCam->SetViewUp( 0, -1, 0 );
- zCam->SetPosition( 0, 0, -1 );
- zCam->SetFocalPoint( 0, 0, 0 );
- */
-
// First rendering
this->m_MPRActors->ResetSlices( );
this->ResetCameras( );
this->RenderAll( );
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::MPRObjects::
+AddAuxiliaryImage( vtkImageData* image )
+{
+ // Try to add new image
+ int id = this->m_MPRActors->AddInputData( image );
+ if( id < 0 )
+ return;
+
+ // Push everything on renderers
+ this->m_MPRActors->PushDataInto(
+ this->m_Renderers[ 0 ],
+ this->m_Renderers[ 1 ],
+ this->m_Renderers[ 2 ],
+ this->m_Renderers[ 3 ]
+ );
+
+ // Rendering
+ this->RenderAll( );
+}
+
// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRObjects::
ActivateInteractors( )
vtkRenderWindow* wz, vtkRenderWindow* w3D
);
void SetImage( vtkImageData* image );
+ void AddAuxiliaryImage( vtkImageData* image );
void ActivateInteractors( );
void ResetCamera( const int& id );
SET(
LIB_SOURCES_CXX
+ Instances_itkImage.cxx
+ Instances_itkVectorImage.cxx
+ Instances_itkMesh.cxx
BaseProcessObjects.cxx
DataObject.cxx
Image.cxx
- Instances_itkImage.cxx
- Instances_itkMesh.cxx
Interface.cxx
Mesh.cxx
Object.cxx
#include <itkVector.h>
// -------------------------------------------------------------------------
-#define cpPlugins_Image_Export( T, D ) \
- cpPlugins_TEMPLATE_EXPORT( \
- 2(class cpPlugins_Interface_EXPORT itk::Image< T, D >) \
+#define cpPlugins_ITKImage_Export( T, D ) \
+ cpPlugins_TEMPLATE_EXPORT( \
+ 2(class cpPlugins_Interface_EXPORT itk::Image< T, D >) \
)
// -------------------------------------------------------------------------
-#define cpPlugins_VTKImage_Export( T, D ) \
+#define cpPlugins_ITKArrayImage_Export( A, T, DA, DI ) \
cpPlugins_TEMPLATE_EXPORT( \
- 2( \
- class cpPlugins_Interface_EXPORT \
- itk::ImageToVTKImageFilter< itk::Image< T, D > > \
- ) \
+ 3(class cpPlugins_Interface_EXPORT itk::Image< A< T, DA >, DI >) \
)
// -------------------------------------------------------------------------
-#define cpPlugins_ImageArray_Export( A, T, DA, DI ) \
- cpPlugins_TEMPLATE_EXPORT( \
- 3( \
- class cpPlugins_Interface_EXPORT \
- itk::Image< itk::A< T, DA >, DI > \
- ) \
- )
+#define cpPlugins_ITKImage_AllDims_Export( T ) \
+ cpPlugins_ITKImage_Export( T, 2 ); \
+ cpPlugins_ITKImage_Export( T, 3 ); \
+ cpPlugins_ITKImage_Export( T, 4 )
// -------------------------------------------------------------------------
-#define cpPlugins_VTKImageArray_Export( A, T, DA, DI ) \
- cpPlugins_TEMPLATE_EXPORT( \
- 3( \
- class cpPlugins_Interface_EXPORT \
- itk::ImageToVTKImageFilter< itk::Image< itk::A< T, DA >, DI > > \
- ) \
+#define cpPlugins_ITKArrayImage_AllDims_Export( A, T ) \
+ cpPlugins_ITKArrayImage_Export( A, T, 2, 2 ); \
+ cpPlugins_ITKArrayImage_Export( A, T, 3, 3 ); \
+ cpPlugins_ITKArrayImage_Export( A, T, 4, 4 )
+
+// -------------------------------------------------------------------------
+#define cpPlugins_VTKImage_Export( T, D ) \
+ cpPlugins_TEMPLATE_EXPORT( \
+ 2( \
+ class cpPlugins_Interface_EXPORT \
+ itk::ImageToVTKImageFilter< itk::Image< T, D > > \
+ ) \
)
// -------------------------------------------------------------------------
-#define cpPlugins_Image_Export_AllDimensions( T ) \
- cpPlugins_Image_Export( T, 2 ); \
- cpPlugins_Image_Export( T, 3 ); \
- cpPlugins_Image_Export( T, 4 )
+#define cpPlugins_VTKArrayImage_Export( A, T, DA, DI ) \
+ cpPlugins_TEMPLATE_EXPORT( \
+ 3(class \
+ cpPlugins_Interface_EXPORT \
+ itk::ImageToVTKImageFilter< itk::Image< A< T, DA >, DI > >) \
+ )
// -------------------------------------------------------------------------
-#define cpPlugins_VTKImage_Export_AllDimensions( T ) \
- cpPlugins_VTKImage_Export( T, 2 ); \
+#define cpPlugins_VTKImage_AllDims_Export( T ) \
+ cpPlugins_VTKImage_Export( T, 2 ); \
cpPlugins_VTKImage_Export( T, 3 )
// -------------------------------------------------------------------------
-#define cpPlugins_ImageArray_Export_AllDimensions( A, T ) \
- cpPlugins_ImageArray_Export( A, T, 2, 2 ); \
- cpPlugins_ImageArray_Export( A, T, 3, 3 ); \
- cpPlugins_ImageArray_Export( A, T, 4, 4 )
+#define cpPlugins_VTKArrayImage_AllDims_Export( A, T ) \
+ cpPlugins_VTKArrayImage_Export( A, T, 2, 2 ); \
+ cpPlugins_VTKArrayImage_Export( A, T, 3, 3 )
// -------------------------------------------------------------------------
-#define cpPlugins_VTKImageArray_Export_AllDimensions( A, T ) \
- cpPlugins_VTKImageArray_Export( A, T, 2, 2 ); \
- cpPlugins_VTKImageArray_Export( A, T, 3, 3 )
-
+#define cpPlugins_Image_Export( T, D ) \
+ cpPlugins_ITKImage_Export( T, D ); \
+ cpPlugins_VTKImage_Export( T, D ) \
+
+// -------------------------------------------------------------------------
+#define cpPlugins_Image_AllDims_Export( T ) \
+ cpPlugins_ITKImage_AllDims_Export( T ); \
+ cpPlugins_VTKImage_AllDims_Export( T ) \
+
+// -------------------------------------------------------------------------
+#define cpPlugins_ArrayImage_AllDims_Export( A, T ) \
+ cpPlugins_ITKArrayImage_AllDims_Export( A, T ); \
+ cpPlugins_VTKArrayImage_AllDims_Export( A, T ) \
+
+// -------------------------------------------------------------------------
+// ITK-VTK base clases
// -------------------------------------------------------------------------
-// ITK base clases
-cpPlugins_Image_Export_AllDimensions( char );
-cpPlugins_Image_Export_AllDimensions( short );
-cpPlugins_Image_Export_AllDimensions( int );
-cpPlugins_Image_Export_AllDimensions( long );
-cpPlugins_Image_Export_AllDimensions( unsigned char );
-cpPlugins_Image_Export_AllDimensions( unsigned short );
-cpPlugins_Image_Export_AllDimensions( unsigned int );
-cpPlugins_Image_Export_AllDimensions( unsigned long );
-cpPlugins_Image_Export_AllDimensions( float );
-cpPlugins_Image_Export_AllDimensions( double );
-
-cpPlugins_Image_Export_AllDimensions( std::complex< float > );
-cpPlugins_Image_Export_AllDimensions( std::complex< double > );
-
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< char > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< short > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< int > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< long > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< unsigned char > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< unsigned short > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< unsigned int > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< unsigned long > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< float > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBPixel< double > );
-
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< char > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< short > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< int > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< long > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< unsigned char > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< unsigned short > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< unsigned int > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< unsigned long > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< float > );
-cpPlugins_Image_Export_AllDimensions( itk::RGBAPixel< double > );
-
-cpPlugins_ImageArray_Export_AllDimensions( Vector, float );
-cpPlugins_ImageArray_Export_AllDimensions( Vector, double );
-
-cpPlugins_ImageArray_Export_AllDimensions( CovariantVector, float );
-cpPlugins_ImageArray_Export_AllDimensions( CovariantVector, double );
-
-cpPlugins_ImageArray_Export_AllDimensions( Point, float );
-cpPlugins_ImageArray_Export_AllDimensions( Point, double );
-
-cpPlugins_ImageArray_Export_AllDimensions(
- SymmetricSecondRankTensor, float
- );
-cpPlugins_ImageArray_Export_AllDimensions(
- SymmetricSecondRankTensor, double
- );
-
-cpPlugins_Image_Export( itk::DiffusionTensor3D< float >, 3 );
-cpPlugins_Image_Export( itk::DiffusionTensor3D< double >, 3 );
-cpPlugins_Image_Export( itk::DiffusionTensor3D< float >, 4 );
-cpPlugins_Image_Export( itk::DiffusionTensor3D< double >, 4 );
-cpPlugins_Image_Export( itk::Offset< 2 >, 2 );
-cpPlugins_Image_Export( itk::Offset< 3 >, 3 );
-cpPlugins_Image_Export( itk::Offset< 4 >, 4 );
+cpPlugins_Image_AllDims_Export( char );
+cpPlugins_Image_AllDims_Export( short );
+cpPlugins_Image_AllDims_Export( int );
+cpPlugins_Image_AllDims_Export( long );
+cpPlugins_Image_AllDims_Export( unsigned char );
+cpPlugins_Image_AllDims_Export( unsigned short );
+cpPlugins_Image_AllDims_Export( unsigned int );
+cpPlugins_Image_AllDims_Export( unsigned long );
+cpPlugins_Image_AllDims_Export( float );
+cpPlugins_Image_AllDims_Export( double );
+
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< char > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< short > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< int > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< long > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned char > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned short > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned int > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned long > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< float > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< double > );
+
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< char > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< short > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< int > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< long > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned char > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned short > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned int > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned long > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< float > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< double > );
+
+cpPlugins_Image_AllDims_Export( itk::DiffusionTensor3D< float > );
+cpPlugins_Image_AllDims_Export( itk::DiffusionTensor3D< double > );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::Vector, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::Vector, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::CovariantVector, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::CovariantVector, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::Point, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::Point, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::SymmetricSecondRankTensor, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::SymmetricSecondRankTensor, double );
+
+// -------------------------------------------------------------------------
+// ITK-only base clases
// -------------------------------------------------------------------------
-// ITK<->VTK base clases
-cpPlugins_VTKImage_Export_AllDimensions( char );
-cpPlugins_VTKImage_Export_AllDimensions( short );
-cpPlugins_VTKImage_Export_AllDimensions( int );
-cpPlugins_VTKImage_Export_AllDimensions( long );
-cpPlugins_VTKImage_Export_AllDimensions( unsigned char );
-cpPlugins_VTKImage_Export_AllDimensions( unsigned short );
-cpPlugins_VTKImage_Export_AllDimensions( unsigned int );
-cpPlugins_VTKImage_Export_AllDimensions( unsigned long );
-cpPlugins_VTKImage_Export_AllDimensions( float );
-cpPlugins_VTKImage_Export_AllDimensions( double );
-
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< char > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< short > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< int > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< long > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< unsigned char > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< unsigned short > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< unsigned int > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBPixel< unsigned long > );
-
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< char > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< short > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< int > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< long > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< unsigned char > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< unsigned short > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< unsigned int > );
-cpPlugins_VTKImage_Export_AllDimensions( itk::RGBAPixel< unsigned long > );
-
-cpPlugins_VTKImageArray_Export_AllDimensions( Vector, float );
-cpPlugins_VTKImageArray_Export_AllDimensions( Vector, double );
-
-cpPlugins_VTKImageArray_Export_AllDimensions( CovariantVector, float );
-cpPlugins_VTKImageArray_Export_AllDimensions( CovariantVector, double );
-
-cpPlugins_VTKImageArray_Export_AllDimensions( Point, float );
-cpPlugins_VTKImageArray_Export_AllDimensions( Point, double );
-
-cpPlugins_VTKImageArray_Export_AllDimensions(
- SymmetricSecondRankTensor, float
- );
-cpPlugins_VTKImageArray_Export_AllDimensions(
- SymmetricSecondRankTensor, double
- );
-
-cpPlugins_VTKImage_Export( itk::DiffusionTensor3D< float >, 3 );
-cpPlugins_VTKImage_Export( itk::DiffusionTensor3D< double >, 3 );
+
+cpPlugins_ITKImage_AllDims_Export( std::complex< float > );
+cpPlugins_ITKImage_AllDims_Export( std::complex< double > );
+
+cpPlugins_ITKImage_Export( itk::Offset< 2 >, 2 );
+cpPlugins_ITKImage_Export( itk::Offset< 3 >, 3 );
+cpPlugins_ITKImage_Export( itk::Offset< 4 >, 4 );
// eof - $RCSfile$
--- /dev/null
+#include <cpPlugins/Interface/Macros.h>
+
+#include <complex>
+
+#include <itkVectorImage.h>
+
+#include <itkCovariantVector.h>
+#include <itkDiffusionTensor3D.h>
+#include <itkPoint.h>
+#include <itkRGBPixel.h>
+#include <itkRGBAPixel.h>
+#include <itkSymmetricSecondRankTensor.h>
+#include <itkVector.h>
+
+// -------------------------------------------------------------------------
+#define cpPlugins_Image_Export( T, D ) \
+ cpPlugins_TEMPLATE_EXPORT( \
+ 2(class cpPlugins_Interface_EXPORT itk::VectorImage< T, D >) \
+ )
+
+// -------------------------------------------------------------------------
+#define cpPlugins_ArrayImage_Export( A, T, DA, DI ) \
+ cpPlugins_TEMPLATE_EXPORT( \
+ 3(class \
+ cpPlugins_Interface_EXPORT \
+ itk::VectorImage< A< T, DA >, DI >) \
+ )
+
+// -------------------------------------------------------------------------
+#define cpPlugins_Image_AllDims_Export( T ) \
+ cpPlugins_Image_Export( T, 2 ); \
+ cpPlugins_Image_Export( T, 3 ); \
+ cpPlugins_Image_Export( T, 4 )
+
+// -------------------------------------------------------------------------
+#define cpPlugins_ArrayImage_AllDims_Export( A, T ) \
+ cpPlugins_ArrayImage_Export( A, T, 2, 2 ); \
+ cpPlugins_ArrayImage_Export( A, T, 3, 3 ); \
+ cpPlugins_ArrayImage_Export( A, T, 4, 4 )
+
+// -------------------------------------------------------------------------
+// ITK-VTK base clases
+// -------------------------------------------------------------------------
+
+cpPlugins_Image_AllDims_Export( char );
+cpPlugins_Image_AllDims_Export( short );
+cpPlugins_Image_AllDims_Export( int );
+cpPlugins_Image_AllDims_Export( long );
+cpPlugins_Image_AllDims_Export( unsigned char );
+cpPlugins_Image_AllDims_Export( unsigned short );
+cpPlugins_Image_AllDims_Export( unsigned int );
+cpPlugins_Image_AllDims_Export( unsigned long );
+cpPlugins_Image_AllDims_Export( float );
+cpPlugins_Image_AllDims_Export( double );
+
+cpPlugins_Image_AllDims_Export( std::complex< float > );
+cpPlugins_Image_AllDims_Export( std::complex< double > );
+
+cpPlugins_Image_Export( itk::Offset< 2 >, 2 );
+cpPlugins_Image_Export( itk::Offset< 3 >, 3 );
+cpPlugins_Image_Export( itk::Offset< 4 >, 4 );
+
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< char > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< short > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< int > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< long > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned char > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned short > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned int > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< unsigned long > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< float > );
+cpPlugins_Image_AllDims_Export( itk::RGBPixel< double > );
+
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< char > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< short > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< int > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< long > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned char > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned short > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned int > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< unsigned long > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< float > );
+cpPlugins_Image_AllDims_Export( itk::RGBAPixel< double > );
+
+cpPlugins_Image_AllDims_Export( itk::DiffusionTensor3D< float > );
+cpPlugins_Image_AllDims_Export( itk::DiffusionTensor3D< double > );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::Vector, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::Vector, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::CovariantVector, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::CovariantVector, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::Point, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::Point, double );
+
+cpPlugins_ArrayImage_AllDims_Export( itk::SymmetricSecondRankTensor, float );
+cpPlugins_ArrayImage_AllDims_Export( itk::SymmetricSecondRankTensor, double );
+
+// eof - $RCSfile$
#define cpPlugins_TEMPLATE_IMPORT( X ) \
extern template cpPlugins_TEMPLATE_##X;
-/* TODO
- #define cpPlugins_EXPORT_TEMPLATE( E, c, T ) \
- cpPlugins_TEMPLATE_##c( cpPlugins_TEMPLATE_EXPORT, E, T )
- #define cpPlugins_IMPORT_TEMPLATE( E, c, T ) \
- cpPlugins_TEMPLATE_##c( cpPlugins_TEMPLATE_IMPORT, E, T )
-*/
-
#endif // __CPPLUGINS__INTERFACE__MACROS__H__
// eof - $RCSfile$
-#include <cpPlugins/Plugins/BinaryThresholdImageFilter.h>
+#include "BinaryThresholdImageFilter.h"
#include <cpPlugins/Interface/Image.h>
#include <itkBinaryThresholdImageFilter.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::BinaryThresholdImageFilter::
+cpPlugins::BasicFilters::BinaryThresholdImageFilter::
BinaryThresholdImageFilter( )
: Superclass( )
{
- this->m_ClassName = "cpPlugins::BinaryThresholdImageFilter";
+ this->m_ClassName = "cpPlugins::BasicFilters::BinaryThresholdImageFilter";
this->m_ClassCategory = "ImageToImageFilter";
this->SetNumberOfInputs( 1 );
this->SetNumberOfOutputs( 1 );
this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
using namespace cpPlugins::Interface;
- this->m_DefaultParameters.Configure(Parameters::Real, "LowerThresholdValue");
- this->m_DefaultParameters.Configure(Parameters::Real, "UpperThresholdValue");
- this->m_DefaultParameters.Configure(Parameters::Real, "InsideValue");
- this->m_DefaultParameters.Configure(Parameters::Real, "OutsideValue");
+ this->m_DefaultParameters.Configure( Parameters::Real, "LowerThresholdValue" );
+ this->m_DefaultParameters.Configure( Parameters::Real, "UpperThresholdValue" );
+ this->m_DefaultParameters.Configure( Parameters::Real, "InsideValue" );
+ this->m_DefaultParameters.Configure( Parameters::Real, "OutsideValue" );
- this->m_DefaultParameters.SetValueAsReal("LowerThresholdValue", 100);
- this->m_DefaultParameters.SetValueAsReal("UpperThresholdValue",500);
- this->m_DefaultParameters.SetValueAsReal("InsideValue", 255);
- this->m_DefaultParameters.SetValueAsReal("OutsideValue", 0);
+ this->m_DefaultParameters.SetValueAsReal( "LowerThresholdValue", 100 );
+ this->m_DefaultParameters.SetValueAsReal( "UpperThresholdValue", 500 );
+ this->m_DefaultParameters.SetValueAsReal( "InsideValue", 255 );
+ this->m_DefaultParameters.SetValueAsReal( "OutsideValue", 0 );
- //this->m_DefaultParameters.Configure(
-
- // Parameters::Uint, "NumberOfHistogramBins"
- // );
- //this->m_DefaultParameters.Configure( Parameters::Real, "InsideValue" );
- //this->m_DefaultParameters.Configure( Parameters::Real, "OutsideValue" );
- //this->m_DefaultParameters.SetValueAsUint( "NumberOfHistogramBins", 100 );
- //this->m_DefaultParameters.SetValueAsReal( "InsideValue", 255 );
- //this->m_DefaultParameters.SetValueAsReal( "OutsideValue", 0 );
this->m_Parameters = this->m_DefaultParameters;
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::BinaryThresholdImageFilter::
+cpPlugins::BasicFilters::BinaryThresholdImageFilter::
~BinaryThresholdImageFilter( )
{
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::BinaryThresholdImageFilter::
+std::string cpPlugins::BasicFilters::BinaryThresholdImageFilter::
_GenerateData( )
{
cpPlugins::Interface::Image* image =
// -------------------------------------------------------------------------
template< class I >
-std::string cpPlugins::Plugins::BinaryThresholdImageFilter::
+std::string cpPlugins::BasicFilters::BinaryThresholdImageFilter::
_DemangleOutput( itk::DataObject* image )
{
return(
// -------------------------------------------------------------------------
template< class I, class O >
-inline std::string cpPlugins::Plugins::BinaryThresholdImageFilter::
+inline std::string cpPlugins::BasicFilters::BinaryThresholdImageFilter::
_RealGD( itk::DataObject* image )
{
typedef itk::BinaryThresholdImageFilter< I, O > _F;
+ typedef typename I::PixelType _IP;
typedef typename O::PixelType _OP;
// Get parameters
//unsigned int bins =
// this->m_Parameters.GetValueAsUint( "NumberOfHistogramBins" );
- _OP lower_val = _OP(this->m_Parameters.GetValueAsReal("LowerValue"));
- _OP upper_val = _OP(this->m_Parameters.GetValueAsReal("UpperValue"));
+ _IP lower_val = _IP( this->m_Parameters.GetValueAsReal( "LowerValue" ) );
+ _IP upper_val = _IP( this->m_Parameters.GetValueAsReal( "UpperValue" ) );
_OP in_val = _OP( this->m_Parameters.GetValueAsReal( "InsideValue" ) );
_OP out_val = _OP( this->m_Parameters.GetValueAsReal( "OutsideValue" ) );
} // fi
filter->SetInput( dynamic_cast< I* >( image ) );
- //filter->SetNumberOfHistogramBins( bins );
- filter->SetLowerThreshold(lower_val);
- filter->SetUpperThreshold(upper_val);
+ filter->SetLowerThreshold( lower_val );
+ filter->SetUpperThreshold( upper_val );
filter->SetInsideValue( in_val );
filter->SetOutsideValue( out_val );
filter->Update( );
#ifndef __CPPLUGINS__PLUGINS__BINARYTHRESHOLDIMAGEFILTER__H__
#define __CPPLUGINS__PLUGINS__BINARYTHRESHOLDIMAGEFILTER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/BasicFilters/cpPluginsBasicFilters_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace cpPlugins
{
- namespace Plugins
+ namespace BasicFilters
{
/**
*/
- class cpPlugins_EXPORT BinaryThresholdImageFilter
+ class cpPluginsBasicFilters_EXPORT BinaryThresholdImageFilter
: public cpPlugins::Interface::ImageToImageFilter
{
public:
- typedef BinaryThresholdImageFilter Self;
+ typedef BinaryThresholdImageFilter Self;
typedef cpPlugins::Interface::ImageToImageFilter Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
public:
itkNewMacro( Self );
- itkTypeMacro( BinaryThresholdImageFilter, cpPluginsInterfaceImageToImageFilter );
+ itkTypeMacro(
+ BinaryThresholdImageFilter,
+ cpPluginsInterfaceImageToImageFilter
+ );
protected:
BinaryThresholdImageFilter( );
--- /dev/null
+SET(LIBRARY_NAME cpPluginsBasicFilters)
+
+## ===============
+## = 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")
+
+## =====================
+## = Compilation rules =
+## =====================
+
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${LIBRARY_NAME}_Host.cxx
+ DEPENDS ${PROJECT_BINARY_DIR}/cpPlugins_createHost ${LIB_HEADERS_H} ${LIB_HEADERS_HPP} ${LIB_HEADERS_HXX}
+ COMMAND ${PROJECT_BINARY_DIR}/cpPlugins_createHost ${LIBRARY_NAME}_Host.cxx cpPlugins::BasicFilters ${LIB_HEADERS_H}
+ )
+
+ADD_LIBRARY(
+ ${LIBRARY_NAME}
+ SHARED
+ ${LIBRARY_NAME}_Host.cxx
+ ${LIB_SOURCES_C}
+ ${LIB_SOURCES_CPP}
+ ${LIB_SOURCES_CXX}
+ )
+GENERATE_EXPORT_HEADER(
+ ${LIBRARY_NAME}
+ BASE_NAME ${LIBRARY_NAME}
+ EXPORT_MACRO_NAME ${LIBRARY_NAME}_EXPORT
+ EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/lib/cpPlugins/BasicFilters/${LIBRARY_NAME}_Export.h
+ STATIC_DEFINE ${LIBRARY_NAME}_BUILT_AS_STATIC
+ )
+TARGET_LINK_LIBRARIES(
+ ${LIBRARY_NAME}
+ cpPlugins_Interface
+ cpExtensions
+ )
+
+## ========================
+## -- Installation rules --
+## ========================
+
+INSTALL(
+ TARGETS ${LIBRARY_NAME}
+ RUNTIME DESTINATION bin
+ LIBRARY DESTINATION lib
+ ARCHIVE DESTINATION lib/static
+ )
+
+## eof - $RCSfile$
-#include <cpPlugins/Plugins/MarchingCubes.h>
+#include "MarchingCubes.h"
#include <cpPlugins/Interface/Image.h>
#include <cpPlugins/Interface/Mesh.h>
#include <vtkMarchingSquares.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MarchingCubes::
+cpPlugins::BasicFilters::MarchingCubes::
MarchingCubes( )
: Superclass( ),
m_Algorithm( NULL )
{
- this->m_ClassName = "cpPlugins::MarchingCubes";
+ this->m_ClassName = "cpPlugins::BasicFilters::MarchingCubes";
this->m_ClassCategory = "ImageToMeshFilter";
this->SetNumberOfInputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MarchingCubes::
+cpPlugins::BasicFilters::MarchingCubes::
~MarchingCubes( )
{
if( this->m_Algorithm != NULL )
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::MarchingCubes::
+std::string cpPlugins::BasicFilters::MarchingCubes::
_GenerateData( )
{
// Get input
#ifndef __CPPLUGINS__PLUGINS__MARCHINGCUBES__H__
#define __CPPLUGINS__PLUGINS__MARCHINGCUBES__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/BasicFilters/cpPluginsBasicFilters_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
class vtkPolyDataAlgorithm;
namespace cpPlugins
{
- namespace Plugins
+ namespace BasicFilters
{
/**
*/
- class cpPlugins_EXPORT MarchingCubes
+ class cpPluginsBasicFilters_EXPORT MarchingCubes
: public cpPlugins::Interface::ImageToMeshFilter
{
public:
-#include <cpPlugins/Plugins/MedianImageFilter.h>
+#include "MedianImageFilter.h"
#include <cpPlugins/Interface/Image.h>
#include <itkMedianImageFilter.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MedianImageFilter::
+cpPlugins::BasicFilters::MedianImageFilter::
MedianImageFilter( )
: Superclass( )
{
- this->m_ClassName = "cpPlugins::MedianImageFilter";
+ this->m_ClassName = "cpPlugins::BasicFilters::MedianImageFilter";
this->m_ClassCategory = "ImageToImageFilter";
this->SetNumberOfInputs( 1 );
this->SetNumberOfOutputs( 1 );
this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
using namespace cpPlugins::Interface;
- this->m_DefaultParameters.Configure(Parameters::Real, "Radius");
-
- this->m_DefaultParameters.SetValueAsReal("Radius", 3);
-
+ this->m_DefaultParameters.Configure( Parameters::Uint, "Radius" );
+
+ this->m_DefaultParameters.SetValueAsUint( "Radius", 3 );
+
this->m_Parameters = this->m_DefaultParameters;
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MedianImageFilter::
+cpPlugins::BasicFilters::MedianImageFilter::
~MedianImageFilter( )
{
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::MedianImageFilter::
+std::string cpPlugins::BasicFilters::MedianImageFilter::
_GenerateData( )
{
cpPlugins::Interface::Image* image =
// -------------------------------------------------------------------------
template< class I >
-std::string cpPlugins::Plugins::MedianImageFilter::
+std::string cpPlugins::BasicFilters::MedianImageFilter::
_DemangleOutput( itk::DataObject* image )
{
return(
// -------------------------------------------------------------------------
template< class I, class O >
-inline std::string cpPlugins::Plugins::MedianImageFilter::
+inline std::string cpPlugins::BasicFilters::MedianImageFilter::
_RealGD( itk::DataObject* image )
{
typedef itk::MedianImageFilter< I, O > _F;
- typedef typename O::PixelType _OP;
+ typedef typename _F::RadiusType _RT;
// Get parameters
-
- _OP rad_val = _OP(this->m_Parameters.GetValueAsReal("Radius"));
-
+ _RT rad_val;
+ rad_val.Fill( this->m_Parameters.GetValueAsUint( "Radius" ) );
// Configure filter
_F* filter = dynamic_cast< _F* >( this->m_RealProcessObject.GetPointer( ) );
} // fi
filter->SetInput( dynamic_cast< I* >( image ) );
-
- filter->SetRadius(rad_val);
-
+ filter->SetRadius( rad_val );
+
filter->Update( );
// Connect output
#ifndef __CPPLUGINS__PLUGINS__MEDIANIMAGEFILTER__H__
#define __CPPLUGINS__PLUGINS__MEDIANIMAGEFILTER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/BasicFilters/cpPluginsBasicFilters_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace cpPlugins
{
- namespace Plugins
+ namespace BasicFilters
{
/**
*/
- class cpPlugins_EXPORT MedianImageFilter
+ class cpPluginsBasicFilters_EXPORT MedianImageFilter
: public cpPlugins::Interface::ImageToImageFilter
{
public:
- typedef MedianImageFilter Self;
+ typedef MedianImageFilter Self;
typedef cpPlugins::Interface::ImageToImageFilter Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
public:
itkNewMacro( Self );
- itkTypeMacro( MedianImageFilter, cpPluginsInterfaceImageToImageFilter );
+ itkTypeMacro(
+ MedianImageFilter,
+ cpPluginsInterfaceImageToImageFilter
+ );
protected:
MedianImageFilter( );
-#include <cpPlugins/Plugins/OtsuThresholdImageFilter.h>
+#include "OtsuThresholdImageFilter.h"
#include <cpPlugins/Interface/Image.h>
#include <itkOtsuThresholdImageFilter.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::OtsuThresholdImageFilter::
+cpPlugins::BasicFilters::OtsuThresholdImageFilter::
OtsuThresholdImageFilter( )
: Superclass( )
{
- this->m_ClassName = "cpPlugins::OtsuThresholdImageFilter";
+ this->m_ClassName = "cpPlugins::BasicFilters::OtsuThresholdImageFilter";
this->m_ClassCategory = "ImageToImageFilter";
this->SetNumberOfInputs( 1 );
this->SetNumberOfOutputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::OtsuThresholdImageFilter::
+cpPlugins::BasicFilters::OtsuThresholdImageFilter::
~OtsuThresholdImageFilter( )
{
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::OtsuThresholdImageFilter::
+std::string cpPlugins::BasicFilters::OtsuThresholdImageFilter::
_GenerateData( )
{
cpPlugins::Interface::Image* image =
// -------------------------------------------------------------------------
template< class I >
-std::string cpPlugins::Plugins::OtsuThresholdImageFilter::
+std::string cpPlugins::BasicFilters::OtsuThresholdImageFilter::
_DemangleOutput( itk::DataObject* image )
{
return(
// -------------------------------------------------------------------------
template< class I, class O >
-inline std::string cpPlugins::Plugins::OtsuThresholdImageFilter::
+inline std::string cpPlugins::BasicFilters::OtsuThresholdImageFilter::
_RealGD( itk::DataObject* image )
{
typedef itk::OtsuThresholdImageFilter< I, O > _F;
#ifndef __CPPLUGINS__PLUGINS__OTSUTHRESHOLDIMAGEFILTER__H__
#define __CPPLUGINS__PLUGINS__OTSUTHRESHOLDIMAGEFILTER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/BasicFilters/cpPluginsBasicFilters_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace cpPlugins
{
- namespace Plugins
+ namespace BasicFilters
{
/**
*/
- class cpPlugins_EXPORT OtsuThresholdImageFilter
+ class cpPluginsBasicFilters_EXPORT OtsuThresholdImageFilter
: public cpPlugins::Interface::ImageToImageFilter
{
public:
-#include <cpPlugins/Plugins/RGBImageToOtherChannelsFilter.h>
+#include "RGBImageToOtherChannelsFilter.h"
#include <cpPlugins/Interface/Image.h>
#include <cpExtensions/Algorithms/RGBImageToOtherChannelsFilter.h>
#include <cpExtensions/Algorithms/RGBToYPbPrFunction.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::RGBImageToOtherChannelsFilter::
+cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter::
RGBImageToOtherChannelsFilter( )
: Superclass( )
{
typedef cpPlugins::Interface::Parameters TParameters;
- this->m_ClassName = "cpPlugins::RGBImageToOtherChannelsFilter";
+ this->m_ClassName = "cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter";
this->m_ClassCategory = "ImageToImageFilter";
this->SetNumberOfInputs( 1 );
this->SetNumberOfOutputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::RGBImageToOtherChannelsFilter::
+cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter::
~RGBImageToOtherChannelsFilter( )
{
}
)
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::RGBImageToOtherChannelsFilter::
+std::string cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter::
_GenerateData( )
{
cpPlugins::Interface::Image* image =
// -------------------------------------------------------------------------
template< class I >
-std::string cpPlugins::Plugins::RGBImageToOtherChannelsFilter::
+std::string cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter::
_DemangleOutput( itk::DataObject* image )
{
typedef typename I::PixelType _P;
// -------------------------------------------------------------------------
template< class I, class C >
-std::string cpPlugins::Plugins::RGBImageToOtherChannelsFilter::
+std::string cpPlugins::BasicFilters::RGBImageToOtherChannelsFilter::
_RealGD( itk::DataObject* image )
{
typedef itk::Image< itk::RGBPixel< double >, I::ImageDimension > _O;
#ifndef __CPPLUGINS__PLUGINS__RGBIMAGETOOTHERCHANNELSFILTER__H__
#define __CPPLUGINS__PLUGINS__RGBIMAGETOOTHERCHANNELSFILTER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/BasicFilters/cpPluginsBasicFilters_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace cpPlugins
{
- namespace Plugins
+ namespace BasicFilters
{
/**
*/
- class cpPlugins_EXPORT RGBImageToOtherChannelsFilter
+ class cpPluginsBasicFilters_EXPORT RGBImageToOtherChannelsFilter
: public cpPlugins::Interface::ImageToImageFilter
{
public:
-SET(LIBRARY_NAME cpPlugins)
-
-## ===============
-## = 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")
-
-## =====================
-## = Compilation rules =
-## =====================
-
-ADD_LIBRARY(
- ${LIBRARY_NAME}
- SHARED
- ${LIB_SOURCES_C}
- ${LIB_SOURCES_CPP}
- ${LIB_SOURCES_CXX}
- )
-GENERATE_EXPORT_HEADER(
- ${LIBRARY_NAME}
- BASE_NAME ${LIBRARY_NAME}
- EXPORT_MACRO_NAME ${LIBRARY_NAME}_EXPORT
- EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/lib/cpPlugins/Plugins/${LIBRARY_NAME}_Export.h
- STATIC_DEFINE ${LIBRARY_NAME}_BUILT_AS_STATIC
- )
-TARGET_LINK_LIBRARIES(
- ${LIBRARY_NAME}
- cpExtensions
- cpPlugins_Interface
- )
-
-## ========================
-## -- Installation rules --
-## ========================
-
-INSTALL(
- TARGETS ${LIBRARY_NAME}
- RUNTIME DESTINATION bin
- LIBRARY DESTINATION lib
- ARCHIVE DESTINATION lib/static
+SUBDIRS(
+ IO
+ BasicFilters
)
## eof - $RCSfile$
+++ /dev/null
-#include <Pluma/Connector.hpp>
-#include <cpPlugins/Plugins/ImageReader.h>
-#include <cpPlugins/Plugins/ImageWriter.h>
-#include <cpPlugins/Plugins/MeshReader.h>
-#include <cpPlugins/Plugins/MeshWriter.h>
-#include <cpPlugins/Plugins/MarchingCubes.h>
-#include <cpPlugins/Plugins/OtsuThresholdImageFilter.h>
-#include <cpPlugins/Plugins/RGBImageToOtherChannelsFilter.h>
-#include <cpPlugins/Plugins/SecondRankDiffusionTensorToPolyData.h>
-#include <cpPlugins/Plugins/BinaryThresholdImageFilter.h>
-#include <cpPlugins/Plugins/MedianImageFilter.h>
-
-/// TODO: doc
-PLUMA_CONNECTOR
-bool connect( pluma::Host& host )
-{
- using namespace cpPlugins::Plugins;
-
- host.add( new ImageReaderProvider( ) );
- host.add( new ImageWriterProvider( ) );
- host.add( new MeshReaderProvider( ) );
- host.add( new MeshWriterProvider( ) );
- host.add( new MarchingCubesProvider( ) );
- host.add( new OtsuThresholdImageFilterProvider( ) );
- host.add( new RGBImageToOtherChannelsFilterProvider( ) );
- host.add( new SecondRankDiffusionTensorToPolyDataProvider( ) );
- host.add( new BinaryThresholdImageFilterProvider( ) );
- host.add( new MedianImageFilterProvider( ) );
-
- return( true );
-}
-
-// eof - $RCSfile$
--- /dev/null
+SET(LIBRARY_NAME cpPluginsIO)
+
+## ===============
+## = 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")
+
+## =====================
+## = Compilation rules =
+## =====================
+
+ADD_CUSTOM_COMMAND(
+ OUTPUT ${LIBRARY_NAME}_Host.cxx
+ DEPENDS ${PROJECT_BINARY_DIR}/cpPlugins_createHost ${LIB_HEADERS_H} ${LIB_HEADERS_HPP} ${LIB_HEADERS_HXX}
+ COMMAND ${PROJECT_BINARY_DIR}/cpPlugins_createHost ${LIBRARY_NAME}_Host.cxx cpPlugins::IO ${LIB_HEADERS_H}
+ )
+
+ADD_LIBRARY(
+ ${LIBRARY_NAME}
+ SHARED
+ ${LIBRARY_NAME}_Host.cxx
+ ${LIB_SOURCES_C}
+ ${LIB_SOURCES_CPP}
+ ${LIB_SOURCES_CXX}
+ )
+GENERATE_EXPORT_HEADER(
+ ${LIBRARY_NAME}
+ BASE_NAME ${LIBRARY_NAME}
+ EXPORT_MACRO_NAME ${LIBRARY_NAME}_EXPORT
+ EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/lib/cpPlugins/IO/${LIBRARY_NAME}_Export.h
+ STATIC_DEFINE ${LIBRARY_NAME}_BUILT_AS_STATIC
+ )
+TARGET_LINK_LIBRARIES(
+ ${LIBRARY_NAME}
+ cpPlugins_Interface
+ )
+
+## ========================
+## -- Installation rules --
+## ========================
+
+INSTALL(
+ TARGETS ${LIBRARY_NAME}
+ RUNTIME DESTINATION bin
+ LIBRARY DESTINATION lib
+ ARCHIVE DESTINATION lib/static
+ )
+
+## eof - $RCSfile$
--- /dev/null
+#include "ImageReader.h"
+#include <cpPlugins/Interface/Image.h>
+
+#include <set>
+
+#include <itkImageFileReader.h>
+#include <itkImageSeriesReader.h>
+
+// -------------------------------------------------------------------------
+cpPlugins::IO::ImageReader::
+ImageReader( )
+ : Superclass( )
+{
+ this->m_ClassName = "cpPlugins::IO::ImageReader";
+ this->m_ClassCategory = "ImageReader";
+
+ this->SetNumberOfOutputs( 1 );
+ this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
+
+ using namespace cpPlugins::Interface;
+ this->m_DefaultParameters.Configure( Parameters::StringList, "FileNames" );
+ this->m_DefaultParameters.Configure( Parameters::Bool, "VectorType" );
+ this->m_DefaultParameters.SetValueAsBool( "VectorType", false );
+ this->m_Parameters = this->m_DefaultParameters;
+}
+
+// -------------------------------------------------------------------------
+cpPlugins::IO::ImageReader::
+~ImageReader( )
+{
+}
+
+// -------------------------------------------------------------------------
+std::string cpPlugins::IO::ImageReader::
+_GenerateData( )
+{
+ // Get filenames
+ TStringList names;
+ this->m_Parameters.GetValueAsStringList( names, "FileNames" );
+
+ std::string r = "";
+ if( names.size( ) >= 1 )
+ {
+ // Guess image properties
+ itk::ImageIOBase::Pointer io =
+ itk::ImageIOFactory::CreateImageIO(
+ names[ 0 ].c_str( ),
+ itk::ImageIOFactory::ReadMode
+ );
+ if( io.IsNotNull( ) )
+ {
+ io->SetFileName( names[ 0 ] );
+ io->ReadImageInformation( );
+ if( names.size( ) >= 1 )
+ {
+ switch( io->GetNumberOfDimensions( ) )
+ {
+ case 2: r = this->_GD0< 2 >( io, names ); break;
+ case 3: r = this->_GD0< 3 >( io, names ); break;
+ case 4: r = this->_GD0< 4 >( io, names ); break;
+ default:
+ r = "ImageReader: Image dimension not supported.";
+ break;
+ } // hctiws
+
+ } // fi
+ }
+ else
+ r = "ImageReader: Could not CreateImageIO for \"" + names[ 0 ] + "\"";
+ }
+ else
+ r = "No image files given";
+ return( r );
+}
+
+// -------------------------------------------------------------------------
+template< unsigned int D >
+std::string cpPlugins::IO::ImageReader::
+_GD0( itk::ImageIOBase* io, const TStringList& names )
+{
+ itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
+ itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
+ std::string r = "";
+
+ if( pt == itk::ImageIOBase::SCALAR )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::UCHAR:
+ r = this->_GD1< unsigned char, D >( names );
+ break;
+ case itk::ImageIOBase::CHAR:
+ r = this->_GD1< char, D >( names );
+ break;
+ case itk::ImageIOBase::USHORT:
+ r = this->_GD1< unsigned short, D >( names );
+ break;
+ case itk::ImageIOBase::SHORT:
+ r = this->_GD1< short, D >( names );
+ break;
+ case itk::ImageIOBase::UINT:
+ r = this->_GD1< unsigned int, D >( names );
+ break;
+ case itk::ImageIOBase::INT:
+ r = this->_GD1< int, D >( names );
+ break;
+ case itk::ImageIOBase::ULONG:
+ r = this->_GD1< unsigned long, D >( names );
+ break;
+ case itk::ImageIOBase::LONG:
+ r = this->_GD1< long, D >( names );
+ break;
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< float, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< double, D >( names );
+ break;
+ default:
+ r = "ImageReader: Scalar pixel type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::RGB )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::UCHAR:
+ r = this->_GD1< itk::RGBPixel< unsigned char >, D >( names );
+ break;
+ case itk::ImageIOBase::CHAR:
+ r = this->_GD1< itk::RGBPixel< char >, D >( names );
+ break;
+ case itk::ImageIOBase::USHORT:
+ r = this->_GD1< itk::RGBPixel< unsigned short >, D >( names );
+ break;
+ case itk::ImageIOBase::SHORT:
+ r = this->_GD1< itk::RGBPixel< short >, D >( names );
+ break;
+ case itk::ImageIOBase::UINT:
+ r = this->_GD1< itk::RGBPixel< unsigned int >, D >( names );
+ break;
+ case itk::ImageIOBase::INT:
+ r = this->_GD1< itk::RGBPixel< int >, D >( names );
+ break;
+ case itk::ImageIOBase::ULONG:
+ r = this->_GD1< itk::RGBPixel< unsigned long >, D >( names );
+ break;
+ case itk::ImageIOBase::LONG:
+ r = this->_GD1< itk::RGBPixel< long >, D >( names );
+ break;
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::RGBPixel< float >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::RGBPixel< double >, D >( names );
+ break;
+ default:
+ r = "ImageReader: RGB pixel type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::RGBA )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::UCHAR:
+ r = this->_GD1< itk::RGBAPixel< unsigned char >, D >( names );
+ break;
+ case itk::ImageIOBase::CHAR:
+ r = this->_GD1< itk::RGBAPixel< char >, D >( names );
+ break;
+ case itk::ImageIOBase::USHORT:
+ r = this->_GD1< itk::RGBAPixel< unsigned short >, D >( names );
+ break;
+ case itk::ImageIOBase::SHORT:
+ r = this->_GD1< itk::RGBAPixel< short >, D >( names );
+ break;
+ case itk::ImageIOBase::UINT:
+ r = this->_GD1< itk::RGBAPixel< unsigned int >, D >( names );
+ break;
+ case itk::ImageIOBase::INT:
+ r = this->_GD1< itk::RGBAPixel< int >, D >( names );
+ break;
+ case itk::ImageIOBase::ULONG:
+ r = this->_GD1< itk::RGBAPixel< unsigned long >, D >( names );
+ break;
+ case itk::ImageIOBase::LONG:
+ r = this->_GD1< itk::RGBAPixel< long >, D >( names );
+ break;
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::RGBAPixel< float >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::RGBAPixel< double >, D >( names );
+ break;
+ default:
+ r = "ImageReader: RGBA pixel type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::VECTOR )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::Vector< float, D >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::Vector< double, D >, D >( names );
+ break;
+ default:
+ r = "ImageReader: Vector type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::POINT )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::Point< float, D >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::Point< double, D >, D >( names );
+ break;
+ default:
+ r = "ImageReader: Point type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::COVARIANTVECTOR )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::CovariantVector< float, D >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::CovariantVector< double, D >, D >( names );
+ break;
+ default:
+ r = "ImageReader: CovariantVector type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r =
+ this->_GD1< itk::SymmetricSecondRankTensor< float, D >, D >(
+ names
+ );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r =
+ this->_GD1< itk::SymmetricSecondRankTensor< double, D >, D >(
+ names
+ );
+ break;
+ default:
+ r = "ImageReader: Vector type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::DIFFUSIONTENSOR3D )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< itk::DiffusionTensor3D< float >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< itk::DiffusionTensor3D< double >, D >( names );
+ break;
+ default:
+ r = "ImageReader: Diffusion tensor type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::COMPLEX )
+ {
+ switch( ct )
+ {
+ case itk::ImageIOBase::FLOAT:
+ r = this->_GD1< std::complex< float >, D >( names );
+ break;
+ case itk::ImageIOBase::DOUBLE:
+ r = this->_GD1< std::complex< double >, D >( names );
+ break;
+ default:
+ r = "ImageReader: Complex type not supported.";
+ break;
+ } // hctiws
+ }
+ else if( pt == itk::ImageIOBase::OFFSET )
+ r = this->_GD1< itk::Offset< D >, D >( names );
+ else
+ r = "ImageReader: Image pixel type not yet supported.";
+ /* TODO
+ itk::ImageIOBase::FIXEDARRAY
+ itk::ImageIOBase::MATRIX
+ */
+ return( r );
+}
+
+// -------------------------------------------------------------------------
+template< class P, unsigned int D >
+std::string cpPlugins::IO::ImageReader::
+_GD1( const TStringList& names )
+{
+ if( this->m_Parameters.GetValueAsBool( "VectorType" ) )
+ return( this->_RealGD< itk::VectorImage< P, D > >( names ) );
+ else
+ return( this->_RealGD< itk::Image< P, D > >( names ) );
+}
+
+// -------------------------------------------------------------------------
+template< class I >
+std::string cpPlugins::IO::ImageReader::
+_RealGD( const TStringList& names )
+{
+ cpPlugins::Interface::Image* out =
+ this->GetOutput< cpPlugins::Interface::Image >( 0 );
+ if( out == NULL )
+ return( "ImageReader: No output object properly created." );
+
+ std::string r = "";
+ if( names.size( ) == 1 )
+ {
+ // Read single image
+ typedef itk::ImageFileReader< I > _SR;
+ _SR* reader =
+ dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
+ if( reader == NULL )
+ {
+ this->m_RealProcessObject = _SR::New( );
+ reader =
+ dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
+
+ } // fi
+ reader->SetFileName( names[ 0 ] );
+ try
+ {
+ reader->Update( );
+ out->SetITKImage< I >( reader->GetOutput( ) );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ r = "ImageReader: " + std::string( err.GetDescription( ) );
+ out->SetITKImage< I >( NULL );
+
+ } // yrt
+ }
+ else if( names.size( ) > 1 )
+ {
+ // Read image series
+ std::set< std::string > ordered_names;
+ for( unsigned int i = 0; i < names.size( ); ++i )
+ ordered_names.insert( names[ i ] );
+
+ typedef itk::ImageSeriesReader< I > _MR;
+ _MR* reader =
+ dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
+ if( reader == NULL )
+ {
+ this->m_RealProcessObject = _MR::New( );
+ reader =
+ dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
+
+ } // fi
+ std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
+ for( ; fnIt != ordered_names.end( ); ++fnIt )
+ {
+ reader->AddFileName( *fnIt );
+ }
+ try
+ {
+ reader->Update( );
+ out->SetITKImage< I >( reader->GetOutput( ) );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ r = "ImageReader: " + std::string( err.GetDescription( ) );
+ out->SetITKImage< I >( NULL );
+
+ } // yrt
+ }
+ else
+ r = "ImageReader: No image files given";
+ return( r );
+}
+
+// eof - $RCSfile$
#include <vector>
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/IO/cpPluginsIO_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace itk
namespace cpPlugins
{
- namespace Plugins
+ namespace IO
{
/**
*/
- class cpPlugins_EXPORT ImageReader
+ class cpPluginsIO_EXPORT ImageReader
: public cpPlugins::Interface::ImageSource
{
public:
std::string _GD0( itk::ImageIOBase* io, const TStringList& names );
template< class P, unsigned int D >
+ std::string _GD1( const TStringList& names );
+
+ template< class I >
std::string _RealGD( const TStringList& names );
private:
-#include <cpPlugins/Plugins/ImageWriter.h>
+#include "ImageWriter.h"
#include <cpPlugins/Interface/Image.h>
#include <itkImageFileWriter.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::ImageWriter::
+cpPlugins::IO::ImageWriter::
ImageWriter( )
: Superclass( )
{
- this->m_ClassName = "cpPlugins::ImageWriter";
+ this->m_ClassName = "cpPlugins::IO::ImageWriter";
this->m_ClassCategory = "ImageWriter";
this->SetNumberOfInputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::ImageWriter::
+cpPlugins::IO::ImageWriter::
~ImageWriter( )
{
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::ImageWriter::
+std::string cpPlugins::IO::ImageWriter::
_GenerateData( )
{
cpPlugins::Interface::Image* image =
// -------------------------------------------------------------------------
template< class I >
-std::string cpPlugins::Plugins::ImageWriter::
+std::string cpPlugins::IO::ImageWriter::
_RealGD( itk::DataObject* image )
{
typedef itk::ImageFileWriter< I > _W;
#ifndef __CPPLUGINS__PLUGINS__IMAGEWRITER__H__
#define __CPPLUGINS__PLUGINS__IMAGEWRITER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/IO/cpPluginsIO_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
namespace cpPlugins
{
- namespace Plugins
+ namespace IO
{
/**
*/
- class cpPlugins_EXPORT ImageWriter
+ class cpPluginsIO_EXPORT ImageWriter
: public cpPlugins::Interface::ImageSink
{
public:
-#include <cpPlugins/Plugins/MeshReader.h>
+#include "MeshReader.h"
#include <cpPlugins/Interface/Mesh.h>
#include <vtkPolyData.h>
#include <vtkPolyDataReader.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MeshReader::
+cpPlugins::IO::MeshReader::
MeshReader( )
: Superclass( ),
m_Reader( NULL )
{
- this->m_ClassName = "cpPlugins::MeshReader";
+ this->m_ClassName = "cpPlugins::IO::MeshReader";
this->m_ClassCategory = "MeshReader";
this->SetNumberOfOutputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MeshReader::
+cpPlugins::IO::MeshReader::
~MeshReader( )
{
if( this->m_Reader != NULL )
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::MeshReader::
+std::string cpPlugins::IO::MeshReader::
_GenerateData( )
{
using namespace cpPlugins::Interface;
// -------------------------------------------------------------------------
template< unsigned int D >
-std::string cpPlugins::Plugins::MeshReader::
+std::string cpPlugins::IO::MeshReader::
_GD0( )
{
using namespace cpPlugins::Interface;
// -------------------------------------------------------------------------
template< class P, unsigned int D >
-std::string cpPlugins::Plugins::MeshReader::
+std::string cpPlugins::IO::MeshReader::
_GD1( )
{
// Get filename
#ifndef __CPPLUGINS__PLUGINS__MESHREADER__H__
#define __CPPLUGINS__PLUGINS__MESHREADER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/IO/cpPluginsIO_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
class vtkDataReader;
namespace cpPlugins
{
- namespace Plugins
+ namespace IO
{
/**
*/
- class cpPlugins_EXPORT MeshReader
+ class cpPluginsIO_EXPORT MeshReader
: public cpPlugins::Interface::MeshSource
{
public:
-#include <cpPlugins/Plugins/MeshWriter.h>
+#include "MeshWriter.h"
#include <cpPlugins/Interface/Mesh.h>
#include <vtkSmartPointer.h>
#include <vtkPolyDataWriter.h>
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MeshWriter::
+cpPlugins::IO::MeshWriter::
MeshWriter( )
: Superclass( ),
m_Writer( NULL )
{
- this->m_ClassName = "cpPlugins::MeshWriter";
+ this->m_ClassName = "cpPlugins::IO::MeshWriter";
this->m_ClassCategory = "MeshWriter";
this->SetNumberOfInputs( 1 );
}
// -------------------------------------------------------------------------
-cpPlugins::Plugins::MeshWriter::
+cpPlugins::IO::MeshWriter::
~MeshWriter( )
{
if( this->m_Writer != NULL )
}
// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::MeshWriter::
+std::string cpPlugins::IO::MeshWriter::
_GenerateData( )
{
cpPlugins::Interface::Mesh* mesh =
#ifndef __CPPLUGINS__PLUGINS__MESHWRITER__H__
#define __CPPLUGINS__PLUGINS__MESHWRITER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/IO/cpPluginsIO_Export.h>
#include <cpPlugins/Interface/BaseProcessObjects.h>
class vtkDataWriter;
namespace cpPlugins
{
- namespace Plugins
+ namespace IO
{
/**
*/
- class cpPlugins_EXPORT MeshWriter
+ class cpPluginsIO_EXPORT MeshWriter
: public cpPlugins::Interface::MeshSink
{
public:
+++ /dev/null
-#include <cpPlugins/Plugins/ImageReader.h>
-#include <cpPlugins/Interface/Image.h>
-
-#include <set>
-
-#include <itkImageFileReader.h>
-#include <itkImageSeriesReader.h>
-
-// -------------------------------------------------------------------------
-cpPlugins::Plugins::ImageReader::
-ImageReader( )
- : Superclass( )
-{
- this->m_ClassName = "cpPlugins::ImageReader";
- this->m_ClassCategory = "ImageReader";
-
- this->SetNumberOfOutputs( 1 );
- this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
-
- using namespace cpPlugins::Interface;
- this->m_DefaultParameters.Configure( Parameters::StringList, "FileNames" );
- this->m_Parameters = this->m_DefaultParameters;
-}
-
-// -------------------------------------------------------------------------
-cpPlugins::Plugins::ImageReader::
-~ImageReader( )
-{
-}
-
-// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::ImageReader::
-_GenerateData( )
-{
- // Get filenames
- TStringList names;
- this->m_Parameters.GetValueAsStringList( names, "FileNames" );
-
- std::string r = "";
- if( names.size( ) >= 1 )
- {
- // Guess image properties
- itk::ImageIOBase::Pointer io =
- itk::ImageIOFactory::CreateImageIO(
- names[ 0 ].c_str( ),
- itk::ImageIOFactory::ReadMode
- );
- if( io.IsNotNull( ) )
- {
- io->SetFileName( names[ 0 ] );
- io->ReadImageInformation( );
- if( names.size( ) >= 1 )
- {
- switch( io->GetNumberOfDimensions( ) )
- {
- case 2: r = this->_GD0< 2 >( io, names ); break;
- case 3: r = this->_GD0< 3 >( io, names ); break;
- case 4: r = this->_GD0< 4 >( io, names ); break;
- default:
- r = "ImageReader: Image dimension not supported.";
- break;
- } // hctiws
-
- } // fi
- }
- else
- r = "ImageReader: Could not CreateImageIO for \"" + names[ 0 ] + "\"";
- }
- else
- r = "No image files given";
- return( r );
-}
-
-// -------------------------------------------------------------------------
-template< unsigned int D >
-std::string cpPlugins::Plugins::ImageReader::
-_GD0( itk::ImageIOBase* io, const TStringList& names )
-{
- itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
- itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
- std::string r = "";
-
- if( pt == itk::ImageIOBase::SCALAR )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< unsigned char, D >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< char, D >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< unsigned short, D >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< short, D >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< unsigned int, D >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< int, D >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< unsigned long, D >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< long, D >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< float, D >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< double, D >( names );
- break;
- default:
- r = "ImageReader: Scalar pixel type not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::RGB )
- {
- if( D == 2 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBPixel< unsigned char >, 2 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBPixel< char >, 2 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBPixel< unsigned short >, 2 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBPixel< short >, 2 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBPixel< unsigned int >, 2 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBPixel< int >, 2 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBPixel< unsigned long >, 2 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBPixel< long >, 2 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBPixel< float >, 2 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBPixel< double >, 2 >( names );
- break;
- default:
- r = "ImageReader: RGB pixel type not supported.";
- break;
- } // hctiws
- }
- else if( D == 3 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBPixel< unsigned char >, 3 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBPixel< char >, 3 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBPixel< unsigned short >, 3 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBPixel< short >, 3 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBPixel< unsigned int >, 3 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBPixel< int >, 3 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBPixel< unsigned long >, 3 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBPixel< long >, 3 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBPixel< float >, 3 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBPixel< double >, 3 >( names );
- break;
- default:
- r = "ImageReader: RGB pixel type not supported.";
- break;
- } // hctiws
- }
- else if( D == 4 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBPixel< unsigned char >, 4 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBPixel< char >, 4 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBPixel< unsigned short >, 4 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBPixel< short >, 4 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBPixel< unsigned int >, 4 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBPixel< int >, 4 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBPixel< unsigned long >, 4 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBPixel< long >, 4 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBPixel< float >, 4 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBPixel< double >, 4 >( names );
- break;
- default:
- r = "ImageReader: RGB pixel type not supported.";
- break;
- } // hctiws
-
- } // fi
- }
- else if( pt == itk::ImageIOBase::RGBA )
- {
- if( D == 2 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBAPixel< unsigned char >, 2 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBAPixel< char >, 2 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBAPixel< unsigned short >, 2 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBAPixel< short >, 2 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBAPixel< unsigned int >, 2 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBAPixel< int >, 2 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBAPixel< unsigned long >, 2 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBAPixel< long >, 2 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBAPixel< float >, 2 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBAPixel< double >, 2 >( names );
- break;
- default:
- r = "ImageReader: RGBA pixel type not supported.";
- break;
- } // hctiws
- }
- else if( D == 3 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBAPixel< unsigned char >, 3 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBAPixel< char >, 3 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBAPixel< unsigned short >, 3 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBAPixel< short >, 3 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBAPixel< unsigned int >, 3 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBAPixel< int >, 3 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBAPixel< unsigned long >, 3 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBAPixel< long >, 3 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBAPixel< float >, 3 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBAPixel< double >, 3 >( names );
- break;
- default:
- r = "ImageReader: RGBA pixel type not supported.";
- break;
- } // hctiws
- }
- else if( D == 4 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::UCHAR:
- r = this->_RealGD< itk::RGBAPixel< unsigned char >, 4 >( names );
- break;
- case itk::ImageIOBase::CHAR:
- r = this->_RealGD< itk::RGBAPixel< char >, 4 >( names );
- break;
- case itk::ImageIOBase::USHORT:
- r = this->_RealGD< itk::RGBAPixel< unsigned short >, 4 >( names );
- break;
- case itk::ImageIOBase::SHORT:
- r = this->_RealGD< itk::RGBAPixel< short >, 4 >( names );
- break;
- case itk::ImageIOBase::UINT:
- r = this->_RealGD< itk::RGBAPixel< unsigned int >, 4 >( names );
- break;
- case itk::ImageIOBase::INT:
- r = this->_RealGD< itk::RGBAPixel< int >, 4 >( names );
- break;
- case itk::ImageIOBase::ULONG:
- r = this->_RealGD< itk::RGBAPixel< unsigned long >, 4 >( names );
- break;
- case itk::ImageIOBase::LONG:
- r = this->_RealGD< itk::RGBAPixel< long >, 4 >( names );
- break;
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::RGBAPixel< float >, 4 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::RGBAPixel< double >, 4 >( names );
- break;
- default:
- r = "ImageReader: RGBA pixel type not supported.";
- break;
- } // hctiws
-
- } // fi
- }
- else if( pt == itk::ImageIOBase::OFFSET )
- {
- switch( D )
- {
- case 2:
- r = this->_RealGD< itk::Offset< 2 >, 2 >( names );
- break;
- case 3:
- r = this->_RealGD< itk::Offset< 3 >, 3 >( names );
- break;
- case 4:
- r = this->_RealGD< itk::Offset< 4 >, 4 >( names );
- break;
- default:
- r = "ImageReader: Offset pixel dimension not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::VECTOR )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::Vector< float, D >, D >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::Vector< double, D >, D >( names );
- break;
- default:
- r = "ImageReader: Vector type not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::POINT )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::Point< float, D >, D >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::Point< double, D >, D >( names );
- break;
- default:
- r = "ImageReader: Point type not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::COVARIANTVECTOR )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::CovariantVector< float, D >, D >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::CovariantVector< double, D >, D >( names );
- break;
- default:
- r = "ImageReader: CovariantVector type not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r =
- this->_RealGD< itk::SymmetricSecondRankTensor< float, D >, D >(
- names
- );
- break;
- case itk::ImageIOBase::DOUBLE:
- r =
- this->_RealGD< itk::SymmetricSecondRankTensor< double, D >, D >(
- names
- );
- break;
- default:
- r = "ImageReader: Vector type not supported.";
- break;
- } // hctiws
- }
- else if( pt == itk::ImageIOBase::DIFFUSIONTENSOR3D )
- {
- if( D == 3 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::DiffusionTensor3D< float >, 3 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::DiffusionTensor3D< double >, 3 >( names );
- break;
- default:
- r = "ImageReader: Diffusion tensor type not supported.";
- break;
- } // hctiws
- }
- else if( D == 4 )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< itk::DiffusionTensor3D< float >, 4 >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< itk::DiffusionTensor3D< double >, 4 >( names );
- break;
- default:
- r = "ImageReader: Diffusion tensor type not supported.";
- break;
- } // hctiws
- }
- else
- r = "ImageReader: Diffusion tensor dimension not supported.";
- }
- else if( pt == itk::ImageIOBase::COMPLEX )
- {
- switch( ct )
- {
- case itk::ImageIOBase::FLOAT:
- r = this->_RealGD< std::complex< float >, D >( names );
- break;
- case itk::ImageIOBase::DOUBLE:
- r = this->_RealGD< std::complex< double >, D >( names );
- break;
- default:
- r = "ImageReader: Complex type not supported.";
- break;
- } // hctiws
- }
- else
- r = "ImageReader: Image pixel type not yet supported.";
- /* TODO
- itk::ImageIOBase::FIXEDARRAY
- itk::ImageIOBase::MATRIX
- */
-
- return( r );
-}
-
-// -------------------------------------------------------------------------
-template< class P, unsigned int D >
-std::string cpPlugins::Plugins::ImageReader::
-_RealGD( const TStringList& names )
-{
- typedef itk::Image< P, D > _I;
-
- cpPlugins::Interface::Image* out =
- this->GetOutput< cpPlugins::Interface::Image >( 0 );
- if( out == NULL )
- return( "ImageReader: No output object properly created." );
-
- std::string r = "";
- if( names.size( ) == 1 )
- {
- // Read single image
- typedef itk::ImageFileReader< _I > _SR;
- _SR* reader =
- dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
- if( reader == NULL )
- {
- this->m_RealProcessObject = _SR::New( );
- reader =
- dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
-
- } // fi
- reader->SetFileName( names[ 0 ] );
- try
- {
- reader->Update( );
- out->SetITKImage< _I >( reader->GetOutput( ) );
- }
- catch( itk::ExceptionObject& err )
- {
- r = "ImageReader: " + std::string( err.GetDescription( ) );
- out->SetITKImage< _I >( NULL );
-
- } // yrt
- }
- else if( names.size( ) > 1 )
- {
- // Read image series
- std::set< std::string > ordered_names;
- for( unsigned int i = 0; i < names.size( ); ++i )
- ordered_names.insert( names[ i ] );
-
- typedef itk::ImageSeriesReader< _I > _MR;
- _MR* reader =
- dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
- if( reader == NULL )
- {
- this->m_RealProcessObject = _MR::New( );
- reader =
- dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
-
- } // fi
- std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
- for( ; fnIt != ordered_names.end( ); ++fnIt )
- {
- reader->AddFileName( *fnIt );
- }
- try
- {
- reader->Update( );
- out->SetITKImage< _I >( reader->GetOutput( ) );
- }
- catch( itk::ExceptionObject& err )
- {
- r = "ImageReader: " + std::string( err.GetDescription( ) );
- out->SetITKImage< _I >( NULL );
-
- } // yrt
- }
- else
- r = "ImageReader: No image files given";
- return( r );
-}
-
-// eof - $RCSfile$
+++ /dev/null
-#include <cpPlugins/Plugins/SecondRankDiffusionTensorToPolyData.h>
-#include <cpPlugins/Interface/Image.h>
-#include <cpPlugins/Interface/Mesh.h>
-
-#include <cpExtensions/Algorithms/SecondRankDiffusionTensorToPolyData.h>
-#include <itkSymmetricSecondRankTensor.h>
-
-// -------------------------------------------------------------------------
-cpPlugins::Plugins::SecondRankDiffusionTensorToPolyData::
-SecondRankDiffusionTensorToPolyData( )
- : Superclass( ),
- m_Algorithm( NULL )
-{
- this->m_ClassName = "cpPlugins::SecondRankDiffusionTensorToPolyData";
- this->m_ClassCategory = "ImageToMeshFilter";
-
- this->SetNumberOfInputs( 1 );
- this->SetNumberOfOutputs( 1 );
- this->_MakeOutput< cpPlugins::Interface::Mesh >( 0 );
-
- using namespace cpPlugins::Interface;
- this->m_Parameters = this->m_DefaultParameters;
-}
-
-// -------------------------------------------------------------------------
-cpPlugins::Plugins::SecondRankDiffusionTensorToPolyData::
-~SecondRankDiffusionTensorToPolyData( )
-{
- if( this->m_Algorithm != NULL )
- this->m_Algorithm->Delete( );
-}
-
-// -------------------------------------------------------------------------
-std::string cpPlugins::Plugins::SecondRankDiffusionTensorToPolyData::
-_GenerateData( )
-{
- // Get input
- cpPlugins::Interface::Image* image =
- this->GetInput< cpPlugins::Interface::Image >( 0 );
- if( image == NULL )
- return( "SecondRankDiffusionTensorToPolyData: Input data is not a valid image." );
-
- itk::DataObject* itk_image = NULL;
- std::string r = "";
- cpPlugins_ImageArray_Input_Demangle( itk::SymmetricSecondRankTensor, float, 3, 3, image, itk_image, r, _RealGD );
- else cpPlugins_ImageArray_Input_Demangle( itk::SymmetricSecondRankTensor, double, 3, 3, image, itk_image, r, _RealGD );
- else
- r = "SecondRankDiffusionTensorToPolyData: Input does not have a DiffusionTensor3D.";
- return( r );
-}
-
-// -------------------------------------------------------------------------
-template< class I >
-std::string cpPlugins::Plugins::SecondRankDiffusionTensorToPolyData::
-_RealGD( itk::DataObject* image )
-{
- typedef cpExtensions::Algorithms::SecondRankDiffusionTensorToPolyData< I > _F;
-
- // Configure filter
- _F* f = NULL;
- if( this->m_Algorithm == NULL )
- {
- f = _F::New( );
- this->m_Algorithm = f;
-
- } // fi
- f->SetInputData( dynamic_cast< I* >( image ) );
- this->m_Algorithm->Update( );
-
- // Connect output
- cpPlugins::Interface::Mesh* out =
- this->GetOutput< cpPlugins::Interface::Mesh >( 0 );
- if( out != NULL )
- {
- out->SetVTKMesh( this->m_Algorithm->GetOutput( ) );
- return( "" );
- }
- else
- return( "OtsuThresholdImageFilter: output not correctly created." );
-}
-
-// eof - $RCSfile$
+++ /dev/null
-#ifndef __CPPLUGINS__PLUGINS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-#define __CPPLUGINS__PLUGINS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
-#include <cpPlugins/Interface/BaseProcessObjects.h>
-
-class vtkPolyDataAlgorithm;
-
-namespace cpPlugins
-{
- namespace Plugins
- {
- /**
- */
- class cpPlugins_EXPORT SecondRankDiffusionTensorToPolyData
- : public cpPlugins::Interface::ImageToMeshFilter
- {
- public:
- typedef SecondRankDiffusionTensorToPolyData Self;
- typedef cpPlugins::Interface::ImageToMeshFilter Superclass;
- typedef itk::SmartPointer< Self > Pointer;
- typedef itk::SmartPointer< const Self > ConstPointer;
-
- public:
- itkNewMacro( Self );
- itkTypeMacro( SecondRankDiffusionTensorToPolyData, cpPluginsInterfaceImageToMeshFilter );
-
- protected:
- SecondRankDiffusionTensorToPolyData( );
- virtual ~SecondRankDiffusionTensorToPolyData( );
-
- virtual std::string _GenerateData( );
-
- template< class I >
- inline std::string _RealGD( itk::DataObject* image );
-
- private:
- // Purposely not implemented
- SecondRankDiffusionTensorToPolyData( const Self& );
- Self& operator=( const Self& );
-
- protected:
- vtkPolyDataAlgorithm* m_Algorithm;
- };
-
- // ---------------------------------------------------------------------
- CPPLUGINS_INHERIT_PROVIDER( SecondRankDiffusionTensorToPolyData );
-
- } // ecapseman
-
-} // ecapseman
-
-#endif // __CPPLUGINS__PLUGINS__SECONDRANKDIFFUSIONTENSORTOPOLYDATA__H__
-
-// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff