-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-# for CMake 2.6 corrected behaviour (see "cmake --help-policy CMP0003")
-IF(
- COMMAND cmake_policy AND
- ${CMAKE_MAJOR_VERSION} EQUAL 2 AND
- ${CMAKE_MINOR_VERSION} GREATER 4
- )
- CMAKE_POLICY(SET CMP0003 NEW)
- CMAKE_POLICY(SET CMP0005 NEW)
- CMAKE_POLICY(SET CMP0011 NEW)
- CMAKE_POLICY(SET CMP0012 NEW)
-ENDIF(
- COMMAND cmake_policy AND
- ${CMAKE_MAJOR_VERSION} EQUAL 2 AND
- ${CMAKE_MINOR_VERSION} GREATER 4
- )
+IF(POLICY CMP0020)
+ CMAKE_POLICY(SET CMP0020 NEW)
+ENDIF(POLICY CMP0020)
## ================
## = Project name =
INCLUDE(GenerateExportHeader)
-## -------------------------------------------------------------------------
-## If compiling on UNIX-like OS, an error could arise when using ITKVtkGlue:
-##
-## <command-line>:0:0: warning: "vtkRenderingCore_AUTOINIT" redefined
-## <command-line>:0:0: note: this is the location of the previous definition
-##
-## This is avoided by not including the VTK_USE_FILE. Nevertheless, this fails
-## on MS-Win OS.
-##
-## This is due to object factories. To avoid this, and let the project be
-## usable on UNIX-like and MS-Win, the way to find ITK and VTK differs
-## -------------------------------------------------------------------------
-
-IF(UNIX)
- FIND_PACKAGE(ITK REQUIRED)
- FIND_PACKAGE(VTK REQUIRED)
- INCLUDE(${ITK_USE_FILE})
- IF(NOT ITKVtkGlue_LOADED)
- MESSAGE(FATAL_ERROR "ITKVtkGlue module is required but not available.")
- ENDIF(NOT ITKVtkGlue_LOADED)
-ELSE(UNIX)
- FIND_PACKAGE(ITK REQUIRED)
- INCLUDE(${ITK_USE_FILE})
- IF(ITKVtkGlue_LOADED)
- FIND_PACKAGE(VTK REQUIRED)
- INCLUDE(${VTK_USE_FILE})
- ELSE(ITKVtkGlue_LOADED)
- FIND_PACKAGE(ItkVtkGlue REQUIRED)
- INCLUDE(${ItkVtkGlue_USE_FILE})
- SET(Glue ItkVtkGlue)
- ENDIF(ITKVtkGlue_LOADED)
-ENDIF(UNIX)
+FIND_PACKAGE(ITK REQUIRED)
+INCLUDE(${ITK_USE_FILE})
+
+FIND_PACKAGE(VTK REQUIRED)
+INCLUDE(${VTK_USE_FILE})
+
+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)
FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/lib
${PROJECT_SOURCE_DIR}/lib/third_party
+ ${PROJECT_SOURCE_DIR}/lib/third_party/ItkVtkGlue
${PROJECT_BINARY_DIR}/lib
${PROJECT_BINARY_DIR}/lib/third_party
+ ${PROJECT_BINARY_DIR}/lib/third_party/ItkVtkGlue
)
IF(WIN32)
INCLUDE_DIRECTORIES(
example_RenderQuadEdgeMeshWithoutPlugins
example_ParallelImageMean
example_LightCompensation
+ example_1DImageGradient
+ example_2DImageGradient
+ example_3DImageGradient
+ example_2DGulsunTekMedialness
+ example_3DGulsunTekMedialness
)
FOREACH(prog ${NOPLUGINS_EXAMPLES_PROGRAMS})
ADD_EXECUTABLE(
TARGET_LINK_LIBRARIES(
${prog}
${ITK_LIBRARIES}
+ cpPlugins_Extensions
)
ENDFOREACH(prog)
--- /dev/null
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkImageFileWriter.h>
+#include <itkSimpleFilterWatcher.h>
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.h>
+
+// -------------------------------------------------------------------------
+typedef short TPixel;
+typedef float TScalar;
+const unsigned int Dimension = 2;
+
+typedef itk::CovariantVector< TScalar, Dimension > TVector;
+typedef itk::Image< TPixel, Dimension > TImage;
+typedef itk::Image< TVector, Dimension > TGradient;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ if( argc < 4 )
+ {
+ std::cout
+ << "Usage: " << argv[ 0 ]
+ << " input_image output_gradient s0 s1 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::string image_fn = argv[ 1 ];
+ std::string gradient_fn = argv[ 2 ];
+
+ // Read image
+ itk::ImageFileReader< TImage >::Pointer image_reader =
+ itk::ImageFileReader< TImage >::New( );
+ image_reader->SetFileName( image_fn );
+ try
+ {
+ image_reader->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ // Prepare filter
+ typedef cpPlugins::Extensions::Algorithms::
+ MultiScaleGaussianImageFilter< TImage, TGradient > TFilter;
+
+ TFilter::Pointer filter = TFilter::New( );
+ filter->SetFilterToGradient( );
+ filter->SetInput( image_reader->GetOutput( ) );
+ for( int i = 3; i < argc; ++i )
+ filter->AddScale( std::atof( argv[ i ] ) );
+
+ // Execute filter
+ itk::SimpleFilterWatcher filter_watcher( filter, "Gradient" );
+ filter->Update( );
+
+ // Read image
+ itk::ImageFileWriter< TGradient >::Pointer gradient_writer =
+ itk::ImageFileWriter< TGradient >::New( );
+ gradient_writer->SetInput( filter->GetOutput( ) );
+ gradient_writer->SetFileName( gradient_fn );
+ try
+ {
+ gradient_writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkImageFileWriter.h>
+#include <itkSimpleFilterWatcher.h>
+#include <itkVector.h>
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.h>
+#include <cpPlugins/Extensions/Algorithms/GulsunTekMedialness.h>
+#include <cpPlugins/Extensions/Algorithms/ImageFunctionFilter.h>
+
+#include <cpPlugins/Extensions/Algorithms/InertiaTensorFunction.h>
+
+#include <itkImageToVTKImageFilter.h>
+
+#include <vtkAxesActor.h>
+#include <vtkMatrix4x4.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkSmartPointer.h>
+#include <cpPlugins/Extensions/Visualization/MPRWithDifferentWindows.h>
+
+#include <cpPlugins/Extensions/Algorithms/InertiaMedialness.h>
+
+
+// -------------------------------------------------------------------------
+typedef short TPixel;
+typedef float TScalar;
+const unsigned int Dimension = 2;
+
+typedef itk::Vector< TScalar, Dimension > TVector;
+typedef itk::Image< TPixel, Dimension > TImage;
+typedef itk::Image< TVector, Dimension > TGradient;
+typedef itk::Image< TScalar, Dimension > TScalarImage;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ if( argc < 8 )
+ {
+ std::cout
+ << "Usage: " << argv[ 0 ]
+ << " input_image output_medialness"
+ << " min_radius max_radius profile_sampling radial_sampling"
+ << " s0 s1 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::string image_fn = argv[ 1 ];
+ std::string medialness_fn = argv[ 2 ];
+ double min_radius = std::atof( argv[ 3 ] );
+ double max_radius = std::atof( argv[ 4 ] );
+ unsigned int profile_sampling = std::atoi( argv[ 5 ] );
+ unsigned int radial_sampling = std::atoi( argv[ 6 ] );
+
+ // Read image
+ itk::ImageFileReader< TImage >::Pointer image_reader =
+ itk::ImageFileReader< TImage >::New( );
+ image_reader->SetFileName( image_fn );
+ try
+ {
+ image_reader->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ // Inertia tensor
+ /* TODO
+ typedef cpPlugins::Extensions::Algorithms::
+ InertiaTensorFunction< TScalar, Dimension >
+ TInertiaFunction;
+ TInertiaFunction::Pointer inertia = TInertiaFunction::New( );
+
+ itk::ImageRegionConstIteratorWithIndex< TImage > it(
+ image_reader->GetOutput( ),
+ image_reader->GetOutput( )->GetRequestedRegion( )
+ );
+ for( it.GoToBegin( ); !it.IsAtEnd( ); ++it )
+ {
+ TInertiaFunction::TPoint pnt;
+ image_reader->GetOutput( )->
+ TransformIndexToPhysicalPoint( it.GetIndex( ), pnt );
+ inertia->AddMass( pnt, TScalar( it.Get( ) ) );
+
+ } // rof
+
+ TInertiaFunction::TMatrix I = inertia->GetInertia( );
+ TInertiaFunction::TVector m = inertia->GetCenterOfGravity( );
+
+ TInertiaFunction::TVector pv;
+ TInertiaFunction::TVector r;
+ TInertiaFunction::TMatrix pm;
+ inertia->GetEigenAnalysis( pm, pv, r );
+
+ vtkSmartPointer< vtkMatrix4x4 > matrix =
+ vtkSmartPointer< vtkMatrix4x4 >::New( );
+ matrix->Identity( );
+ matrix->SetElement( 0, 0, pm[ 0 ][ 0 ] * r[ 0 ] );
+ matrix->SetElement( 0, 1, pm[ 0 ][ 1 ] * r[ 1 ] );
+ matrix->SetElement( 1, 0, pm[ 1 ][ 0 ] * r[ 0 ] );
+ matrix->SetElement( 1, 1, pm[ 1 ][ 1 ] * r[ 1 ] );
+ matrix->SetElement( 0, 3, m[ 0 ] );
+ matrix->SetElement( 1, 3, m[ 1 ] );
+
+ vtkSmartPointer< vtkAxesActor > axes =
+ vtkSmartPointer< vtkAxesActor >::New( );
+ axes->SetUserMatrix( matrix );
+
+ std::cout << "---------------------------------" << std::endl;
+ std::cout << I << std::endl;
+ std::cout << m << std::endl;
+ std::cout << "---------------------------------" << std::endl;
+ std::cout << pm << std::endl;
+ std::cout << pv << std::endl;
+ std::cout << "---------------------------------" << std::endl;
+
+ typedef itk::ImageToVTKImageFilter< TImage > TVTKImage;
+ TVTKImage::Pointer vtk_input_image = TVTKImage::New( );
+ vtk_input_image->SetInput( image_reader->GetOutput( ) );
+ vtk_input_image->Update( );
+
+ // Visualization window and interactor
+ vtkSmartPointer< vtkRenderWindowInteractor > interactor =
+ vtkSmartPointer< vtkRenderWindowInteractor >::New( );
+ vtkSmartPointer< vtkRenderWindow > window =
+ vtkSmartPointer< vtkRenderWindow >::New( );
+ window->SetSize( 500, 500 );
+ window->SetInteractor( interactor );
+
+ // Viewer
+ cpPlugins::Extensions::Visualization::MPRWithDifferentWindows
+ view( NULL, NULL, window, NULL );
+ view.SetImage( vtk_input_image->GetOutput( ) );
+ view.GetRenderer( 2 )->AddActor( axes );
+ view.ResetCamera( 2 );
+ view.Render( 2 );
+
+ // Start
+ interactor->Initialize( );
+ interactor->Start( );
+
+ */
+
+ /*
+ // Prepare filter
+ typedef cpPlugins::Extensions::Algorithms::
+ MultiScaleGaussianImageFilter< TImage, TGradient > TGradientFilter;
+
+ TGradientFilter::Pointer gradientFilter = TGradientFilter::New( );
+ gradientFilter->SetFilterToGradient( );
+ gradientFilter->SetInput( image_reader->GetOutput( ) );
+ for( int i = 7; i < argc; ++i )
+ gradientFilter->AddScale( std::atof( argv[ i ] ) );
+
+ // Execute filter
+ itk::SimpleFilterWatcher gradientFilter_watcher( gradientFilter, "Gradient" );
+ gradientFilter->Update( );
+ */
+
+ // Prepare medialness function
+ typedef cpPlugins::Extensions::Algorithms::
+ InertiaMedialness< TImage, TScalar > TMedialness;
+ TMedialness::Pointer medialness = TMedialness::New( );
+ medialness->SetInputImage( image_reader->GetOutput( ) );
+ medialness->SetMaxRadius( max_radius );
+ /*
+ medialness->SetMinRadius( min_radius );
+ medialness->SetProfileSampling( profile_sampling );
+ medialness->SetRadialSampling( radial_sampling );
+
+ TGradient::IndexType idx;
+ idx[ 0 ] = 288;
+ idx[ 1 ] = 690;
+
+ std::cout << "Medialness = " << medialness->EvaluateAtIndex( idx ) << std::endl;
+ // return( 0 );
+ */
+
+ // Prepare output filter
+ typedef cpPlugins::Extensions::Algorithms::
+ ImageFunctionFilter< TImage, TScalarImage, TMedialness >
+ TFunctionApplier;
+ TFunctionApplier::Pointer medialnessFilter = TFunctionApplier::New( );
+ medialnessFilter->SetInput( image_reader->GetOutput( ) );
+ medialnessFilter->SetFunction( medialness );
+
+ // Execute filter
+ itk::SimpleFilterWatcher medialnessFilter_watcher(
+ medialnessFilter, "Medialness"
+ );
+ medialnessFilter->Update( );
+
+ // Write image
+ itk::ImageFileWriter< TScalarImage >::Pointer medialness_writer =
+ itk::ImageFileWriter< TScalarImage >::New( );
+ medialness_writer->SetInput( medialnessFilter->GetOutput( ) );
+ medialness_writer->SetFileName( medialness_fn );
+ try
+ {
+ medialness_writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkImageFileWriter.h>
+#include <itkSimpleFilterWatcher.h>
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.h>
+
+// -------------------------------------------------------------------------
+typedef short TPixel;
+typedef float TScalar;
+const unsigned int Dimension = 2;
+
+typedef itk::CovariantVector< TScalar, Dimension > TVector;
+typedef itk::Image< TPixel, Dimension > TImage;
+typedef itk::Image< TVector, Dimension > TGradient;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ if( argc < 4 )
+ {
+ std::cout
+ << "Usage: " << argv[ 0 ]
+ << " input_image output_gradient s0 s1 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::string image_fn = argv[ 1 ];
+ std::string gradient_fn = argv[ 2 ];
+
+ // Read image
+ itk::ImageFileReader< TImage >::Pointer image_reader =
+ itk::ImageFileReader< TImage >::New( );
+ image_reader->SetFileName( image_fn );
+ try
+ {
+ image_reader->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ // Prepare filter
+ typedef cpPlugins::Extensions::Algorithms::
+ MultiScaleGaussianImageFilter< TImage, TGradient > TFilter;
+
+ TFilter::Pointer filter = TFilter::New( );
+ filter->SetFilterToGradient( );
+ filter->SetInput( image_reader->GetOutput( ) );
+ for( int i = 3; i < argc; ++i )
+ filter->AddScale( std::atof( argv[ i ] ) );
+
+ // Execute filter
+ itk::SimpleFilterWatcher filter_watcher( filter, "Gradient" );
+ filter->Update( );
+
+ // Write image
+ itk::ImageFileWriter< TGradient >::Pointer gradient_writer =
+ itk::ImageFileWriter< TGradient >::New( );
+ gradient_writer->SetInput( filter->GetOutput( ) );
+ gradient_writer->SetFileName( gradient_fn );
+ try
+ {
+ gradient_writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkImageFileWriter.h>
+#include <itkSimpleFilterWatcher.h>
+#include <itkVector.h>
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.h>
+#include <cpPlugins/Extensions/Algorithms/GulsunTekMedialness.h>
+#include <cpPlugins/Extensions/Algorithms/ImageFunctionFilter.h>
+
+// -------------------------------------------------------------------------
+typedef short TPixel;
+typedef float TScalar;
+const unsigned int Dimension = 3;
+
+typedef itk::Vector< TScalar, Dimension > TVector;
+typedef itk::Image< TPixel, Dimension > TImage;
+typedef itk::Image< TVector, Dimension > TGradient;
+typedef itk::Image< TScalar, Dimension > TScalarImage;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ if( argc < 8 )
+ {
+ std::cout
+ << "Usage: " << argv[ 0 ]
+ << " input_image output_medialness"
+ << " min_radius max_radius profile_sampling radial_sampling"
+ << " s0 s1 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::string image_fn = argv[ 1 ];
+ std::string medialness_fn = argv[ 2 ];
+ double min_radius = std::atof( argv[ 3 ] );
+ double max_radius = std::atof( argv[ 4 ] );
+ unsigned int profile_sampling = std::atoi( argv[ 5 ] );
+ unsigned int radial_sampling = std::atoi( argv[ 6 ] );
+
+ // Read image
+ itk::ImageFileReader< TImage >::Pointer image_reader =
+ itk::ImageFileReader< TImage >::New( );
+ image_reader->SetFileName( image_fn );
+ try
+ {
+ image_reader->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ // Prepare filter
+ typedef cpPlugins::Extensions::Algorithms::
+ MultiScaleGaussianImageFilter< TImage, TGradient > TGradientFilter;
+
+ TGradientFilter::Pointer gradientFilter = TGradientFilter::New( );
+ gradientFilter->SetFilterToGradient( );
+ gradientFilter->SetInput( image_reader->GetOutput( ) );
+ for( int i = 7; i < argc; ++i )
+ gradientFilter->AddScale( std::atof( argv[ i ] ) );
+
+ // Execute filter
+ itk::SimpleFilterWatcher gradientFilter_watcher( gradientFilter, "Gradient" );
+ gradientFilter->Update( );
+
+ // Prepare medialness function
+ typedef cpPlugins::Extensions::Algorithms::
+ GulsunTekMedialness< TGradient > TMedialness;
+ TMedialness::Pointer medialness = TMedialness::New( );
+ medialness->SetInputImage( gradientFilter->GetOutput( ) );
+ medialness->SetMinRadius( min_radius );
+ medialness->SetMaxRadius( max_radius );
+ medialness->SetProfileSampling( profile_sampling );
+ medialness->SetRadialSampling( radial_sampling );
+
+ // Prepare output filter
+ typedef cpPlugins::Extensions::Algorithms::
+ ImageFunctionFilter< TGradient, TScalarImage, TMedialness >
+ TFunctionApplier;
+ TFunctionApplier::Pointer medialnessFilter = TFunctionApplier::New( );
+ medialnessFilter->SetInput( gradientFilter->GetOutput( ) );
+ medialnessFilter->SetFunction( medialness );
+
+ // Execute filter
+ itk::SimpleFilterWatcher medialnessFilter_watcher(
+ medialnessFilter, "Medialness"
+ );
+ medialnessFilter->Update( );
+
+ // Write image
+ itk::ImageFileWriter< TScalarImage >::Pointer medialness_writer =
+ itk::ImageFileWriter< TScalarImage >::New( );
+ medialness_writer->SetInput( medialnessFilter->GetOutput( ) );
+ medialness_writer->SetFileName( medialness_fn );
+ try
+ {
+ medialness_writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#include <itkImage.h>
+#include <itkImageFileReader.h>
+#include <itkImageFileWriter.h>
+#include <itkSimpleFilterWatcher.h>
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.h>
+
+// -------------------------------------------------------------------------
+typedef short TPixel;
+typedef float TScalar;
+const unsigned int Dimension = 3;
+
+typedef itk::CovariantVector< TScalar, Dimension > TVector;
+typedef itk::Image< TPixel, Dimension > TImage;
+typedef itk::Image< TVector, Dimension > TGradient;
+
+// -------------------------------------------------------------------------
+int main( int argc, char* argv[] )
+{
+ if( argc < 4 )
+ {
+ std::cout
+ << "Usage: " << argv[ 0 ]
+ << " input_image output_gradient s0 s1 ..."
+ << std::endl;
+ return( 1 );
+
+ } // fi
+ std::string image_fn = argv[ 1 ];
+ std::string gradient_fn = argv[ 2 ];
+
+ // Read image
+ itk::ImageFileReader< TImage >::Pointer image_reader =
+ itk::ImageFileReader< TImage >::New( );
+ image_reader->SetFileName( image_fn );
+ try
+ {
+ image_reader->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ // Prepare filter
+ typedef cpPlugins::Extensions::Algorithms::
+ MultiScaleGaussianImageFilter< TImage, TGradient > TFilter;
+
+ TFilter::Pointer filter = TFilter::New( );
+ filter->SetFilterToGradient( );
+ filter->SetInput( image_reader->GetOutput( ) );
+ for( int i = 3; i < argc; ++i )
+ filter->AddScale( std::atof( argv[ i ] ) );
+
+ // Execute filter
+ itk::SimpleFilterWatcher filter_watcher( filter, "Gradient" );
+ filter->Update( );
+
+ // Write image
+ itk::ImageFileWriter< TGradient >::Pointer gradient_writer =
+ itk::ImageFileWriter< TGradient >::New( );
+ gradient_writer->SetInput( filter->GetOutput( ) );
+ gradient_writer->SetFileName( gradient_fn );
+ try
+ {
+ gradient_writer->Update( );
+ }
+ catch( itk::ExceptionObject& err )
+ {
+ std::cerr << err << std::endl;
+ return( 1 );
+
+ } // yrt
+
+ return( 0 );
+}
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+
+#include <map>
+#include <itkImageFunction.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class G >
+ class GradientFunctionBase
+ : public itk::ImageFunction< G, typename G::PixelType::ValueType, typename G::PixelType::ValueType >
+ {
+ public:
+ // Types from input arguments
+ typedef G TGradient;
+ typedef typename G::PixelType TVector;
+ typedef typename TVector::ValueType TScalar;
+ itkStaticConstMacro( Dimension, unsigned int, G::ImageDimension );
+
+ // Standard itk types
+ typedef GradientFunctionBase Self;
+ typedef itk::ImageFunction< G, TScalar, TScalar > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Types from base itk::ImageFunction
+ typedef typename Superclass::InputType TInput;
+ typedef typename Superclass::OutputType TOutput;
+ typedef typename Superclass::PointType TPoint;
+ typedef typename Superclass::ContinuousIndexType TContIndex;
+ typedef typename Superclass::IndexType TIndex;
+
+ // Sparse buffer
+ typedef std::map< TIndex, TOutput, typename TIndex::LexicographicCompare > TBuffer;
+
+ public:
+ itkTypeMacro( GradientFunctionBase, itkImageFunction );
+
+ itkBooleanMacro( BufferResults );
+ itkGetConstMacro( BufferResults, bool );
+ itkSetMacro( BufferResults, bool );
+
+ public:
+ virtual void ResetBuffer( );
+
+ virtual TOutput Evaluate( const TPoint& p ) const;
+ virtual TOutput EvaluateAtIndex( const TIndex& i ) const;
+ virtual TOutput EvaluateAtContinuousIndex( const TContIndex& i ) const;
+
+ protected:
+ GradientFunctionBase( );
+ virtual ~GradientFunctionBase( );
+
+ virtual TOutput _Evaluate( const TIndex& i ) const = 0;
+
+ private:
+ // Purposely not implemented.
+ GradientFunctionBase( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ mutable TBuffer m_Buffer;
+ bool m_BufferResults;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#include <cpPlugins/Extensions/Algorithms/GradientFunctionBase.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+
+// -------------------------------------------------------------------------
+template< class G >
+void cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+ResetBuffer( )
+{
+ this->m_Buffer.clear( );
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+Evaluate( const TPoint& p ) const
+{
+ TIndex i;
+ this->GetInputImage( )->TransformPhysicalPointToIndex( p, i );
+ return( this->EvaluateAtIndex( i ) );
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+EvaluateAtIndex( const TIndex& i ) const
+{
+ TOutput res = TOutput( 0 );
+ bool computed = false;
+ if( this->m_BufferResults )
+ {
+ typename TBuffer::const_iterator bIt = this->m_Buffer.find( i );
+ computed = ( bIt != this->m_Buffer.end( ) );
+ res = ( computed )? bIt->second: res;
+
+ } // fi
+
+ if( !computed )
+ res = this->_Evaluate( i );
+
+ if( this->m_BufferResults )
+ this->m_Buffer[ i ] = res;
+ return( res );
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+EvaluateAtContinuousIndex( const TContIndex& i ) const
+{
+ TPoint p;
+ this->GetInputImage( )->TransformContinuousIndexToPhysicalPoint( i, p );
+ return( this->Evaluate( p ) );
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+GradientFunctionBase( )
+ : Superclass( ),
+ m_BufferResults( false )
+{
+ this->m_Buffer.clear( );
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+~GradientFunctionBase( )
+{
+ this->m_Buffer.clear( );
+}
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+
+#include <vector>
+#include <cpPlugins/Extensions/Algorithms/GradientFunctionBase.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class G >
+ class GulsunTekMedialness
+ : public GradientFunctionBase< G >
+ {
+ public:
+ // Standard itk types
+ typedef GulsunTekMedialness Self;
+ typedef GradientFunctionBase< G > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Types from superclass
+ typedef typename Superclass::TGradient TGradient;
+ typedef typename Superclass::TVector TVector;
+ typedef typename Superclass::TScalar TScalar;
+ typedef typename Superclass::TInput TInput;
+ typedef typename Superclass::TOutput TOutput;
+ typedef typename Superclass::TPoint TPoint;
+ typedef typename Superclass::TContIndex TContIndex;
+ typedef typename Superclass::TIndex TIndex;
+ typedef typename Superclass::TBuffer TBuffer;
+
+ typedef typename TIndex::OffsetType TOffset;
+ typedef std::vector< double > TProfile;
+ typedef std::vector< TOffset > TOffsets;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( GulsunTekMedialness, GradientFunctionBase );
+
+ itkGetConstMacro( MinRadius, double );
+ itkGetConstMacro( MaxRadius, double );
+ itkGetConstMacro( ProfileSampling, unsigned int );
+ itkGetConstMacro( RadialSampling, unsigned int );
+
+ itkSetMacro( MinRadius, double );
+ itkSetMacro( MaxRadius, double );
+ itkSetMacro( ProfileSampling, unsigned int );
+ itkSetMacro( RadialSampling, unsigned int );
+
+ protected:
+ GulsunTekMedialness( );
+ virtual ~GulsunTekMedialness( );
+
+ virtual TOutput _Evaluate( const TIndex& i ) const;
+
+ private:
+ // Purposely not implemented.
+ GulsunTekMedialness( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ double m_MinRadius;
+ double m_MaxRadius;
+ unsigned int m_ProfileSampling;
+ unsigned int m_RadialSampling;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#include <cpPlugins/Extensions/Algorithms/GulsunTekMedialness.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+
+#include <cmath>
+#include <vnl/vnl_math.h>
+
+
+#include <queue>
+#include <map>
+#include <set>
+
+
+
+
+// -------------------------------------------------------------------------
+template< class G >
+cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+GulsunTekMedialness( )
+ : Superclass( ),
+ m_MinRadius( double( 0 ) ),
+ m_MaxRadius( double( 1 ) ),
+ m_ProfileSampling( 4 ),
+ m_RadialSampling( 10 )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+~GulsunTekMedialness( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class G >
+typename cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+TOutput cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+_Evaluate( const TIndex& i ) const
+{
+ const G* gradient = this->GetInputImage( );
+ typename G::RegionType region = gradient->GetRequestedRegion( );
+ typename G::PointType i_P;
+ gradient->TransformIndexToPhysicalPoint( i, i_P );
+
+ std::queue< TIndex > q;
+ std::set< TIndex, typename TIndex::LexicographicCompare > m;
+ std::map< TOffset, std::vector< TIndex >, typename TOffset::LexicographicCompare > profiles;
+ q.push( i );
+
+ while( !q.empty( ) )
+ {
+ // Get next node
+ TIndex node = q.front( );
+ q.pop( );
+ if( m.find( node ) != m.end( ) )
+ continue;
+ m.insert( node );
+
+ // Get neighborhood
+ for( unsigned int d = 0; d < Self::Dimension; d++ )
+ {
+ for( int off = -1; off <= 1; off += 2 )
+ {
+ TIndex neighbor = node;
+ neighbor[ d ] += off;
+ if( region.IsInside( neighbor ) )
+ {
+ typename G::PointType neighbor_P;
+ gradient->TransformIndexToPhysicalPoint( neighbor, neighbor_P );
+ if( double( i_P.EuclideanDistanceTo( neighbor_P ) ) > this->m_MaxRadius )
+ continue;
+
+ // Normalize offset in terms of a l1 (manhattan) distance
+ TOffset offset = neighbor - i;
+ // std::cout << "Offset: " << offset << std::endl;
+
+ /*
+ int max_off = 0;
+ for( unsigned int o = 0; o < Self::Dimension; ++o )
+ max_off += std::abs( offset[ o ] );
+ if( max_off == 0 )
+ continue;
+ bool normalized = true;
+ TOffset normalized_offset;
+ for( unsigned int o = 0; o < Self::Dimension && normalized; ++o )
+ {
+ if( offset[ o ] % max_off == 0 )
+ normalized_offset[ o ] = offset[ o ] / max_off;
+ else
+ normalized = false;
+
+ } // rof
+ if( !normalized )
+ normalized_offset = offset;
+ std::cout << "offset: " << normalized_offset << std::endl;
+
+ // Update profiles
+ profiles[ normalized_offset ].push_back( neighbor );
+ */
+
+ // Update queue
+ q.push( neighbor );
+
+ } // fi
+
+ } // rof
+
+ } // rof
+
+ } // elihw
+ // std::cout << "HOLA: " << profiles.size( ) << std::endl;
+
+
+ return( TOutput( 0 ) );
+ /* TODO
+ const G* in = this->GetInputImage( );
+ double pi2n =
+ double( 2 ) * double( vnl_math::pi ) /
+ double( this->m_ProfileSampling );
+ double rOff = this->m_MaxRadius / double( this->m_RadialSampling - 1 );
+ double optR = double( 0 );
+ TPoint pnt;
+ in->TransformIndexToPhysicalPoint( i, pnt );
+
+ // Main loop
+ for( unsigned int cx = 0; cx < Self::Dimension - 1; cx++ )
+ {
+ for( unsigned int cy = cx + 1; cy < Self::Dimension; cy++ )
+ {
+ TProfile maxProfile( this->m_RadialSampling, double( 0 ) );
+ for( unsigned int p = 0; p < this->m_ProfileSampling; p++ )
+ {
+ double a = pi2n * double( p );
+
+ // Direction of this profile
+ TVector dir;
+ dir.Fill( TScalar( 0 ) );
+ dir[ cx ] = TScalar( std::cos( a ) );
+ dir[ cy ] = TScalar( std::sin( a ) );
+
+ double maxrise = double( 0 );
+ double maxfall = double( -1 );
+ TProfile profile;
+ for( unsigned int r = 0; r < this->m_RadialSampling; r++ )
+ {
+ double radius = double( r ) * rOff;
+ TIndex idx;
+ if(
+ in->TransformPhysicalPointToIndex( pnt + ( dir * radius ), idx )
+ )
+ {
+ TVector g = in->GetPixel( idx );
+ double b = double( g.GetNorm( ) );
+ if( double( g * dir ) < double( 0 ) )
+ b *= double( -1 );
+ maxrise = ( b > maxrise )? b: maxrise;
+ if( radius >= this->m_MinRadius )
+ maxfall = ( b < maxfall )? b: maxfall;
+ profile.push_back( -b - maxrise );
+ }
+ else
+ profile.push_back( double( 0 ) );
+
+ } // rof
+
+ for( unsigned int r = 0; r < this->m_RadialSampling; r++ )
+ {
+ double E = profile[ r ] / -maxfall;
+ E = ( E < double( 0 ) )? double( 0 ): E;
+ E = ( E > double( 1 ) )? double( 1 ): E;
+ maxProfile[ r ] += E;
+
+ } // rof
+
+ } // rof
+
+ for( unsigned int r = 0; r < this->m_RadialSampling; r++ )
+ {
+ double E = maxProfile[ r ] / double( this->m_RadialSampling );
+ optR = ( E > optR )? E: optR;
+
+ } // rof
+
+ } // rof
+
+ } // rof
+ return( TScalar( optR ) );
+ */
+}
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+
+#include <itkImageToImageFilter.h>
+#include <itkImageScanlineConstIterator.h>
+#include <itkImageScanlineIterator.h>
+#include <itkProgressReporter.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class I, class O, class F >
+ class ImageFunctionFilter
+ : public itk::ImageToImageFilter< I, O >
+ {
+ public:
+ typedef ImageFunctionFilter Self;
+ typedef itk::ImageToImageFilter< I, O > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef I TInputImage;
+ typedef O TOutputImage;
+ typedef F TFunction;
+
+ typedef typename O::RegionType TRegion;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( ImageFunctionFilter, itkImageToImageFilter );
+
+ itkGetObjectMacro( Function, F );
+ itkSetObjectMacro( Function, F );
+
+ protected:
+ ImageFunctionFilter( )
+ : Superclass( )
+ {
+ }
+ virtual ~ImageFunctionFilter( )
+ {
+ }
+
+ virtual void ThreadedGenerateData(
+ const TRegion& region,
+ itk::ThreadIdType threadId
+ )
+ {
+ const typename TRegion::SizeType& regionSize = region.GetSize( );
+ if( regionSize[ 0 ] == 0 )
+ return;
+ const I* in = this->GetInput( );
+ O* out = this->GetOutput( 0 );
+
+ const size_t nLines = region.GetNumberOfPixels( ) / regionSize[ 0 ];
+ itk::ProgressReporter progress( this, threadId, nLines );
+
+ // Define the iterators
+ itk::ImageScanlineConstIterator< I > inIt( in, region );
+ itk::ImageScanlineIterator< O > outIt( out, region );
+
+ inIt.GoToBegin( );
+ outIt.GoToBegin( );
+ while( !inIt.IsAtEnd( ) )
+ {
+ while( !inIt.IsAtEndOfLine( ) )
+ {
+ outIt.Set( this->m_Function->EvaluateAtIndex( inIt.GetIndex( ) ) );
+ ++inIt;
+ ++outIt;
+
+ } // elihw
+ inIt.NextLine( );
+ outIt.NextLine( );
+ progress.CompletedPixel( );
+
+ } // elihw
+ }
+
+ private:
+ // Purposely not implemented.
+ ImageFunctionFilter( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ typename F::Pointer m_Function;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+// TODO: #include <cpPlugins/Extensions/Algorithms/ImageFunctionFilter.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+
+#include <map>
+#include <itkImageFunction.h>
+
+#include <cpPlugins/Extensions/Algorithms/InertiaTensorFunction.h>
+#include <itkImageRegionConstIteratorWithIndex.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class I, class S = float >
+ class InertiaMedialness
+ : public itk::ImageFunction< I, S, S >
+ {
+ public:
+ // Standard itk types
+ typedef InertiaMedialness Self;
+ typedef itk::ImageFunction< I, S, S > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ // Types from base itk::ImageFunction
+ typedef typename Superclass::InputType TInput;
+ typedef typename Superclass::OutputType TOutput;
+ typedef typename Superclass::PointType TPoint;
+ typedef typename Superclass::ContinuousIndexType TContIndex;
+ typedef typename Superclass::IndexType TIndex;
+ typedef typename TIndex::OffsetType TOffset;
+
+ // Sparse buffer
+ typedef std::map< TIndex, TOutput, typename TIndex::LexicographicCompare > TBuffer;
+
+ typedef InertiaTensorFunction< S, I::ImageDimension > TInertia;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( InertiaMedialness, itkImageFunction );
+
+ itkBooleanMacro( BufferResults );
+ itkGetConstMacro( BufferResults, bool );
+ itkGetConstMacro( MaxRadius, double );
+
+ itkSetMacro( BufferResults, bool );
+ itkSetMacro( MaxRadius, double );
+
+ public:
+ virtual void ResetBuffer( )
+ {
+ this->m_Buffer.clear( );
+ }
+
+ virtual TOutput Evaluate( const TPoint& p ) const
+ {
+ TIndex i;
+ this->GetInputImage( )->TransformPhysicalPointToIndex( p, i );
+ return( this->EvaluateAtIndex( i ) );
+ }
+
+ virtual TOutput EvaluateAtIndex( const TIndex& i ) const
+ {
+ TOutput res = TOutput( 0 );
+ bool computed = false;
+ if( this->m_BufferResults )
+ {
+ typename TBuffer::const_iterator bIt = this->m_Buffer.find( i );
+ computed = ( bIt != this->m_Buffer.end( ) );
+ res = ( computed )? bIt->second: res;
+
+ } // fi
+
+ if( !computed )
+ res = this->_Evaluate( i );
+
+ if( this->m_BufferResults )
+ this->m_Buffer[ i ] = res;
+ return( res );
+ }
+
+ virtual TOutput EvaluateAtContinuousIndex( const TContIndex& i ) const
+ {
+ TPoint p;
+ this->GetInputImage( )->TransformContinuousIndexToPhysicalPoint( i, p );
+ return( this->Evaluate( p ) );
+ }
+
+ protected:
+ InertiaMedialness( )
+ : Superclass( ),
+ m_BufferResults( false ),
+ m_MaxRadius( double( 1 ) )
+ {
+ this->m_Buffer.clear( );
+ }
+
+ virtual ~InertiaMedialness( )
+ {
+ this->m_Buffer.clear( );
+ }
+
+ virtual TOutput _Evaluate( const TIndex& idx ) const
+ {
+ const I* image = this->GetInputImage( );
+
+ typename I::PointType p_i;
+ image->TransformIndexToPhysicalPoint( idx, p_i );
+
+ typename I::PointType max_p, min_p;
+ for( unsigned int d = 0; d < I::ImageDimension; ++d )
+ {
+ max_p[ d ] = p_i[ d ] + this->m_MaxRadius;
+ min_p[ d ] = p_i[ d ] - this->m_MaxRadius;
+
+ } // rof
+ TIndex max_i, min_i;
+ image->TransformPhysicalPointToIndex( max_p, max_i );
+ image->TransformPhysicalPointToIndex( min_p, min_i );
+
+ typename I::RegionType in_region = image->GetRequestedRegion( );
+ TIndex in_index = in_region.GetIndex( );
+ TIndex in_last = in_index + in_region.GetSize( );
+ typename I::SizeType size;
+ for( unsigned int d = 0; d < I::ImageDimension; ++d )
+ {
+ if( min_i[ d ] < in_index[ d ] ) min_i[ d ] = in_index[ d ];
+ if( max_i[ d ] < in_index[ d ] ) max_i[ d ] = in_index[ d ];
+ if( min_i[ d ] >= in_last[ d ] ) min_i[ d ] = in_last[ d ];
+ if( max_i[ d ] >= in_last[ d ] ) max_i[ d ] = in_last[ d ];
+
+ size[ d ] = max_i[ d ] - min_i[ d ];
+
+ } // rof
+
+ typename I::RegionType region;
+ region.SetIndex( min_i );
+ region.SetSize( size );
+
+ std::vector< typename TInertia::Pointer > inertias;
+ itk::ImageRegionConstIteratorWithIndex< I > it( image, region );
+ for( it.GoToBegin( ); !it.IsAtEnd( ); ++it )
+ {
+ TOffset off = it.GetIndex( ) - idx;
+ unsigned long l1dist = std::abs( off[ 0 ] );
+ for( unsigned int d = 1; d < I::ImageDimension; ++d )
+ l1dist = ( std::abs( off[ d ] ) > l1dist )? std::abs( off[ d ] ): l1dist;
+
+ typename TInertia::TPoint i_pnt;
+ image->TransformIndexToPhysicalPoint( it.GetIndex( ), i_pnt );
+
+ for( unsigned long l = 0; l < l1dist; ++l )
+ {
+ if( inertias.size( ) <= l )
+ inertias.push_back( TInertia::New( ) );
+ inertias[ l ]->AddMass( i_pnt.GetVectorFromOrigin( ), S( it.Get( ) ) );
+
+ /* TODO
+ typename TInertias::iterator inIt = inertias.find( l );
+ if( inIt == inertias.end( ) )
+ inIt = inertias.insert( std::pair< unsigned long, typename TInertia::Pointer >( l, TInertia::New( ) ) ).first;
+ */
+
+ } // rof
+
+ } // rof
+
+ if( inertias.size( ) > 0 )
+ {
+ S res = S( 0 );
+ for( unsigned int l = 0; l < inertias.size( ); ++l )
+ {
+ typename TInertia::TVector pv, r;
+ typename TInertia::TMatrix pm;
+ inertias[ l ]->GetEigenAnalysis( pm, pv, r );
+ S v = pv.GetNorm( );
+ if( l == 0 || v > res )
+ res = v;
+
+ } // rof
+ return( res );
+ }
+ else
+ return( TOutput( 0 ) );
+ }
+
+ private:
+ // Purposely not implemented.
+ InertiaMedialness( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ mutable TBuffer m_Buffer;
+ bool m_BufferResults;
+
+ double m_MaxRadius;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+// TODO: #include <cpPlugins/Extensions/Algorithms/InertiaMedialness.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+
+#include <itkObject.h>
+
+#include <itkObject.h>
+#include <itkObjectFactory.h>
+#include <itkMatrix.h>
+#include <itkPoint.h>
+
+
+#include <cmath>
+#include <itkSymmetricEigenAnalysis.h>
+
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class S, unsigned int D >
+ class InertiaTensorFunction
+ : public itk::Object
+ {
+ public:
+ // Standard itk types
+ typedef InertiaTensorFunction Self;
+ typedef itk::Object Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef S TScalar;
+ typedef itk::Matrix< S, D, D > TMatrix;
+ typedef itk::Point< S, D > TPoint;
+ typedef typename TPoint::VectorType TVector;
+
+ protected:
+ typedef TMatrix _TInternalMatrix;
+ typedef itk::Matrix< S, D, 1 > _TInternalVector;
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( InertiaTensorFunction, itkObject );
+
+ public:
+ inline void Reset( )
+ {
+ this->m_M = S( 0 );
+ this->m_MPP = S( 0 );
+ this->m_MP.Fill( S( 0 ) );
+ this->m_MPPT.Fill( S( 0 ) );
+ this->Modified( );
+ }
+ inline void AddMass( const TPoint& pnt, const S& mass = S( 1 ) )
+ {
+ this->AddMass( pnt.GetVectorFromOrigin( ), mass );
+ }
+ inline void AddMass( const S* data, const S& mass = S( 1 ) )
+ {
+ this->AddMass( TVector( data ), mass );
+ }
+ inline void AddMass( const TVector& vec, const S& mass = S( 1 ) )
+ {
+ this->m_M += mass;
+ this->m_MPP += mass * ( vec * vec );
+
+ _TInternalVector mp;
+ for( unsigned int d = 0; d < D; ++d )
+ {
+ this->m_MP[ d ][ 0 ] += mass * vec[ d ];
+ mp[ d ][ 0 ] = vec[ d ];
+
+ } // rof
+ this->m_MPPT +=
+ _TInternalMatrix( mp.GetVnlMatrix( ) * mp.GetTranspose( ) ) *
+ mass;
+ }
+
+ inline S GetMass( ) const
+ {
+ return( this->m_M );
+ }
+
+ inline TMatrix GetInertia( ) const
+ {
+ TMatrix I;
+ if( S( 0 ) < this->m_M )
+ {
+ I.SetIdentity( );
+ I *= this->m_MPP - ( ( this->m_MP.GetTranspose( ) * this->m_MP.GetVnlMatrix( ) )[ 0 ][ 0 ] / this->m_M );
+ I -= this->m_MPPT;
+ I += TMatrix( this->m_MP.GetVnlMatrix( ) * this->m_MP.GetTranspose( ) ) / this->m_M;
+ }
+ else
+ I.Fill( S( 0 ) );
+ return( I );
+ }
+
+ inline TVector GetCenterOfGravity( ) const
+ {
+ TVector cog;
+ if( S( 0 ) < this->m_M )
+ {
+ for( unsigned int d = 0; d < D; ++d )
+ cog[ d ] = this->m_MP[ d ][ 0 ] / this->m_M;
+ }
+ else
+ cog.Fill( S( 0 ) );
+ return( cog );
+ }
+
+ inline void GetEigenAnalysis( TMatrix& pm, TVector& pv, TVector& r ) const
+ {
+ TMatrix I = this->GetInertia( );
+
+ itk::SymmetricEigenAnalysis< TMatrix, TVector, TMatrix > eigen;
+ eigen.SetDimension( D );
+ eigen.SetOrderEigenMagnitudes( true );
+ eigen.SetOrderEigenValues( 1 );
+ eigen.ComputeEigenValuesAndVectors( I, pv, pm );
+ pm = TMatrix( pm.GetTranspose( ) );
+ S det = vnl_determinant( pm.GetVnlMatrix( ) );
+ for( unsigned int d = 0; d < D; ++d )
+ pm[ d ][ D - 1 ] *= det;
+
+ if( D == 2 )
+ {
+ S coeff = S( 4 ) / this->m_M;
+ r[ 0 ] = std::sqrt( std::fabs( coeff * pv[ 1 ] ) );
+ r[ 1 ] = std::sqrt( std::fabs( coeff * pv[ 0 ] ) );
+ }
+ else if( D == 3 )
+ {
+ S coeff = S( 2.5 ) / this->m_M;
+ r[ 0 ] = std::sqrt( std::fabs( coeff * ( pv[ 1 ] + pv[ 2 ] - pv[ 0 ] ) ) );
+ r[ 1 ] = std::sqrt( std::fabs( coeff * ( pv[ 0 ] + pv[ 2 ] - pv[ 1 ] ) ) );
+ r[ 2 ] = std::sqrt( std::fabs( coeff * ( pv[ 0 ] + pv[ 1 ] - pv[ 2 ] ) ) );
+ }
+ else
+ r.Fill( S( 0 ) );
+ }
+
+ protected:
+ InertiaTensorFunction( )
+ : Superclass( )
+ {
+ this->Reset( );
+ }
+ virtual ~InertiaTensorFunction( )
+ {
+ }
+
+ private:
+ // Purposely not implemented.
+ InertiaTensorFunction( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ S m_M;
+ S m_MPP;
+ _TInternalVector m_MP;
+ _TInternalMatrix m_MPPT;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+// #include <cpPlugins/Extensions/Algorithms/InertiaTensorFunction.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+
+#include <set>
+#include <itkImageToImageFilter.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class I, class O >
+ class MultiScaleGaussianImageFilter
+ : public itk::ImageToImageFilter< I, O >
+ {
+ public:
+ typedef MultiScaleGaussianImageFilter Self;
+ typedef itk::ImageToImageFilter< I, O > Superclass;
+ typedef itk::SmartPointer< Self > Pointer;
+ typedef itk::SmartPointer< const Self > ConstPointer;
+
+ typedef I TInputImage;
+ typedef O TOutputImage;
+
+ typedef std::set< double > TScalesContainer;
+
+ enum FilterId
+ {
+ Gradient = 0,
+ GradientMagnitude,
+ Hessian,
+ None
+ };
+
+ protected:
+ /**
+ */
+ class _Greater
+ {
+ public:
+ typedef typename O::PixelType _T;
+
+ public:
+ _Greater( );
+ virtual ~_Greater( );
+ bool operator!=( const _Greater& b ) const;
+ bool operator==( const _Greater& b ) const;
+ inline _T operator()( const _T& a ) const;
+ inline _T operator()( const _T& a, const _T& b ) const;
+ };
+
+ public:
+ itkNewMacro( Self );
+ itkTypeMacro( MultiScaleGaussianImageFilter, itkImageToImageFilter );
+
+ public:
+ void SetFilterToGradient( );
+ void SetFilterToGradientMagnitude( );
+ void SetFilterToHessian( );
+
+ bool IsGradientFilter( ) const;
+ bool IsGradientMagnitudeFilter( ) const;
+ bool IsHessianFilter( ) const;
+
+ void AddScale( const double& s );
+ unsigned long GetNumberOfScales( ) const;
+
+ protected:
+ MultiScaleGaussianImageFilter( );
+ virtual ~MultiScaleGaussianImageFilter( );
+
+ virtual void GenerateData( );
+
+ template< class F >
+ void _GenerateData( );
+
+ private:
+ // Purposely not implemented.
+ MultiScaleGaussianImageFilter( const Self& );
+ void operator=( const Self& );
+
+ protected:
+ TScalesContainer m_Scales;
+ FilterId m_FilterId;
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.hxx>
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+
+#include <vnl/vnl_vector.h>
+
+#include <itkImageRegionIterator.h>
+#include <itkImageRegionConstIterator.h>
+#include <itkNumericTraits.h>
+#include <itkProgressAccumulator.h>
+
+#include <itkBinaryFunctorImageFilter.h>
+#include <itkUnaryFunctorImageFilter.h>
+#include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
+#include <itkGradientRecursiveGaussianImageFilter.h>
+#include <itkHessianRecursiveGaussianImageFilter.h>
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+_Greater( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+~_Greater( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+bool cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+operator!=( const _Greater& b ) const
+{
+ return( false );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+bool cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+operator==( const _Greater& b ) const
+{
+ return !( *this != b );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+typename cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+_T cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+operator()( const _T& a ) const
+{
+ return( a );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+typename cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+_T cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::_Greater::
+operator()( const _T& a, const _T& b ) const
+{
+ typedef itk::NumericTraits< _T > _TTraits;
+ typedef typename _TTraits::ValueType _TValue;
+ typedef vnl_vector< _TValue > _TVector;
+
+ _TVector va( _TTraits::GetLength( ) );
+ _TVector vb( _TTraits::GetLength( ) );
+
+ _TTraits::AssignToArray( a, va );
+ _TTraits::AssignToArray( b, vb );
+ return( ( vb.magnitude( ) < va.magnitude( ) )? a: b );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+SetFilterToGradient( )
+{
+ if(
+ itk::NumericTraits< typename O::PixelType >::GetLength( ) ==
+ I::ImageDimension
+ )
+ this->m_FilterId = Self::Gradient;
+ else
+ this->m_FilterId = Self::None;
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+SetFilterToGradientMagnitude( )
+{
+ if( itk::NumericTraits< typename O::PixelType >::GetLength( ) == 1 )
+ this->m_FilterId = Self::GradientMagnitude;
+ else
+ this->m_FilterId = Self::None;
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+SetFilterToHessian( )
+{
+ itkExceptionMacro( << "Check for hessian definition." );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+bool
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+IsGradientFilter( ) const
+{
+ return( this->m_FilterId == Self::Gradient );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+bool
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+IsGradientMagnitudeFilter( ) const
+{
+ return( this->m_FilterId == Self::GradientMagnitude );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+bool
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+IsHessianFilter( ) const
+{
+ return( this->m_FilterId == Self::Hessian );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+AddScale( const double& s )
+{
+ if( this->m_Scales.insert( s ).second )
+ this->Modified( );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+unsigned long
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+GetNumberOfScales( ) const
+{
+ return( this->m_Scales.size( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+MultiScaleGaussianImageFilter( )
+ : Superclass( )
+{
+ this->SetFilterToGradientMagnitude( );
+ if( !this->IsGradientMagnitudeFilter( ) )
+ {
+ this->SetFilterToGradient( );
+ if( !this->IsGradientFilter( ) )
+ this->SetFilterToHessian( );
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+~MultiScaleGaussianImageFilter( )
+{
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+GenerateData( )
+{
+ typedef itk::GradientRecursiveGaussianImageFilter< I, O > _TGF;
+ typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< I, O > _TGMF;
+ typedef itk::HessianRecursiveGaussianImageFilter< I, O > _THF;
+
+ if( this->IsGradientFilter( ) )
+ this->_GenerateData< _TGF >( );
+ else if( this->IsGradientMagnitudeFilter( ) )
+ this->_GenerateData< _TGMF >( );
+ else if( this->IsHessianFilter( ) )
+ this->_GenerateData< _THF >( );
+}
+
+// -------------------------------------------------------------------------
+template< class I, class O >
+template< class F >
+void
+cpPlugins::Extensions::Algorithms::
+MultiScaleGaussianImageFilter< I, O >::
+_GenerateData( )
+{
+ // Some types
+ typedef itk::BinaryFunctorImageFilter< O, O, O, _Greater > _TMaxFilter;
+ typedef itk::UnaryFunctorImageFilter< O, O, _Greater > _TCopyFilter;
+ typedef itk::ImageRegionConstIterator< O > _TConstIt;
+ typedef itk::ImageRegionIterator< O > _TIt;
+ typedef itk::ProgressAccumulator _TProgress;
+
+ // Some values
+ typename I::ConstPointer input = this->GetInput( );
+ typename O::Pointer output = this->GetOutput( );
+ unsigned int nThreads = this->GetNumberOfThreads( );
+ float fw = float( 1 ) / float( this->m_Scales.size( ) << 1 );
+
+ // Progress accumulator
+ _TProgress::Pointer pg = _TProgress::New( );
+ pg->SetMiniPipelineFilter( this );
+
+ // Copy image information
+ output->SetLargestPossibleRegion( input->GetLargestPossibleRegion( ) );
+ output->SetRequestedRegion( input->GetRequestedRegion( ) );
+ output->SetBufferedRegion( input->GetBufferedRegion( ) );
+ output->SetSpacing( input->GetSpacing( ) );
+ output->SetOrigin( input->GetOrigin( ) );
+ output->SetDirection( input->GetDirection( ) );
+ output->Allocate( );
+
+ // Intermediary buffer
+ typename O::Pointer buffer = O::New( );
+ buffer->SetLargestPossibleRegion( input->GetLargestPossibleRegion( ) );
+ buffer->SetRequestedRegion( input->GetRequestedRegion( ) );
+ buffer->SetBufferedRegion( input->GetBufferedRegion( ) );
+ buffer->SetSpacing( input->GetSpacing( ) );
+ buffer->SetOrigin( input->GetOrigin( ) );
+ buffer->SetDirection( input->GetDirection( ) );
+ buffer->Allocate( );
+
+ // Perform all scales
+ _TIt gIt( output, output->GetRequestedRegion( ) );
+ TScalesContainer::const_iterator sIt = this->m_Scales.begin( );
+ for( ; sIt != this->m_Scales.end( ); sIt++ )
+ {
+ // Single scale filter
+ typename F::Pointer filter = F::New( );
+ filter->SetInput( input );
+ filter->SetNormalizeAcrossScale( true );
+ filter->SetNumberOfThreads( nThreads );
+ filter->SetSigma( *sIt );
+ pg->RegisterInternalFilter( filter, fw );
+ filter->GraftOutput( buffer );
+ filter->Update( );
+ buffer->Graft( filter->GetOutput( ) );
+
+ // Get maximum response
+ if( sIt == this->m_Scales.begin( ) )
+ {
+ // Copy first result
+ typename _TCopyFilter::Pointer copy = _TCopyFilter::New( );
+ copy->SetInput( buffer );
+ copy->InPlaceOff( );
+ copy->SetNumberOfThreads( nThreads );
+ pg->RegisterInternalFilter( copy, fw );
+ copy->GraftOutput( output );
+ copy->Update( );
+ output->Graft( copy->GetOutput( ) );
+ }
+ else
+ {
+ // Maximize results
+ typename _TMaxFilter::Pointer max = _TMaxFilter::New( );
+ max->SetInput1( output );
+ max->SetInput2( buffer );
+ max->InPlaceOn( );
+ max->SetNumberOfThreads( nThreads );
+ pg->RegisterInternalFilter( max, fw );
+ max->GraftOutput( output );
+ max->Update( );
+ output->Graft( max->GetOutput( ) );
+
+ } // fi
+
+ } // rof
+}
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+
+// eof - $RCSfile$
--- /dev/null
+// -------------------------------------------------------------------------
+// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
+// -------------------------------------------------------------------------
+
+#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+
+#include <cmath>
+#include <limits>
+#include <vnl/vnl_math.h>
+
+#include <itkRGBPixel.h>
+#include <itkVector.h>
+
+namespace cpPlugins
+{
+ namespace Extensions
+ {
+ namespace Algorithms
+ {
+ /**
+ */
+ template< class O >
+ struct RGBExtractFunction
+ {
+ typedef RGBExtractFunction Self;
+ typedef itk::Vector< O, 3 > TOutPixel;
+
+ template< class Tr, class Tg, class Tb >
+ TOutPixel operator()( const Tr& r, const Tg& g, const Tb& b ) const
+ {
+ TOutPixel rgb;
+ rgb[ 0 ] = O( r );
+ rgb[ 1 ] = O( g );
+ rgb[ 2 ] = O( b );
+ return( rgb );
+ }
+
+ template< class C >
+ TOutPixel operator()( const itk::RGBPixel< C >& rgb ) const
+ {
+ return(
+ this->operator()(
+ rgb.GetRed( ), rgb.GetGreen( ), rgb.GetBlue( )
+ )
+ );
+ }
+ };
+
+ } // ecapseman
+
+ } // ecapseman
+
+} // ecapseman
+
+#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+
+// eof - $RCSfile$
)
TARGET_LINK_LIBRARIES(
${LIBRARY_NAME}
- ITKCommon
- ITKVtkGlue
+ vtkCommonCore
+ vtkRenderingCore
+ vtkRenderingOpenGL
+ vtkRenderingAnnotation
+ vtkRenderingVolumeOpenGL
+ vtkRenderingFreeTypeOpenGL
+ vtkInteractionStyle
vtkInteractionWidgets
+ vtkIOMPIImage
+ ITKCommon
+ ITKVTK
)
## eof - $RCSfile$
this->m_Windows[ i ]->Render( );
}
+// -------------------------------------------------------------------------
+vtkRenderer* cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+GetRenderer( const int& id ) const
+{
+ if( id < 4 )
+ return( this->m_Renderers[ id ] );
+ else
+ return( NULL );
+}
+
// -------------------------------------------------------------------------
void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
Add3DActor( vtkProp3D* prop )
void Render( const int& id );
void RenderAll( );
+ vtkRenderer* GetRenderer( const int& id ) const;
+
void Add3DActor( vtkProp3D* prop );
protected:
${LIBRARY_NAME}
cpPlugins_Interface
${ITK_LIBRARIES}
- ${VTK_LIBRARIES}
- vtkIOLegacy
- ITKIOImageBase
)
## eof - $RCSfile$
--- /dev/null
+/*=========================================================================
+ *
+ * Copyright Insight Software Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef __itkImageToVTKImageFilter_h
+#define __itkImageToVTKImageFilter_h
+
+#include "itkVTKImageExport.h"
+#include "vtkImageImport.h"
+#include "vtkImageData.h"
+
+namespace itk
+{
+
+/** \class ImageToVTKImageFilter
+ * \brief Converts an ITK image into a VTK image and plugs a
+ * itk data pipeline to a VTK datapipeline.
+ *
+ * This class puts together an itkVTKImageExporter and a vtkImageImporter.
+ * It takes care of the details related to the connection of ITK and VTK
+ * pipelines. The User will perceive this filter as an adaptor to which
+ * an itk::Image can be plugged as input and a vtkImage is produced as
+ * output.
+ *
+ * \ingroup ITKVtkGlue
+ *
+ * \wiki
+ * \wikiexample{IO/ImageToVTKImageFilter,Display an ITK image}
+ * \wikiexample{IO/itkVtkImageConvertDICOM,Uses a custom user matrix to align the image with DICOM physical space}
+ * \endwiki
+ */
+template <typename TInputImage >
+class ImageToVTKImageFilter : public ProcessObject
+{
+public:
+ /** Standard class typedefs. */
+ typedef ImageToVTKImageFilter Self;
+ typedef ProcessObject Superclass;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self);
+
+ /** Run-time type information (and related methods). */
+ itkTypeMacro(ImageToVTKImageFilter, ProcessObject);
+
+ /** Some typedefs. */
+ typedef TInputImage InputImageType;
+ typedef typename InputImageType::ConstPointer InputImagePointer;
+
+ typedef VTKImageExport< InputImageType> ExporterFilterType;
+ typedef typename ExporterFilterType::Pointer ExporterFilterPointer;
+
+ /** Get the output in the form of a vtkImage.
+ This call is delegated to the internal vtkImageImporter filter */
+ vtkImageData * GetOutput() const;
+
+ /** Set the input in the form of an itk::Image */
+ using Superclass::SetInput;
+ void SetInput( const InputImageType * );
+ InputImageType * GetInput();
+
+ /** Return the internal VTK image importer filter.
+ This is intended to facilitate users the access
+ to methods in the importer */
+ vtkImageImport * GetImporter() const;
+
+ /** Return the internal ITK image exporter filter.
+ This is intended to facilitate users the access
+ to methods in the exporter */
+ ExporterFilterType * GetExporter() const;
+
+ /** This call delegates the update to the importer */
+ void Update();
+
+protected:
+ ImageToVTKImageFilter();
+ virtual ~ImageToVTKImageFilter();
+
+private:
+ ImageToVTKImageFilter(const Self&); //purposely not implemented
+ void operator=(const Self&); //purposely not implemented
+
+ ExporterFilterPointer m_Exporter;
+ vtkImageImport * m_Importer;
+};
+
+} // end namespace itk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkImageToVTKImageFilter.hxx"
+#endif
+
+#endif
--- /dev/null
+/*=========================================================================
+ *
+ * Copyright Insight Software Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef __itkImageToVTKImageFilter_hxx
+#define __itkImageToVTKImageFilter_hxx
+
+#include "itkImageToVTKImageFilter.h"
+
+namespace itk
+{
+
+/**
+ * Constructor
+ */
+template <typename TInputImage>
+ImageToVTKImageFilter<TInputImage>
+::ImageToVTKImageFilter()
+{
+ m_Importer = vtkImageImport::New();
+ m_Exporter = ExporterFilterType::New();
+
+ m_Importer->SetUpdateInformationCallback(m_Exporter->GetUpdateInformationCallback());
+ m_Importer->SetPipelineModifiedCallback(m_Exporter->GetPipelineModifiedCallback());
+ m_Importer->SetWholeExtentCallback(m_Exporter->GetWholeExtentCallback());
+ m_Importer->SetSpacingCallback(m_Exporter->GetSpacingCallback());
+ m_Importer->SetOriginCallback(m_Exporter->GetOriginCallback());
+ m_Importer->SetScalarTypeCallback(m_Exporter->GetScalarTypeCallback());
+ m_Importer->SetNumberOfComponentsCallback(m_Exporter->GetNumberOfComponentsCallback());
+ m_Importer->SetPropagateUpdateExtentCallback(m_Exporter->GetPropagateUpdateExtentCallback());
+ m_Importer->SetUpdateDataCallback(m_Exporter->GetUpdateDataCallback());
+ m_Importer->SetDataExtentCallback(m_Exporter->GetDataExtentCallback());
+ m_Importer->SetBufferPointerCallback(m_Exporter->GetBufferPointerCallback());
+ m_Importer->SetCallbackUserData(m_Exporter->GetCallbackUserData());
+
+}
+
+/**
+ * Destructor
+ */
+template <typename TInputImage>
+ImageToVTKImageFilter<TInputImage>
+::~ImageToVTKImageFilter()
+{
+ if( m_Importer )
+ {
+ m_Importer->Delete();
+ m_Importer = 0;
+ }
+}
+
+/**
+ * Set an itk::Image as input
+ */
+template <typename TInputImage>
+void
+ImageToVTKImageFilter<TInputImage>
+::SetInput( const InputImageType * inputImage )
+{
+ m_Exporter->SetInput( inputImage );
+}
+
+template <typename TInputImage>
+typename ImageToVTKImageFilter<TInputImage>::InputImageType *
+ImageToVTKImageFilter<TInputImage>
+::GetInput()
+{
+ return m_Exporter->GetInput();
+}
+
+/**
+ * Get a vtkImage as output
+ */
+template <typename TInputImage>
+vtkImageData *
+ImageToVTKImageFilter<TInputImage>
+::GetOutput() const
+{
+ return m_Importer->GetOutput();
+}
+
+/**
+ * Get the importer filter
+ */
+template <typename TInputImage>
+vtkImageImport *
+ImageToVTKImageFilter<TInputImage>
+::GetImporter() const
+{
+ return m_Importer;
+}
+
+/**
+ * Get the exporter filter
+ */
+template <typename TInputImage>
+typename ImageToVTKImageFilter<TInputImage>::ExporterFilterType *
+ImageToVTKImageFilter<TInputImage>
+::GetExporter() const
+{
+ return m_Exporter.GetPointer();
+}
+
+/**
+ * Delegate the Update to the importer
+ */
+template <typename TInputImage>
+void
+ImageToVTKImageFilter<TInputImage>
+::Update()
+{
+ m_Importer->Update();
+}
+} // end namespace itk
+
+#endif
--- /dev/null
+/*=========================================================================
+ *
+ * Copyright Insight Software Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *=========================================================================*/
+
+#ifndef __itkVTKImageToImageFilter_h
+#define __itkVTKImageToImageFilter_h
+
+#include "itkVTKImageImport.h"
+#include "vtkImageExport.h"
+#include "vtkImageData.h"
+#include "vtkSmartPointer.h"
+
+#ifndef vtkFloatingPointType
+#define vtkFloatingPointType float
+#endif
+
+namespace itk
+{
+
+/** \class VTKImageToImageFilter
+ * \brief Converts a VTK image into an ITK image and plugs a
+ * VTK data pipeline to an ITK datapipeline.
+ *
+ * This class puts together an itk::VTKImageImport and a vtk::ImageExport.
+ * It takes care of the details related to the connection of ITK and VTK
+ * pipelines. The User will perceive this filter as an adaptor to which
+ * a vtkImageData can be plugged as input and an itk::Image is produced as
+ * output.
+ *
+ * \ingroup ITKVtkGlue
+ */
+template <typename TOutputImage >
+class VTKImageToImageFilter : public VTKImageImport< TOutputImage >
+{
+public:
+ /** Standard class typedefs. */
+ typedef VTKImageToImageFilter Self;
+ typedef VTKImageImport< TOutputImage > Superclass;
+ typedef SmartPointer<Self> Pointer;
+ typedef SmartPointer<const Self> ConstPointer;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self);
+
+ /** Run-time type information (and related methods). */
+ itkTypeMacro(VTKImageToImageFilter, VTKImageImport);
+
+ /** Some typedefs. */
+ typedef TOutputImage OutputImageType;
+ typedef typename OutputImageType::ConstPointer OutputImagePointer;
+
+ /** Set the input in the form of a vtkImageData */
+ void SetInput( vtkImageData * );
+ using Superclass::SetInput;
+
+ /** Return the internal VTK image exporter filter.
+ This is intended to facilitate users the access
+ to methods in the exporter */
+ vtkImageExport * GetExporter() const;
+
+ /** Return the internal ITK image importer filter.
+ This is intended to facilitate users the access
+ to methods in the importer.
+ */
+ const Superclass * GetImporter() const;
+
+protected:
+ VTKImageToImageFilter();
+ virtual ~VTKImageToImageFilter();
+
+private:
+ VTKImageToImageFilter(const Self&); //purposely not implemented
+ void operator=(const Self&); //purposely not implemented
+
+ typedef vtkSmartPointer<vtkImageExport> ImageExportPointer;
+ ImageExportPointer m_Exporter;
+
+};
+
+} // end namespace itk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkVTKImageToImageFilter.hxx"
+#endif
+
+#endif
--- /dev/null
+/*=========================================================================
+ *
+ * Copyright Insight Software Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *=========================================================================*/
+
+#ifndef __itkVTKImageToImageFilter_hxx
+#define __itkVTKImageToImageFilter_hxx
+
+#include "itkVTKImageToImageFilter.h"
+
+#include "vtkVersion.h"
+
+namespace itk
+{
+
+/**
+ * Constructor
+ */
+template <typename TOutputImage>
+VTKImageToImageFilter<TOutputImage>
+::VTKImageToImageFilter()
+{
+
+ m_Exporter = vtkImageExport::New();
+
+ this->SetUpdateInformationCallback( m_Exporter->GetUpdateInformationCallback());
+ this->SetPipelineModifiedCallback( m_Exporter->GetPipelineModifiedCallback());
+ this->SetWholeExtentCallback( m_Exporter->GetWholeExtentCallback());
+ this->SetSpacingCallback( m_Exporter->GetSpacingCallback());
+ this->SetOriginCallback( m_Exporter->GetOriginCallback());
+ this->SetScalarTypeCallback( m_Exporter->GetScalarTypeCallback());
+ this->SetNumberOfComponentsCallback( m_Exporter->GetNumberOfComponentsCallback());
+ this->SetPropagateUpdateExtentCallback( m_Exporter->GetPropagateUpdateExtentCallback());
+ this->SetUpdateDataCallback( m_Exporter->GetUpdateDataCallback());
+ this->SetDataExtentCallback( m_Exporter->GetDataExtentCallback());
+ this->SetBufferPointerCallback( m_Exporter->GetBufferPointerCallback());
+ this->SetCallbackUserData( m_Exporter->GetCallbackUserData());
+
+}
+
+/**
+ * Destructor
+ */
+template <typename TOutputImage>
+VTKImageToImageFilter<TOutputImage>
+::~VTKImageToImageFilter()
+{
+ if( m_Exporter )
+ {
+ m_Exporter->Delete();
+ m_Exporter = 0;
+ }
+}
+
+/**
+ * Set a vtkImageData as input
+ */
+template <typename TOutputImage>
+void
+VTKImageToImageFilter<TOutputImage>
+::SetInput( vtkImageData * inputImage )
+{
+#if VTK_MAJOR_VERSION <= 5
+ m_Exporter->SetInput( inputImage );
+#else
+ m_Exporter->SetInputData( inputImage );
+#endif
+}
+
+/**
+ * Get the exporter filter
+ */
+template <typename TOutputImage>
+vtkImageExport *
+VTKImageToImageFilter<TOutputImage>
+::GetExporter() const
+{
+ return m_Exporter;
+}
+
+/**
+ * Get the importer filter
+ */
+template <typename TOutputImage>
+const typename VTKImageToImageFilter<TOutputImage>::Superclass *
+VTKImageToImageFilter<TOutputImage>
+::GetImporter() const
+{
+ return this;
+}
+
+} // end namespace itk
+
+#endif
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff