)
TARGET_LINK_LIBRARIES(
${App_NAME}
- cpPlugins_Interface
${QT_LIBRARIES}
- vtkGUISupportQt
+ cpExtensions
+ ##vtkGUISupportQt
)
ENDIF(USE_QT4)
#include <cpPlugins/Interface/ProcessObject.h>
#include <cpPlugins/Interface/Image.h>
#include <cpPlugins/Interface/Mesh.h>
-#include <cpPlugins/Extensions/Visualization/MPRWithDifferentWindows.h>
+#include <cpExtensions/Visualization/MPRWithDifferentWindows.h>
// -------------------------------------------------------------------------
namespace Ui
typedef cpPlugins::Interface::Parameters TParameters;
typedef std::set< std::string > TStringContainer;
- typedef cpPlugins::Extensions::Visualization::MPRWithDifferentWindows TMPR;
+ typedef cpExtensions::Visualization::MPRWithDifferentWindows TMPR;
public:
explicit ImageMPR( QWidget* parent = 0 );
SET(
EXAMPLES_PROGRAMS
## example_TestParameters
- example_LoadPlugins
- example_ReadWriteImage
- example_MarchingCubes
- example_OtsuFilter
+ #example_LoadPlugins
+ #example_ReadWriteImage
+ #example_MarchingCubes
+ #example_OtsuFilter
## example_ReadImageSeriesWriteImage
## example_ReadQuadEdgeMesh
## example_RenderQuadEdgeMesh
${prog}
${prog}.cxx
)
- TARGET_LINK_LIBRARIES(
- ${prog}
- cpPlugins_Interface
- )
+ #TARGET_LINK_LIBRARIES(
+ # ${prog}
+ # cpPlugins_Interface
+ # )
ENDFOREACH(prog)
SET(
TARGET_LINK_LIBRARIES(
${prog}
${ITK_LIBRARIES}
- cpPlugins_Extensions
+ cpExtensions
)
ENDFOREACH(prog)
SUBDIRS(
+ cpExtensions
cpPlugins
third_party
)
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
#include <vector>
#include <itkFunctionBase.h>
#include <itkMatrix.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/BezierCurveFunction.hxx>
+#include <cpExtensions/Algorithms/BezierCurveFunction.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
// -------------------------------------------------------------------------
template< class V >
-void cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+void cpExtensions::Algorithms::BezierCurveFunction< V >::
AddPoint( const TVector& v )
{
this->m_Vectors.push_back( v );
// -------------------------------------------------------------------------
template< class V >
-unsigned int cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+unsigned int cpExtensions::Algorithms::BezierCurveFunction< V >::
GetNumberOfPoints( ) const
{
return( this->m_Vectors.size( ) );
// -------------------------------------------------------------------------
template< class V >
-typename cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
-TVector cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+typename cpExtensions::Algorithms::BezierCurveFunction< V >::
+TVector cpExtensions::Algorithms::BezierCurveFunction< V >::
Evaluate( const TScalar& u ) const
{
TVectorsContainer Q = this->m_Vectors;
// -------------------------------------------------------------------------
template< class V >
-typename cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
-TFrame cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+typename cpExtensions::Algorithms::BezierCurveFunction< V >::
+TFrame cpExtensions::Algorithms::BezierCurveFunction< V >::
EvaluateFrenetFrame( const TScalar& u ) const
{
TFrame fr;
// -------------------------------------------------------------------------
template< class V >
-typename cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
-TScalar cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+typename cpExtensions::Algorithms::BezierCurveFunction< V >::
+TScalar cpExtensions::Algorithms::BezierCurveFunction< V >::
EvaluateLength( ) const
{
unsigned int n = this->GetNumberOfPoints( ) << 1;
// -------------------------------------------------------------------------
template< class V >
-cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+cpExtensions::Algorithms::BezierCurveFunction< V >::
BezierCurveFunction( )
: Superclass( ),
m_DerivativeUpdated( false )
// -------------------------------------------------------------------------
template< class V >
-void cpPlugins::Extensions::Algorithms::BezierCurveFunction< V >::
+void cpExtensions::Algorithms::BezierCurveFunction< V >::
_UpdateDerivative( ) const
{
if( this->m_DerivativeUpdated )
);
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__BEZIERCURVEFUNCTION__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+#define __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
#include <map>
#include <itkImageFunction.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/GradientFunctionBase.hxx>
+#include <cpExtensions/Algorithms/GradientFunctionBase.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
// -------------------------------------------------------------------------
template< class G >
-void cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+void cpExtensions::Algorithms::GradientFunctionBase< G >::
ResetBuffer( )
{
this->m_Buffer.clear( );
// -------------------------------------------------------------------------
template< class G >
-typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
-TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+typename cpExtensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpExtensions::Algorithms::GradientFunctionBase< G >::
Evaluate( const TPoint& p ) const
{
TIndex i;
// -------------------------------------------------------------------------
template< class G >
-typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
-TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+typename cpExtensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpExtensions::Algorithms::GradientFunctionBase< G >::
EvaluateAtIndex( const TIndex& i ) const
{
TOutput res = TOutput( 0 );
// -------------------------------------------------------------------------
template< class G >
-typename cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
-TOutput cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+typename cpExtensions::Algorithms::GradientFunctionBase< G >::
+TOutput cpExtensions::Algorithms::GradientFunctionBase< G >::
EvaluateAtContinuousIndex( const TContIndex& i ) const
{
TPoint p;
// -------------------------------------------------------------------------
template< class G >
-cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+cpExtensions::Algorithms::GradientFunctionBase< G >::
GradientFunctionBase( )
: Superclass( ),
m_BufferResults( false )
// -------------------------------------------------------------------------
template< class G >
-cpPlugins::Extensions::Algorithms::GradientFunctionBase< G >::
+cpExtensions::Algorithms::GradientFunctionBase< G >::
~GradientFunctionBase( )
{
this->m_Buffer.clear( );
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__GRADIENTFUNCTIONBASE__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+#define __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
#include <vector>
-#include <cpPlugins/Extensions/Algorithms/GradientFunctionBase.h>
+#include <cpExtensions/Algorithms/GradientFunctionBase.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/GulsunTekMedialness.hxx>
+#include <cpExtensions/Algorithms/GulsunTekMedialness.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
#include <cmath>
#include <vnl/vnl_math.h>
// -------------------------------------------------------------------------
template< class G >
-cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+cpExtensions::Algorithms::GulsunTekMedialness< G >::
GulsunTekMedialness( )
: Superclass( ),
m_MinRadius( double( 0 ) ),
// -------------------------------------------------------------------------
template< class G >
-cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+cpExtensions::Algorithms::GulsunTekMedialness< G >::
~GulsunTekMedialness( )
{
}
// -------------------------------------------------------------------------
template< class G >
-typename cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
-TOutput cpPlugins::Extensions::Algorithms::GulsunTekMedialness< G >::
+typename cpExtensions::Algorithms::GulsunTekMedialness< G >::
+TOutput cpExtensions::Algorithms::GulsunTekMedialness< G >::
_Evaluate( const TIndex& i ) const
{
const G* gradient = this->GetInputImage( );
*/
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__GULSUNTEKMEDIALNESS__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
#include <itkImageToImageFilter.h>
#include <itkImageScanlineConstIterator.h>
#include <itkImageScanlineIterator.h>
#include <itkProgressReporter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-// TODO: #include <cpPlugins/Extensions/Algorithms/ImageFunctionFilter.hxx>
+// TODO: #include <cpExtensions/Algorithms/ImageFunctionFilter.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTIONFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
#include <itkImageToImageFilter.h>
#include <itkImageScanlineConstIterator.h>
#include <itkImageScanlineIterator.h>
#include <itkProgressReporter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__IMAGEFUNCTORFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+#define __CPEXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
#include <map>
#include <itkImageFunction.h>
-#include <cpPlugins/Extensions/Algorithms/InertiaTensorFunction.h>
+#include <cpExtensions/Algorithms/InertiaTensorFunction.h>
#include <itkImageRegionConstIteratorWithIndex.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-// TODO: #include <cpPlugins/Extensions/Algorithms/InertiaMedialness.hxx>
+// TODO: #include <cpExtensions/Algorithms/InertiaMedialness.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__INERTIAMEDIALNESS__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
#include <itkObject.h>
#include <itkSymmetricEigenAnalysis.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-// #include <cpPlugins/Extensions/Algorithms/InertiaTensorFunction.hxx>
+// #include <cpExtensions/Algorithms/InertiaTensorFunction.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__INERTIATENSORFUNCTION__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
+#define __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
#include <itkAffineTransform.h>
#include <itkExtractImageFilter.h>
#include <itkVectorResampleImageFilter.h>
#include <itkVectorInterpolateImageFunction.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/IsoImageSlicer.hxx>
+#include <cpExtensions/Algorithms/IsoImageSlicer.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
// -------------------------------------------------------------------------
template< class R, class I >
-unsigned long cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+unsigned long cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GetMTime( ) const
{
unsigned long t = this->Superclass::GetMTime( );
// -------------------------------------------------------------------------
template< class R, class I >
-const typename cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+const typename cpExtensions::Algorithms::BaseImageSlicer< R, I >::
TInterpolateFunction*
-cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GetInterpolator( ) const
{
return( this->m_Slicer->GetInterpolator( ) );
// -------------------------------------------------------------------------
template< class R, class I >
-const typename cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
-TMatrix& cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+const typename cpExtensions::Algorithms::BaseImageSlicer< R, I >::
+TMatrix& cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GetRotation( ) const
{
return( this->m_Transform->GetMatrix( ) );
// -------------------------------------------------------------------------
template< class R, class I >
-const typename cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
-TVector& cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+const typename cpExtensions::Algorithms::BaseImageSlicer< R, I >::
+TVector& cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GetTranslation( ) const
{
return( this->m_Transform->GetOffset( ) );
// -------------------------------------------------------------------------
template< class R, class I >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
SetInterpolator( TInterpolateFunction* f )
{
this->m_Slicer->SetInterpolator( f );
// -------------------------------------------------------------------------
template< class R, class I >
template< class M >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
SetRotation( const M& r )
{
TMatrix rotation;
// -------------------------------------------------------------------------
template< class R, class I >
template< class V >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
SetTranslation( const V& t )
{
TVector off;
// -------------------------------------------------------------------------
template< class R, class I >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
SetSize( TScalar s )
{
this->m_Size.Fill( s );
// -------------------------------------------------------------------------
template< class R, class I >
-cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+cpExtensions::Algorithms::BaseImageSlicer< R, I >::
BaseImageSlicer( )
: Superclass( ),
m_SizeFromMaximum( false ),
// -------------------------------------------------------------------------
template< class R, class I >
-cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+cpExtensions::Algorithms::BaseImageSlicer< R, I >::
~BaseImageSlicer( )
{
}
// -------------------------------------------------------------------------
template< class R, class I >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GenerateOutputInformation( )
{
}
// -------------------------------------------------------------------------
template< class R, class I >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GenerateInputRequestedRegion( )
{
TImage* input = const_cast< TImage* >( this->GetInput( ) );
// -------------------------------------------------------------------------
template< class R, class I >
-void cpPlugins::Extensions::Algorithms::BaseImageSlicer< R, I >::
+void cpExtensions::Algorithms::BaseImageSlicer< R, I >::
GenerateData( )
{
const TImage* input = this->GetInput( );
this->GraftOutput( this->m_Collapsor->GetOutput( ) );
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__ISOIMAGESLICER__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
+#define __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
#include <vector>
#include <itkConceptChecking.h>
#include <itkObject.h>
#include <vnl/vnl_matrix.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/IterativeGaussianModelEstimator.hxx>
+#include <cpExtensions/Algorithms/IterativeGaussianModelEstimator.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
#include <cmath>
#include <cstdarg>
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
SetNumberOfSamples( unsigned long n )
{
this->m_N = S( n );
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
SetMu( const TMatrix& m )
{
if( m.rows( ) == D && m.columns( ) == 1 )
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
SetOmega( const TMatrix& O )
{
if( O.rows( ) == D && O.columns( ) == D )
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-bool
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+bool cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
SaveModelToFile( const std::string& filename ) const
{
std::ofstream out( filename.c_str( ) );
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-bool
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+bool cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
LoadModelFromFile( const std::string& filename )
{
std::ifstream in( filename.c_str( ) );
// -------------------------------------------------------------------------
template< class S, unsigned int D >
template< class V >
-S cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+S cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
Probability( const V& sample ) const
{
if( !this->m_Updated )
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-S cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+S cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
Probability( const S& s_x, const S& s_y, ... ) const
{
static S sample[ D ];
// -------------------------------------------------------------------------
template< class S, unsigned int D >
template< class V, class M >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
GetModel( V& m, M& E ) const
{
if( !this->m_Updated )
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
Clear( )
{
this->m_N = S( 0 );
// -------------------------------------------------------------------------
template< class S, unsigned int D >
template< class V >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
AddSample( const V& sample )
{
TMatrix s( D, 1 );
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
AddSample( const S& s_x, const S& s_y, ... )
{
static S sample[ D ];
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
IterativeGaussianModelEstimator( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
~IterativeGaussianModelEstimator( )
{
}
// -------------------------------------------------------------------------
template< class S, unsigned int D >
-void
-cpPlugins::Extensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
+void cpExtensions::Algorithms::IterativeGaussianModelEstimator< S, D >::
_UpdateModel( ) const
{
static const double _2piD =
this->m_Updated = true;
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__ITERATIVEGAUSSIANMODELESTIMATOR__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#include <cpPlugins/Extensions/Algorithms/KalmanConstantFilter.h>
+#include <cpExtensions/Algorithms/KalmanConstantFilter.h>
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanConstantFilter< T >::
+void cpExtensions::Algorithms::KalmanConstantFilter< T >::
Configure( unsigned int m )
{
this->Superclass::Configure( m, 1, m );
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanConstantFilter< T >::
+void cpExtensions::Algorithms::KalmanConstantFilter< T >::
Initialize( )
{
this->Superclass::Initialize( );
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanConstantFilter< T >::
+cpExtensions::Algorithms::KalmanConstantFilter< T >::
KalmanConstantFilter( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanConstantFilter< T >::
+cpExtensions::Algorithms::KalmanConstantFilter< T >::
~KalmanConstantFilter( )
{
}
// -------------------------------------------------------------------------
// Explicit instantiations
-using namespace cpPlugins::Extensions::Algorithms;
+using namespace cpExtensions::Algorithms;
template class KalmanConstantFilter< float >;
template class KalmanConstantFilter< double >;
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
-#include <cpPlugins/Extensions/Algorithms/KalmanFilter.h>
+#include <cpExtensions/Algorithms/KalmanFilter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
/**
*/
template< typename T >
- class cpPlugins_Extensions_EXPORT KalmanConstantFilter
+ class cpExtensions_EXPORT KalmanConstantFilter
: public KalmanFilter< T >
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__KALMANCONSTANTFILTER__H__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Algorithms/KalmanFilter.h>
+#include <cpExtensions/Algorithms/KalmanFilter.h>
#include <cstdlib>
#include <vnl/algo/vnl_matrix_inverse.h>
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Configure( unsigned int s, unsigned int i, unsigned int m )
{
this->m_StateSize = s;
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Initialize( )
{
// Set all to the first iteration
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Predict( )
{
if( this->m_Step == Self::StFilt )
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Innovate( )
{
typedef vnl_matrix_inverse< T > _TInv;
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Filtrate( )
{
if( this->m_Step == Self::StInno )
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+cpExtensions::Algorithms::KalmanFilter< T >::
KalmanFilter( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+cpExtensions::Algorithms::KalmanFilter< T >::
~KalmanFilter( )
{
}
// -------------------------------------------------------------------------
// Explicit instantiations
-using namespace cpPlugins::Extensions::Algorithms;
+using namespace cpExtensions::Algorithms;
template class KalmanFilter< float >;
template class KalmanFilter< double >;
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__H__
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/cpExtensions_Export.h>
#include <itkObject.h>
#include <itkObjectFactory.h>
kalmanGetVectorMacro( var, name ); \
kalmanSetVectorMacro( var, name );
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
* for a description of this algorithm.
*/
template< typename T >
- class cpPlugins_Extensions_EXPORT KalmanFilter
+ class cpExtensions_EXPORT KalmanFilter
: public itk::Object
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/KalmanFilter.hxx>
+#include <cpExtensions/Algorithms/KalmanFilter.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
// -------------------------------------------------------------------------
template< typename T >
template< class M >
-void cpPlugins::Extensions::Algorithms::KalmanFilter< T >::
+void cpExtensions::Algorithms::KalmanFilter< T >::
Kronecker( M& AkB, const M& A, const M& B )
{
unsigned int m = A.rows( ); unsigned int n = A.cols( );
} // rof
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__KALMANFILTER__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#include <cpPlugins/Extensions/Algorithms/KalmanVelocityFilter.h>
+#include <cpExtensions/Algorithms/KalmanVelocityFilter.h>
#include <cmath>
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+void cpExtensions::Algorithms::KalmanVelocityFilter< T >::
Configure( unsigned int m )
{
this->Superclass::Configure( m << 1, 1, m );
// -------------------------------------------------------------------------
template< typename T >
-typename cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
-TScalar cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+typename cpExtensions::Algorithms::KalmanVelocityFilter< T >::
+TScalar cpExtensions::Algorithms::KalmanVelocityFilter< T >::
GetTimeOffset( ) const
{
return( TScalar( std::sqrt( double( this->m_TimeOffset[ 1 ][ 1 ] ) ) ) );
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+void cpExtensions::Algorithms::KalmanVelocityFilter< T >::
SetTimeOffset( TScalar t )
{
TScalar t2 = t * t;
// -------------------------------------------------------------------------
template< typename T >
-void cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+void cpExtensions::Algorithms::KalmanVelocityFilter< T >::
Initialize( )
{
this->Superclass::Initialize( );
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+cpExtensions::Algorithms::KalmanVelocityFilter< T >::
KalmanVelocityFilter( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename T >
-cpPlugins::Extensions::Algorithms::KalmanVelocityFilter< T >::
+cpExtensions::Algorithms::KalmanVelocityFilter< T >::
~KalmanVelocityFilter( )
{
}
// -------------------------------------------------------------------------
// Explicit instantiations
-using namespace cpPlugins::Extensions::Algorithms;
+using namespace cpExtensions::Algorithms;
template class KalmanVelocityFilter< float >;
template class KalmanVelocityFilter< double >;
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
-#include <cpPlugins/Extensions/Algorithms/KalmanFilter.h>
+#include <cpExtensions/Algorithms/KalmanFilter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
/**
*/
template< typename T >
- class cpPlugins_Extensions_EXPORT KalmanVelocityFilter
+ class cpExtensions_EXPORT KalmanVelocityFilter
: public KalmanFilter< T >
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__KALMANVELOCITYFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
#include <itkInPlaceImageFilter.h>
-#include <cpPlugins/Extensions/Algorithms/ParallelImageMean.h>
+#include <cpExtensions/Algorithms/ParallelImageMean.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
typedef I TImage;
typedef typename I::RegionType TRegion;
- typedef cpPlugins::Extensions::Algorithms::ParallelImageMean< I > TMeanCalculator;
+ typedef cpExtensions::Algorithms::ParallelImageMean< I > TMeanCalculator;
typedef typename TMeanCalculator::TMean TMean;
public:
TMean m_Coefficient;
};
- } // ecapseman
-
} // ecapseman
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/LightCompensationFilter.hxx>
+#include <cpExtensions/Algorithms/LightCompensationFilter.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
#include <itkImageRegionIterator.h>
#include <itkImageRegionConstIterator.h>
// -------------------------------------------------------------------------
template< class I >
-cpPlugins::Extensions::Algorithms::LightCompensationFilter< I >::
+cpExtensions::Algorithms::LightCompensationFilter< I >::
LightCompensationFilter( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< class I >
-cpPlugins::Extensions::Algorithms::LightCompensationFilter< I >::
+cpExtensions::Algorithms::LightCompensationFilter< I >::
~LightCompensationFilter( )
{
}
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::LightCompensationFilter< I >::
+void cpExtensions::Algorithms::LightCompensationFilter< I >::
BeforeThreadedGenerateData( )
{
this->Superclass::BeforeThreadedGenerateData( );
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::LightCompensationFilter< I >::
+void cpExtensions::Algorithms::LightCompensationFilter< I >::
ThreadedGenerateData( const TRegion& region, itk::ThreadIdType id )
{
typedef itk::NumericTraits< typename I::PixelType > _TPixelTraits;
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::LightCompensationFilter< I >::
+void cpExtensions::Algorithms::LightCompensationFilter< I >::
AfterThreadedGenerateData( )
{
this->Superclass::AfterThreadedGenerateData( );
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__LIGHTCOMPENSATIONFILTER__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
#include <set>
#include <itkImageToImageFilter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
FilterId m_FilterId;
};
- } // ecapseman
-
} // ecapseman
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/MultiScaleGaussianImageFilter.hxx>
+#include <cpExtensions/Algorithms/MultiScaleGaussianImageFilter.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
#include <vnl/vnl_vector.h>
// -------------------------------------------------------------------------
template< class I, class O >
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
_Greater( )
{
// -------------------------------------------------------------------------
template< class I, class O >
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
~_Greater( )
{
// -------------------------------------------------------------------------
template< class I, class O >
-bool cpPlugins::Extensions::Algorithms::
+bool cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
operator!=( const _Greater& b ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
-bool cpPlugins::Extensions::Algorithms::
+bool cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
operator==( const _Greater& b ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
-typename cpPlugins::Extensions::Algorithms::
+typename cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
-_T cpPlugins::Extensions::Algorithms::
+_T cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
operator()( const _T& a ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
-typename cpPlugins::Extensions::Algorithms::
+typename cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
-_T cpPlugins::Extensions::Algorithms::
+_T cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::_Greater::
operator()( const _T& a, const _T& b ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
SetFilterToGradient( )
{
// -------------------------------------------------------------------------
template< class I, class O >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
SetFilterToGradientMagnitude( )
{
// -------------------------------------------------------------------------
template< class I, class O >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
SetFilterToHessian( )
{
// -------------------------------------------------------------------------
template< class I, class O >
bool
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
IsGradientFilter( ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
bool
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
IsGradientMagnitudeFilter( ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
bool
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
IsHessianFilter( ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
AddScale( const double& s )
{
// -------------------------------------------------------------------------
template< class I, class O >
unsigned long
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
GetNumberOfScales( ) const
{
// -------------------------------------------------------------------------
template< class I, class O >
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
MultiScaleGaussianImageFilter( )
: Superclass( )
// -------------------------------------------------------------------------
template< class I, class O >
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
~MultiScaleGaussianImageFilter( )
{
// -------------------------------------------------------------------------
template< class I, class O >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
GenerateData( )
{
template< class I, class O >
template< class F >
void
-cpPlugins::Extensions::Algorithms::
+cpExtensions::Algorithms::
MultiScaleGaussianImageFilter< I, O >::
_GenerateData( )
{
} // rof
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__MULTISCALEGAUSSIANIMAGEFILTER__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
+#define __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
#include <itkDomainThreader.h>
#include <itkThreadedImageRegionPartitioner.h>
#include <itkArray.h>
#include <itkNumericTraits.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/ParallelImageMean.hxx>
+#include <cpExtensions/Algorithms/ParallelImageMean.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
#include <itkImageRegionConstIterator.h>
// -------------------------------------------------------------------------
template< class I >
-cpPlugins::Extensions::Algorithms::ParallelImageMean< I >::
+cpExtensions::Algorithms::ParallelImageMean< I >::
ParallelImageMean( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< class I >
-cpPlugins::Extensions::Algorithms::ParallelImageMean< I >::
+cpExtensions::Algorithms::ParallelImageMean< I >::
~ParallelImageMean( )
{
}
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::ParallelImageMean< I >::
+void cpExtensions::Algorithms::ParallelImageMean< I >::
BeforeThreadedExecution( )
{
this->m_Mean.SetSize( _TPixelTraits::GetLength( ) );
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::ParallelImageMean< I >::
+void cpExtensions::Algorithms::ParallelImageMean< I >::
ThreadedExecution( const DomainType& region, const itk::ThreadIdType id )
{
itk::ImageRegionConstIterator< I > i( this->m_Associate, region );
// -------------------------------------------------------------------------
template< class I >
-void cpPlugins::Extensions::Algorithms::ParallelImageMean< I >::
+void cpExtensions::Algorithms::ParallelImageMean< I >::
AfterThreadedExecution( )
{
this->m_Mean /= double( this->m_N );
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__PARALLELIMAGEMEAN__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
#include <cmath>
#include <limits>
#include <itkRGBPixel.h>
#include <itkVector.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBEXTRACTFUNCTION__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
+#define __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
#include <itkImageToImageFilter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Algorithms/RGBImageToOtherChannelsFilter.hxx>
+#include <cpExtensions/Algorithms/RGBImageToOtherChannelsFilter.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
+#define __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
#include <cmath>
#include <limits>
// -------------------------------------------------------------------------
template< class I, class O, class C >
-O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel1( )
{
return( this->GetOutput( 0 ) );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel2( )
{
return( this->GetOutput( 1 ) );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel3( )
{
return( this->GetOutput( 2 ) );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-const O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+const O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel1( ) const
{
if( this->GetNumberOfOutputs( ) > 0 )
// -------------------------------------------------------------------------
template< class I, class O, class C >
-const O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+const O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel2( ) const
{
if( this->GetNumberOfOutputs( ) > 1 )
// -------------------------------------------------------------------------
template< class I, class O, class C >
-const O*
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+const O* cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GetChannel3( ) const
{
if( this->GetNumberOfOutputs( ) > 2 )
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GraftChannel1( O* hue )
{
this->GraftNthOutput( 0, hue );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GraftChannel2( O* saturation )
{
this->GraftNthOutput( 1, saturation );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
GraftChannel3( O* value )
{
this->GraftNthOutput( 2, value );
// -------------------------------------------------------------------------
template< class I, class O, class C >
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
RGBImageToOtherChannelsFilter( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< class I, class O, class C >
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
~RGBImageToOtherChannelsFilter( )
{
}
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
BeforeThreadedGenerateData( )
{
}
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
AfterThreadedGenerateData( )
{
}
// -------------------------------------------------------------------------
template< class I, class O, class C >
-void
-cpPlugins::Extensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
+void cpExtensions::Algorithms::RGBImageToOtherChannelsFilter< I, O, C >::
ThreadedGenerateData(
const typename Superclass::OutputImageRegionType& region,
itk::ThreadIdType threadId
} // rof
}
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBIMAGETOOTHERCHANNELSFILTER__HXX__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
#include <cmath>
#include <limits>
#include <itkRGBPixel.h>
#include <itkVector.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
}
};
- } // ecapseman
-
} // ecapseman
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBTOHSVFUNCTION__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
#include <itkRGBPixel.h>
#include <itkMatrix.h>
#include <itkVector.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBTORGBFUNCTION__H__
// eof - $RCSfile$
// @author Leonardo Florez-Valencia (florez-l@javeriana.edu.co)
// -------------------------------------------------------------------------
-#ifndef __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
-#define __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
+#ifndef __CPEXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
+#define __CPEXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
#include <cmath>
#include <limits>
#include <itkMatrix.h>
#include <itkVector.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Algorithms
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
+#endif // __CPEXTENSIONS__ALGORITHMS__RGBTOYPBPRFUNCTION__H__
// eof - $RCSfile$
-SET(LIBRARY_NAME cpPlugins_Extensions)
+SET(LIBRARY_NAME cpExtensions)
## ===============
## = Source code =
${LIBRARY_NAME}
BASE_NAME ${LIBRARY_NAME}
EXPORT_MACRO_NAME ${LIBRARY_NAME}_EXPORT
- EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/lib/cpPlugins/Extensions/${LIBRARY_NAME}_Export.h
+ EXPORT_FILE_NAME ${PROJECT_BINARY_DIR}/lib/cpExtensions/${LIBRARY_NAME}_Export.h
STATIC_DEFINE ${LIBRARY_NAME}_BUILT_AS_STATIC
)
TARGET_LINK_LIBRARIES(
FOREACH(dir ${local_install_dirs})
INSTALL(
DIRECTORY ${dir}
- DESTINATION include/cpPlugins/Extensions
+ DESTINATION include/cpExtensions
FILES_MATCHING PATTERN "*.h"
)
INSTALL(
DIRECTORY ${dir}
- DESTINATION include/cpPlugins/Extensions
+ DESTINATION include/cpExtensions
FILES_MATCHING PATTERN "*.hxx"
)
INSTALL(
DIRECTORY ${dir}
- DESTINATION include/cpPlugins/Extensions
+ DESTINATION include/cpExtensions
FILES_MATCHING PATTERN "*.hpp"
)
ENDFOREACH(dir)
INSTALL(
FILES
- ${PROJECT_BINARY_DIR}/lib/cpPlugins/Extensions/${LIBRARY_NAME}_Export.h
- DESTINATION include/cpPlugins/Extensions
+ ${PROJECT_BINARY_DIR}/lib/cpExtensions/${LIBRARY_NAME}_Export.h
+ DESTINATION include/cpExtensions
)
## eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
+#define __CPEXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
#include <itkImage.h>
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
#include <itkImageToVTKImageFilter.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace DataStructures
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__ITKANDVTKIMAGE__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
#include <itkLightObject.h>
-#include <cpPlugins/Extensions/DataStructures/QuadEdgeIterators.h>
+#include <cpExtensions/DataStructures/QuadEdgeIterators.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace DataStructures
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/DataStructures/QuadEdge.hxx>
+#include <cpExtensions/DataStructures/QuadEdge.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
#include <limits>
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-const typename cpPlugins::Extensions::DataStructures::
+const typename cpExtensions::DataStructures::
QuadEdge< P, D, IsPrimal >::TPrimalGeometry
-cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
NoGeometry = std::numeric_limits< P >::max( );
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-void cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+void cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
CreateRings( )
{
TPrimal* e = this;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-void cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+void cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
SetLnextRingGeometry( const D& v )
{
for( Iterator i = this->BeginLnext( ); i != this->EndLnext( ); ++i )
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-void cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+void cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
UnsetLnextRingGeometry( )
{
this->SetLnextRingGeometry( TDual::NoGeometry );
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-bool cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+bool cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
IsEdgeInOnextRing( const TPrimal* e ) const
{
bool found = false;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-bool cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+bool cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
IsEdgeInLnextRing( const TPrimal* e ) const
{
bool found = false;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
unsigned int
-cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
GetOnextRingSize( ) const
{
unsigned int count = 0;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
unsigned int
-cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
GetLnextRingSize( ) const
{
unsigned int count = 0;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-bool cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+bool cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
IsAtBorder( ) const
{
return(
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-bool cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+bool cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
IsOriginInternal( ) const
{
bool internal = true;
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-typename cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
-TPrimal* cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+typename cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+TPrimal* cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
GetNextBorderEdgeWithUnsetLeft( TPrimal* edge ) const
{
// Be sure the Onext ring isn't already full
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-bool cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+bool cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
ReorderOnextRing( TPrimal* first, TPrimal* second )
{
// Making sure point adjacency is correct:
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-void cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+void cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
Splice( TPrimal* a, TPrimal* b )
{
// Don't waste time splicing the same edge (or non-existent)
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
QuadEdge( )
: m_Origin( Self::NoGeometry )
{
// -------------------------------------------------------------------------
template< typename P, typename D, bool IsPrimal >
-cpPlugins::Extensions::DataStructures::QuadEdge< P, D, IsPrimal >::
+cpExtensions::DataStructures::QuadEdge< P, D, IsPrimal >::
~QuadEdge( )
{
}
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGE__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
#include <vector>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace DataStructures
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/DataStructures/QuadEdgeCell.hxx>
+#include <cpExtensions/DataStructures/QuadEdgeCell.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
// -------------------------------------------------------------------------
template< class I, class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+cpExtensions::DataStructures::QuadEdgeCell< I, E >::
QuadEdgeCell( )
: Superclass( ),
m_EntryEdge( NULL )
// -------------------------------------------------------------------------
template< class I, class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+cpExtensions::DataStructures::QuadEdgeCell< I, E >::
QuadEdgeCell( E* entry )
: Superclass( ),
m_EntryEdge( entry )
// -------------------------------------------------------------------------
template< class I, class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+cpExtensions::DataStructures::QuadEdgeCell< I, E >::
~QuadEdgeCell( )
{
}
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
-CellGeometry cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
+CellGeometry cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetType( ) const
{
std::cout << "QuadEdgeCell GetType" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
MakeCopy( CellAutoPointer& other ) const
{
std::cout << "QuadEdgeCell MakeCopy" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-unsigned int cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+unsigned int cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetDimension( ) const
{
std::cout << "QuadEdgeCell GetDimension" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-unsigned int cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+unsigned int cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetNumberOfPoints( ) const
{
return( this->m_EntryEdge->GetLnextRingSize( ) );
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
-CellFeatureCount cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
+CellFeatureCount cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetNumberOfBoundaryFeatures( int dimension ) const
{
std::cout << "QuadEdgeCell GetNumberOfBoundaryFeatures" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+bool cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetBoundaryFeature(
int dimension,
CellFeatureIdentifier fId,
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
SetPointIds( PointIdConstIterator first )
{
std::cout << "QuadEdgeCell SetPointIds" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
SetPointIds(
PointIdConstIterator first,
PointIdConstIterator last
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
AddPointId( PointIdentifier pId )
{
std::cout << "QuadEdgeCell AddPointId" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
RemovePointId( PointIdentifier pId )
{
std::cout << "QuadEdgeCell RemovePointId" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
SetPointIds(
int dummy,
int num,
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
BuildEdges( )
{
std::cout << "QuadEdgeCell BuildEdges" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
ClearPoints( )
{
std::cout << "QuadEdgeCell ClearPoints" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
SetPointId( int localId, PointIdentifier pId )
{
std::cout << "QuadEdgeCell SetPointId(localId,pId)" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-int cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+int cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetTopologyId( )
{
// TODO: return( Superclass::POLYGON_CELL );
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
Accept(
CellIdentifier cellid,
typename itk::CellInterface< PixelType, CellTraits >::MultiVisitor* mv
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
-PointIdIterator cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
+PointIdIterator cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdsBegin( )
{
std::cout << "QuadEdgeCell PointIdsBegin" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdConstIterator
-cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdsBegin( ) const
{
std::cout << "QuadEdgeCell PointIdsBegin (const)" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
-PointIdIterator cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
+PointIdIterator cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdsEnd( )
{
std::cout << "QuadEdgeCell PointIdsEnd" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+typename cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdConstIterator
-cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+cpExtensions::DataStructures::QuadEdgeCell< I, E >::
PointIdsEnd( ) const
{
std::cout << "QuadEdgeCell PointIdsEnd (const)" << std::endl;
// -------------------------------------------------------------------------
template< class I, class E >
-E* cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+E* cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetEntryPrimalEdge( )
{
return( this->m_EntryEdge );
// -------------------------------------------------------------------------
template< class I, class E >
-const E* cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+const E* cpExtensions::DataStructures::QuadEdgeCell< I, E >::
GetEntryPrimalEdge( ) const
{
return( this->m_EntryEdge );
// -------------------------------------------------------------------------
template< class I, class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeCell< I, E >::
+void cpExtensions::DataStructures::QuadEdgeCell< I, E >::
SetEntryPrimalEdge( E* entry )
{
this->m_EntryEdge = entry;
}
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGECELL__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
#include <cstdlib>
cpPluginsQEIteratorsMacro( op, Iterator, ConstIterator ); \
cpPluginsExtensionsQEPointIteratorsMacro( op, Iterator, ConstIterator );
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace DataStructures
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/DataStructures/QuadEdgeIterators.hxx>
+#include <cpExtensions/DataStructures/QuadEdgeIterators.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
QuadEdgeBaseIterator( E* e, int op, bool start )
: m_StartEdge( e ),
m_Iterator( e ),
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
~QuadEdgeBaseIterator( )
{
}
// -------------------------------------------------------------------------
template< class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
-Self& cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+typename cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
+Self& cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator=( const Self& r )
{
if( this != &r )
// -------------------------------------------------------------------------
template< class E >
-E* cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+E* cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
GetStartEdge( ) const
{
return( this->m_StartEdge );
// -------------------------------------------------------------------------
template< class E >
-E* cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+E* cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
GetIterator( ) const
{
return( this->m_Iterator );
// -------------------------------------------------------------------------
template< class E >
-int cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+int cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
GetOpType( ) const
{
return( this->m_OpType );
// -------------------------------------------------------------------------
template< class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+bool cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
GetStart( ) const
{
return( this->m_Start );
// -------------------------------------------------------------------------
template< class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+bool cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator==( Self& r )
{
return(
// -------------------------------------------------------------------------
template< class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+bool cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator==( const Self& r ) const
{
return(
// -------------------------------------------------------------------------
template< class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+bool cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator!=( Self& r )
{
return( !( this->operator==( r ) ) );
// -------------------------------------------------------------------------
template< class E >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+bool cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator!=( const Self& r ) const
{
return( !( this->operator==( r ) ) );
// -------------------------------------------------------------------------
template< class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
-Self& cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+typename cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
+Self& cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator++( )
{
if( this->m_Start )
// -------------------------------------------------------------------------
template< class E >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
-Self& cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+typename cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
+Self& cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
operator++( int )
{
if( this->m_Start )
// -------------------------------------------------------------------------
template< class E >
-void cpPlugins::Extensions::DataStructures::QuadEdgeBaseIterator< E >::
+void cpExtensions::DataStructures::QuadEdgeBaseIterator< E >::
_GoToNext( )
{
switch( this->m_OpType )
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeIterator< E >::
+cpExtensions::DataStructures::QuadEdgeIterator< E >::
QuadEdgeIterator( E* e, int op, bool start )
: Superclass( e, op, start )
{
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeIterator< E >::
+cpExtensions::DataStructures::QuadEdgeIterator< E >::
~QuadEdgeIterator( )
{
}
// -------------------------------------------------------------------------
template< class E >
-E* cpPlugins::Extensions::DataStructures::QuadEdgeIterator< E >::
+E* cpExtensions::DataStructures::QuadEdgeIterator< E >::
operator*( )
{
return( this->m_Iterator );
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeConstIterator< E >::
+cpExtensions::DataStructures::QuadEdgeConstIterator< E >::
QuadEdgeConstIterator( const E* e, int op, bool start )
: Superclass( e, op, start )
{
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgeConstIterator< E >::
+cpExtensions::DataStructures::QuadEdgeConstIterator< E >::
~QuadEdgeConstIterator( )
{
}
// -------------------------------------------------------------------------
template< class E >
-const E* cpPlugins::Extensions::DataStructures::QuadEdgeConstIterator< E >::
+const E* cpExtensions::DataStructures::QuadEdgeConstIterator< E >::
operator*( ) const
{
return( this->m_Iterator );
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgePointIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointIterator< E >::
QuadEdgePointIterator( const E* e, int op, bool start )
: Superclass( e, op, start )
{
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgePointIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointIterator< E >::
~QuadEdgePointIterator( )
{
}
// -------------------------------------------------------------------------
template< class E >
typename E::TPrimalGeometry&
-cpPlugins::Extensions::DataStructures::QuadEdgePointIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointIterator< E >::
operator*( )
{
return( this->m_Iterator->GetOrigin( ) );
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgePointConstIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointConstIterator< E >::
QuadEdgePointConstIterator( const E* e, int op, bool start )
: Superclass( e, op, start )
{
// -------------------------------------------------------------------------
template< class E >
-cpPlugins::Extensions::DataStructures::QuadEdgePointConstIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointConstIterator< E >::
~QuadEdgePointConstIterator( )
{
}
// -------------------------------------------------------------------------
template< class E >
const typename E::TPrimalGeometry&
-cpPlugins::Extensions::DataStructures::QuadEdgePointConstIterator< E >::
+cpExtensions::DataStructures::QuadEdgePointConstIterator< E >::
operator*( ) const
{
return( this->m_Iterator->GetOrigin( ) );
}
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEITERATORS__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
#include <set>
#include <vector>
#include <itkMesh.h>
-#include <cpPlugins/Extensions/DataStructures/QuadEdgeCell.h>
-#include <cpPlugins/Extensions/DataStructures/QuadEdge.h>
+#include <cpExtensions/DataStructures/QuadEdgeCell.h>
+#include <cpExtensions/DataStructures/QuadEdge.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace DataStructures
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/DataStructures/QuadEdgeMesh.hxx>
+#include <cpExtensions/DataStructures/QuadEdgeMesh.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
-#define __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
+#ifndef __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
+#define __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-TPrimalEdge* cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+TPrimalEdge* cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
FindEdge( const PointIdentifier& a ) const
{
if( a < this->m_OnextRings.size( ) )
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-TPrimalEdge* cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+TPrimalEdge* cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
FindEdge( const PointIdentifier& a, const PointIdentifier& b ) const
{
TPrimalEdge* found = NULL;
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-TPrimalEdge* cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+TPrimalEdge* cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
FindEntryEdge( const CellIdentifier& i ) const
{
if( i < this->GetNumberOfCells( ) )
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-const typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-CntNormals& cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+const typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+CntNormals& cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
GetPointNormalsContainer( ) const
{
return( this->m_PointNormals );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-NormalsIterator cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+NormalsIterator cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
BeginPointNormals( ) const
{
return( this->m_PointNormals.begin( ) );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-NormalsIterator cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+NormalsIterator cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
EndPointNormals( ) const
{
return( this->m_PointNormals.end( ) );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-const typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-VectorType& cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+const typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+VectorType& cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
GetPointNormal( const PointIdentifier& id ) const
{
static const VectorType zero( TScalar( 0 ) );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+bool cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
RequestedRegionIsOutsideOfTheBufferedRegion( )
{
// Mesh regions don't have meaning with QuadEdges, this is important
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetPoints( PointsContainer* points )
{
this->_ReleaseQuadEdgeObjects( );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetPoint( PointIdentifier id , PointType point )
{
// If the point is brand new, add some non-existent edges and normals
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
Initialize( )
{
this->Superclass::Initialize( );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
Graft( const itk::DataObject* data )
{
this->Superclass::Graft( data );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetCells( CellsContainer* cells )
{
// Clear cells
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetCellData( CellDataContainer* data )
{
/* TODO
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetCell( CellIdentifier id, CellAutoPointer& ptr )
{
// Overwrite an existing cell?
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
SetCellData( CellIdentifier id, CellPixelType data )
{
/* TODO
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
BuildCellLinks( ) const
{
// This is no longer required when using QuadEdges
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
QuadEdgeMesh( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
~QuadEdgeMesh( )
{
this->_ReleaseQuadEdgeObjects( );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-bool cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+bool cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_CheckPoints( const CellAutoPointer& ptr ) const
{
const typename Superclass::PointsContainer* pnts = this->GetPoints( );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_DeletePoint( const PointIdentifier& pId )
{
PointIdentifier lastId = this->GetNumberOfPoints( ) - 1;
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-TPrimalEdge* cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+TPrimalEdge* cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_CreateQuadEdge( const PointIdentifier& a, const PointIdentifier& b )
{
// Create brand new object
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_DeleteEdge( TPrimalEdge* edge )
{
this->m_DualEdges.erase( edge->GetInvRot( ) );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_DeleteFace( const CellIdentifier& f )
{
unsigned long cellId = this->GetNumberOfCells( ) - 1;
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_ConstructEdges( _TEdges& edges, const CellAutoPointer& ptr )
{
edges.clear( );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-typename cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
-VectorType cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+typename cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
+VectorType cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_ComputePointNormal( const TPrimalEdge* e ) const
{
VectorType n( TScalar( 0 ) );
// -------------------------------------------------------------------------
template< typename P, unsigned int D, typename T >
-void cpPlugins::Extensions::DataStructures::QuadEdgeMesh< P, D, T >::
+void cpExtensions::DataStructures::QuadEdgeMesh< P, D, T >::
_ReleaseQuadEdgeObjects( )
{
this->m_PrimalEdges.clear( );
this->m_PointNormals.clear( );
}
-#endif // __CPPLUGINS__EXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
+#endif // __CPEXTENSIONS__DATASTRUCTURES__QUADEDGEMESH__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__IO__MESHREADER__H__
-#define __CPPLUGINS__EXTENSIONS__IO__MESHREADER__H__
+#ifndef __CPEXTENSIONS__IO__MESHREADER__H__
+#define __CPEXTENSIONS__IO__MESHREADER__H__
#include <string>
#include <itkMeshSource.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace IO
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/IO/MeshReader.hxx>
+#include <cpExtensions/IO/MeshReader.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__IO__MESHREADER__H__
+#endif // __CPEXTENSIONS__IO__MESHREADER__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__IO__MESHREADER__HXX__
-#define __CPPLUGINS__EXTENSIONS__IO__MESHREADER__HXX__
+#ifndef __CPEXTENSIONS__IO__MESHREADER__HXX__
+#define __CPEXTENSIONS__IO__MESHREADER__HXX__
#include <algorithm>
-#include <cpPlugins/Extensions/IO/WaveFrontOBJReader.h>
+#include <cpExtensions/IO/WaveFrontOBJReader.h>
#include <itkVTKPolyDataReader.h>
// -------------------------------------------------------------------------
template< typename M >
-itk::ModifiedTimeType cpPlugins::Extensions::IO::MeshReader< M >::
+itk::ModifiedTimeType cpExtensions::IO::MeshReader< M >::
GetMTime( ) const
{
itk::ModifiedTimeType mtime = this->Superclass::GetMTime( );
// -------------------------------------------------------------------------
template< typename M >
-cpPlugins::Extensions::IO::MeshReader< M >::
+cpExtensions::IO::MeshReader< M >::
MeshReader( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename M >
-cpPlugins::Extensions::IO::MeshReader< M >::
+cpExtensions::IO::MeshReader< M >::
~MeshReader( )
{
}
// -------------------------------------------------------------------------
template< typename M >
-void cpPlugins::Extensions::IO::MeshReader< M >::
+void cpExtensions::IO::MeshReader< M >::
GenerateData( )
{
std::string fn = this->m_FileName;
if( fn.rfind( ".vtk" ) != std::string::npos )
this->_Read< itk::VTKPolyDataReader< M > >( );
else if( fn.rfind( ".obj" ) != std::string::npos )
- this->_Read< cpPlugins::Extensions::IO::WaveFrontOBJReader< M > >( );
+ this->_Read< cpExtensions::IO::WaveFrontOBJReader< M > >( );
}
// -------------------------------------------------------------------------
template< typename M >
template< class R >
-void cpPlugins::Extensions::IO::MeshReader< M >::
+void cpExtensions::IO::MeshReader< M >::
_Read( )
{
typename R::Pointer reader = NULL;
} // fi
}
-#endif // __CPPLUGINS__EXTENSIONS__IO__MESHREADER__HXX__
+#endif // __CPEXTENSIONS__IO__MESHREADER__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__H__
-#define __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__H__
+#ifndef __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__H__
+#define __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__H__
#include <string>
#include <itkIntTypes.h>
#include <itkMeshSource.h>
#include <itkPolygonCell.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace IO
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/IO/WaveFrontOBJReader.hxx>
+#include <cpExtensions/IO/WaveFrontOBJReader.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__H__
+#endif // __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
-#define __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
+#ifndef __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
+#define __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
#include <cstdlib>
#include <fstream>
// -------------------------------------------------------------------------
template< typename M >
-cpPlugins::Extensions::IO::WaveFrontOBJReader< M >::
+cpExtensions::IO::WaveFrontOBJReader< M >::
WaveFrontOBJReader( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< typename M >
-cpPlugins::Extensions::IO::WaveFrontOBJReader< M >::
+cpExtensions::IO::WaveFrontOBJReader< M >::
~WaveFrontOBJReader( )
{
}
// -------------------------------------------------------------------------
template< typename M >
-void cpPlugins::Extensions::IO::WaveFrontOBJReader< M >::
+void cpExtensions::IO::WaveFrontOBJReader< M >::
GenerateData( )
{
typedef typename PointType::ValueType TScalar;
in.close( );
}
-#endif // __CPPLUGINS__EXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
+#endif // __CPEXTENSIONS__IO__WAVEFRONTOBJREADER__HXX__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/Image3DMPR.h>
+#include <cpExtensions/Visualization/Image3DMPR.h>
#include <vtkCommand.h>
#include <vtkInteractorStyleSwitch.h>
-#include <cpPlugins/Extensions/Visualization/SeedWidgetCorrector.h>
+#include <cpExtensions/Visualization/SeedWidgetCorrector.h>
/**
*/
};
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::Image3DMPR::
+cpExtensions::Visualization::Image3DMPR::
Image3DMPR( )
{
this->m_Outline = vtkSmartPointer< vtkOutlineSource >::New( );
this->m_Interactor->AddObserver( vtkCommand::KeyPressEvent, int_cb );
typedef
- cpPlugins::Extensions::Visualization::SeedWidgetCorrector
+ cpExtensions::Visualization::SeedWidgetCorrector
_TCorrector;
vtkSmartPointer< _TCorrector > corr_cb =
vtkSmartPointer< _TCorrector >::New( );
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::Image3DMPR::
+cpExtensions::Visualization::Image3DMPR::
~Image3DMPR( )
{
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
SetImage( vtkImageData* image )
{
this->m_Image = image;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
SetBackground( double r, double g, double b )
{
this->m_Renderer->SetBackground( r, g, b );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
SetSize( unsigned int w, unsigned int h )
{
this->m_Window->SetSize( w, h );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
SetWindowLevel( double w, double l )
{
this->m_WidgetX->SetWindowLevel( w, l );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
AddPolyData( vtkPolyData* pd, double opacity )
{
unsigned int i = this->m_PolyDatas.size( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
AddPolyData( vtkPolyData* pd, double r, double g, double b, double opacity )
{
unsigned int i = this->m_PolyDatas.size( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
AddPolyData( vtkPolyData* pd, vtkLookupTable* lut, double opacity )
{
unsigned int i = this->m_PolyDatas.size( );
}
// -------------------------------------------------------------------------
-unsigned int cpPlugins::Extensions::Visualization::Image3DMPR::
+unsigned int cpExtensions::Visualization::Image3DMPR::
GetNumberOfSeeds( ) const
{
return( this->m_SeedRepresentation->GetNumberOfSeeds( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
GetSeed( int n, double* s ) const
{
vtkHandleWidget* hWdg = this->m_SeedWidget->GetSeed( n );
}
// -------------------------------------------------------------------------
-unsigned int cpPlugins::Extensions::Visualization::Image3DMPR::
+unsigned int cpExtensions::Visualization::Image3DMPR::
AddSeed( const double& x, const double& y, const double& z ) const
{
double pos[ 3 ] = { x, y, z };
}
// -------------------------------------------------------------------------
-vtkRenderWindow* cpPlugins::Extensions::Visualization::Image3DMPR::
+vtkRenderWindow* cpExtensions::Visualization::Image3DMPR::
GetWindow( ) const
{
return( this->m_Window );
}
// -------------------------------------------------------------------------
-vtkRenderer* cpPlugins::Extensions::Visualization::Image3DMPR::
+vtkRenderer* cpExtensions::Visualization::Image3DMPR::
GetRenderer( ) const
{
return( this->m_Renderer );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
Start( )
{
this->m_WidgetX->On( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::Image3DMPR::
+void cpExtensions::Visualization::Image3DMPR::
Render( )
{
this->m_Window->Render( );
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
+#define __CPEXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/cpExtensions_Export.h>
#include <vtkActor.h>
#include <vtkCellPicker.h>
#include <vtkSphereSource.h>
#include <vtkLookupTable.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT Image3DMPR
+ class cpExtensions_EXPORT Image3DMPR
{
public:
Image3DMPR( );
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__IMAGE3DMPR__H__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/ImageInteractorStyle.h>
+#include <cpExtensions/Visualization/ImageInteractorStyle.h>
#include <cmath>
#include <ctime>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
-#include <cpPlugins/Extensions/Visualization/ImageSliceActors.h>
-#include <cpPlugins/Extensions/Visualization/MPRActors.h>
+#include <cpExtensions/Visualization/ImageSliceActors.h>
+#include <cpExtensions/Visualization/MPRActors.h>
// -------------------------------------------------------------------------
-const int cpPlugins::Extensions::Visualization::
+const int cpExtensions::Visualization::
ImageInteractorStyle::CursorEvent = vtkCommand::UserEvent + 1;
-const int cpPlugins::Extensions::Visualization::
+const int cpExtensions::Visualization::
ImageInteractorStyle::RadiusEvent = vtkCommand::UserEvent + 2;
-const int cpPlugins::Extensions::Visualization::
+const int cpExtensions::Visualization::
ImageInteractorStyle::DoubleClickEvent = vtkCommand::UserEvent + 3;
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageInteractorStyle::
-Self* cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+cpExtensions::Visualization::ImageInteractorStyle::
+Self* cpExtensions::Visualization::ImageInteractorStyle::
New( )
{
return( new Self( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
Configure( ImageSliceActors* slice_actors, MPRActors* mpr_actors )
{
this->m_SliceActors = slice_actors;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
AssociateInteractor( vtkRenderWindowInteractor* interactor )
{
if( interactor != NULL )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
SetModeToNavigation( )
{
this->Mode = Self::NavigationMode;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
SetModeToDeformation( )
{
this->Mode = Self::DeformationMode;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
SetInteractor( vtkRenderWindowInteractor* interactor, const int& axis )
{
this->Superclass::SetInteractor( interactor );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnMouseMove( )
{
if( this->m_MPRActors == NULL )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnLeftButtonDown( )
{
static double pnt[ 3 ];
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnLeftButtonUp( )
{
if( this->CursorMoving )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnMiddleButtonDown( )
{
int x = this->Interactor->GetEventPosition( )[ 0 ];
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnMiddleButtonUp( )
{
if( this->RadiusMoving )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnRightButtonDown( )
{
int x = this->Interactor->GetEventPosition( )[ 0 ];
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnRightButtonUp( )
{
switch( this->State )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnMouseWheelForward( )
{
if( this->m_SliceActors == NULL || this->Interactor == NULL )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnMouseWheelBackward( )
{
if( this->m_SliceActors == NULL || this->Interactor == NULL )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
OnChar( )
{
switch( this->Interactor->GetKeyCode( ) )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
WindowLevel( )
{
if( this->Mode == Self::NavigationMode )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
StartWindowLevel( )
{
if( this->State != VTKIS_NONE )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
EndWindowLevel( )
{
if( this->Mode == Self::NavigationMode )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
StartCursorMoving( )
{
if( this->CursorMoving )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
EndCursorMoving( )
{
if( !( this->CursorMoving ) )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
StartRadiusMoving( )
{
if( this->RadiusMoving )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
EndRadiusMoving( )
{
if( !( this->RadiusMoving ) )
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+cpExtensions::Visualization::ImageInteractorStyle::
ImageInteractorStyle( )
: Superclass( ),
Mode( Self::NavigationMode ),
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+cpExtensions::Visualization::ImageInteractorStyle::
~ImageInteractorStyle( )
{
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
_RenderAssociateInteractors( )
{
std::vector< vtkRenderWindowInteractor* >::iterator rIt =
}
// -------------------------------------------------------------------------
-bool cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+bool cpExtensions::Visualization::ImageInteractorStyle::
_PickPosition( double pos[ 3 ] )
{
if( this->m_SliceActors == NULL )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
_UpdateCursor( )
{
std::cout << "upcur" << std::endl;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageInteractorStyle::
+void cpExtensions::Visualization::ImageInteractorStyle::
_UpdateRadius( )
{
vtkRenderer* ren =
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
+#define __CPEXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
#include <vector>
#include <vtkPropPicker.h>
#include <vtkSmartPointer.h>
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/cpExtensions_Export.h>
// -------------------------------------------------------------------------
#define cpPlugins_ImageInteractorStyle_ObserverMacro( e ) \
inline void Remove##e##Observers( ) \
{ this->RemoveObservers( Self::e##Event ); }
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT ImageInteractorStyle
+ class cpExtensions_EXPORT ImageInteractorStyle
: public vtkInteractorStyleImage
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__IMAGEINTERACTORSTYLE__H__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/ImageSliceActors.h>
+#include <cpExtensions/Visualization/ImageSliceActors.h>
#include <vtkAlgorithmOutput.h>
#include <vtkCellArray.h>
#include <vtkTextProperty.h>
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageSliceActors*
-cpPlugins::Extensions::Visualization::ImageSliceActors::
+cpExtensions::Visualization::ImageSliceActors*
+cpExtensions::Visualization::ImageSliceActors::
New( )
{
return( new Self( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageSliceActors::
+void cpExtensions::Visualization::ImageSliceActors::
SetInputConnection( vtkAlgorithmOutput* aout, int axis )
{
this->SliceMapper->SetInputConnection( aout );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageSliceActors::
+void cpExtensions::Visualization::ImageSliceActors::
SetInputData( vtkImageData* data, int axis )
{
this->SliceMapper->SetInputData( data );
}
// -------------------------------------------------------------------------
-double* cpPlugins::Extensions::Visualization::ImageSliceActors::
+double* cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( ) const
{
return( this->ImageActor->GetDisplayBounds( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageSliceActors::
+void cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( double bounds[ 6 ] ) const
{
this->ImageActor->GetDisplayBounds( bounds );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::ImageSliceActors::
+int cpExtensions::Visualization::ImageSliceActors::
GetAxis( ) const
{
return( this->SliceMapper->GetOrientation( ) );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::ImageSliceActors::
+int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumber( ) const
{
return( this->SliceMapper->GetSliceNumber( ) );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::ImageSliceActors::
+int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumberMinValue( ) const
{
return( this->SliceMapper->GetSliceNumberMinValue( ) );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::ImageSliceActors::
+int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumberMaxValue( ) const
{
return( this->SliceMapper->GetSliceNumberMaxValue( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageSliceActors::
+void cpExtensions::Visualization::ImageSliceActors::
SetSliceNumber( const int& slice )
{
this->SliceMapper->SetSliceNumber( slice );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::ImageSliceActors::
+void cpExtensions::Visualization::ImageSliceActors::
UpdateText( )
{
char axis;
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageSliceActors::
+cpExtensions::Visualization::ImageSliceActors::
ImageSliceActors( )
: Superclass( )
{
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::ImageSliceActors::
+cpExtensions::Visualization::ImageSliceActors::
~ImageSliceActors( )
{
}
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
+#define __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/cpExtensions_Export.h>
#include <vtkActor.h>
#include <vtkImageActor.h>
class vtkImageData;
// -------------------------------------------------------------------------
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT ImageSliceActors
+ class cpExtensions_EXPORT ImageSliceActors
: public vtkPropCollection
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__IMAGESLICEACTORS__H__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/MPRActors.h>
+#include <cpExtensions/Visualization/MPRActors.h>
#include <vtkImageData.h>
#include <vtkInformation.h>
#include <vtkWindowLevelLookupTable.h>
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::MPRActors*
-cpPlugins::Extensions::Visualization::MPRActors::
+cpExtensions::Visualization::MPRActors*
+cpExtensions::Visualization::MPRActors::
New( )
{
return( new Self( ) );
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::
-ImageSliceActors* cpPlugins::Extensions::Visualization::MPRActors::
+cpExtensions::Visualization::
+ImageSliceActors* cpExtensions::Visualization::MPRActors::
GetSliceActors( const int& i ) const
{
if( i < 3 )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetInputConnection( vtkAlgorithmOutput* aout )
{
this->ImageMapToColors->SetInputConnection( aout );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetInputData( vtkImageData* image )
{
this->ImageMapToColors->SetInputData( image );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
PushDataInto( vtkRenderer* x, vtkRenderer* y, vtkRenderer* z, vtkRenderer* w )
{
vtkRenderer* rends[] = { x, y, z };
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
PopDataFrom( vtkRenderer* x, vtkRenderer* y, vtkRenderer* z, vtkRenderer* w )
{
vtkRenderer* rends[] = { x, y, z };
}
// -------------------------------------------------------------------------
-vtkScalarsToColors* cpPlugins::Extensions::Visualization::MPRActors::
+vtkScalarsToColors* cpExtensions::Visualization::MPRActors::
GetLookupTable( ) const
{
return( this->ImageMapToColors->GetLookupTable( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetLookupTable( vtkScalarsToColors* lut )
{
this->ImageMapToColors->SetLookupTable( lut );
}
// -------------------------------------------------------------------------
-vtkWindowLevelLookupTable* cpPlugins::Extensions::Visualization::MPRActors::
+vtkWindowLevelLookupTable* cpExtensions::Visualization::MPRActors::
GetLookupTableAsWindowLevel( ) const
{
return(
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetLookupTableToWindowLevel( )
{
// Check if the input has been configured
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetMinWindow( ) const
{
return( double( 0 ) );
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetMaxWindow( ) const
{
// Check if the input has been configured
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetMinLevel( ) const
{
// Check if the input has been configured
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetMaxLevel( ) const
{
// Check if the input has been configured
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetWindow( ) const
{
vtkWindowLevelLookupTable* lut = this->GetLookupTableAsWindowLevel( );
}
// -------------------------------------------------------------------------
-double cpPlugins::Extensions::Visualization::MPRActors::
+double cpExtensions::Visualization::MPRActors::
GetLevel( ) const
{
vtkWindowLevelLookupTable* lut = this->GetLookupTableAsWindowLevel( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetWindow( const double& w )
{
vtkWindowLevelLookupTable* lut = this->GetLookupTableAsWindowLevel( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetLevel( const double& l )
{
vtkWindowLevelLookupTable* lut = this->GetLookupTableAsWindowLevel( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetWindowLevel( const double& w, const double& l )
{
vtkWindowLevelLookupTable* lut = this->GetLookupTableAsWindowLevel( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
ResetWindowLevel( )
{
vtkImageData* image = this->_InputImage( );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::MPRActors::
+int cpExtensions::Visualization::MPRActors::
GetSliceNumberMinValue( const int& axis ) const
{
return( this->Slices[ axis ]->GetSliceNumberMinValue( ) );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::MPRActors::
+int cpExtensions::Visualization::MPRActors::
GetSliceNumberMaxValue( const int& axis ) const
{
return( this->Slices[ axis ]->GetSliceNumberMaxValue( ) );
}
// -------------------------------------------------------------------------
-int cpPlugins::Extensions::Visualization::MPRActors::
+int cpExtensions::Visualization::MPRActors::
GetSlice( const int& axis ) const
{
return( this->Slices[ axis ]->GetSliceNumber( ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetSlice( const int& axis, const int& slice )
{
vtkImageData* image = this->_InputImage( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
SetSlice( const int& axis, const double& slice )
{
vtkImageData* image = this->_InputImage( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
ResetSlices( )
{
// TODO
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
GetImageBounds( double bounds[ 6 ] ) const
{
vtkImageData* image = this->_InputImage( );
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::MPRActors::
+cpExtensions::Visualization::MPRActors::
MPRActors( )
: Superclass( )
{
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::MPRActors::
+cpExtensions::Visualization::MPRActors::
~MPRActors( )
{
}
// -------------------------------------------------------------------------
-vtkImageData* cpPlugins::Extensions::Visualization::MPRActors::
+vtkImageData* cpExtensions::Visualization::MPRActors::
_InputImage( ) const
{
vtkAlgorithm* algo = this->ImageMapToColors->GetInputAlgorithm( );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRActors::
+void cpExtensions::Visualization::MPRActors::
_UpdateSlices( )
{
// Check if the input has been configured
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRACTORS__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRACTORS__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__MPRACTORS__H__
+#define __CPEXTENSIONS__VISUALIZATION__MPRACTORS__H__
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
-#include <cpPlugins/Extensions/Visualization/ImageSliceActors.h>
+#include <cpExtensions/cpExtensions_Export.h>
+#include <cpExtensions/Visualization/ImageSliceActors.h>
#include <vtkActor.h>
#include <vtkImageMapToColors.h>
class vtkWindowLevelLookupTable;
// -------------------------------------------------------------------------
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT MPRActors
+ class cpExtensions_EXPORT MPRActors
: public vtkPropCollection
{
public:
vtkSmartPointer< vtkActor > ImageOutlineActor;
typedef
- cpPlugins::Extensions::Visualization::ImageSliceActors
+ cpExtensions::Visualization::ImageSliceActors
_TSlice;
vtkSmartPointer< _TSlice > Slices[ 3 ];
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRACTORS__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__MPRACTORS__H__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/MPRWithDifferentWindows.h>
+#include <cpExtensions/Visualization/MPRWithDifferentWindows.h>
#include <vtkCamera.h>
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+cpExtensions::Visualization::MPRWithDifferentWindows::
MPRWithDifferentWindows(
vtkRenderWindow* xWin,
vtkRenderWindow* yWin,
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+cpExtensions::Visualization::MPRWithDifferentWindows::
~MPRWithDifferentWindows( )
{
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
SetImage( vtkImageData* image )
{
this->m_MPRActors->SetInputData( image );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
SetModeToNavigation( )
{
for( unsigned int i = 0; i < 3; ++i )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
SetModeToDeformation( )
{
for( unsigned int i = 0; i < 3; ++i )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
ResetCamera( const int& id )
{
if( id < 4 )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
ResetCameras( )
{
for( int i = 0; i < 4; ++i )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
Render( const int& id )
{
if( id < 4 )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
RenderAll( )
{
for( int i = 0; i < 4; ++i )
}
// -------------------------------------------------------------------------
-vtkRenderer* cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+vtkRenderer* cpExtensions::Visualization::MPRWithDifferentWindows::
GetRenderer( const int& id ) const
{
if( id < 4 )
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::MPRWithDifferentWindows::
+void cpExtensions::Visualization::MPRWithDifferentWindows::
Add3DActor( vtkProp3D* prop )
{
if( this->m_Renderers[ 3 ] != NULL )
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
+#define __CPEXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
-#include <cpPlugins/Extensions/Visualization/MPRActors.h>
-#include <cpPlugins/Extensions/Visualization/ImageInteractorStyle.h>
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/Visualization/MPRActors.h>
+#include <cpExtensions/Visualization/ImageInteractorStyle.h>
+#include <cpExtensions/cpExtensions_Export.h>
#include <vtkImageData.h>
#include <vtkRenderer.h>
this->m_Styles[ i ]->Remove##e##Observers( ); \
}
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT MPRWithDifferentWindows
+ class cpExtensions_EXPORT MPRWithDifferentWindows
{
public:
- typedef cpPlugins::Extensions::Visualization::
+ typedef cpExtensions::Visualization::
MPRActors TMPRActors;
- typedef cpPlugins::Extensions::Visualization::
+ typedef cpExtensions::Visualization::
ImageInteractorStyle TStyle;
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__MPRWITHDIFFERENTWINDOWS__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__H__
+#define __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__H__
#include <itkConceptChecking.h>
#include <vtkMapper.h>
class vtkInformation;
class vtkRenderer;
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#include <cpPlugins/Extensions/Visualization/MeshMapper.hxx>
+#include <cpExtensions/Visualization/MeshMapper.hxx>
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
+#ifndef __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
+#define __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
#include <vtkInformation.h>
#include <vtkMath.h>
-// TODO: #include <cpPlugins/Extensions/Visualization/OpenGLMeshMapper.h>
+// TODO: #include <cpExtensions/Visualization/OpenGLMeshMapper.h>
// -------------------------------------------------------------------------
/* TODO
template< class M >
- typename cpPlugins::Extensions::Visualization::MeshMapper< M >::
- Self* cpPlugins::Extensions::Visualization::MeshMapper< M >::
+ typename cpExtensions::Visualization::MeshMapper< M >::
+ Self* cpExtensions::Visualization::MeshMapper< M >::
New( )
{
return(
- cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::New( )
+ cpExtensions::Visualization::OpenGLMeshMapper< M >::New( )
);
}
*/
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
ShallowCopy( vtkAbstractMapper* m )
{
Self* mapper = Self::SafeDownCast( m );
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
SetInputData( M* in )
{
if( this->Mesh != in )
// -------------------------------------------------------------------------
template< class M >
-M* cpPlugins::Extensions::Visualization::MeshMapper< M >::
+M* cpExtensions::Visualization::MeshMapper< M >::
GetInput( )
{
return( this->Mesh );
// -------------------------------------------------------------------------
template< class M >
-const M* cpPlugins::Extensions::Visualization::MeshMapper< M >::
+const M* cpExtensions::Visualization::MeshMapper< M >::
GetInput( ) const
{
return( this->Mesh );
// -------------------------------------------------------------------------
template< class M >
-double* cpPlugins::Extensions::Visualization::MeshMapper< M >::
+double* cpExtensions::Visualization::MeshMapper< M >::
GetBounds( )
{
// do we have an input
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
GetBounds( double bounds[ 6 ] )
{
this->Superclass::GetBounds( bounds );
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
Render( vtkRenderer* aren, vtkActor* act )
{
if( this->Mesh.IsNull( ) )
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
Update( )
{
// TODO:
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
Update( int port )
{
// TODO:
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
MapDataArrayToVertexAttribute(
const char* vertexAttributeName,
const char* dataArrayName,
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
MapDataArrayToMultiTextureAttribute(
int unit,
const char* dataArrayName,
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
RemoveVertexAttributeMapping( const char* vertexAttributeName )
{
vtkErrorMacro( "Not implemented at this level..." );
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
RemoveAllVertexAttributeMappings( )
{
vtkErrorMacro( "Not implemented at this level..." );
// -------------------------------------------------------------------------
template< class M >
-cpPlugins::Extensions::Visualization::MeshMapper< M >::
+cpExtensions::Visualization::MeshMapper< M >::
MeshMapper( )
: Superclass( )
{
// -------------------------------------------------------------------------
template< class M >
-cpPlugins::Extensions::Visualization::MeshMapper< M >::
+cpExtensions::Visualization::MeshMapper< M >::
~MeshMapper( )
{
}
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::MeshMapper< M >::
+void cpExtensions::Visualization::MeshMapper< M >::
ComputeBounds( )
{
static const TScalar _0 = TScalar( 0 );
// -------------------------------------------------------------------------
template< class M >
-int cpPlugins::Extensions::Visualization::MeshMapper< M >::
+int cpExtensions::Visualization::MeshMapper< M >::
FillInputPortInformation( int port, vtkInformation* info )
{
info->Set( vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE( ), "itk::Mesh" );
return( 1 );
}
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
+#endif // __CPEXTENSIONS__VISUALIZATION__MESHMAPPER__HXX__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
+#define __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
#include <vector>
-#include <cpPlugins/Extensions/Visualization/MeshMapper.h>
+#include <cpExtensions/Visualization/MeshMapper.h>
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
public:
virtual const char* GetNameOfClass( ) const
- { return( "cpPlugins::Extensions::OpenGLMeshMapper" ); }
+ { return( "cpExtensions::OpenGLMeshMapper" ); }
static Self* New( );
virtual void RenderPiece( vtkRenderer* aren, vtkActor* act );
} // ecapseman
-} // ecapseman
+#include <cpExtensions/Visualization/OpenGLMeshMapper.hxx>
-#include <cpPlugins/Extensions/Visualization/OpenGLMeshMapper.hxx>
-
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__H__
// eof - $RCSfile$
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
+#ifndef __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
+#define __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
#include <algorithm>
#include <string>
// -------------------------------------------------------------------------
template< class M >
-typename cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
-Self* cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+typename cpExtensions::Visualization::OpenGLMeshMapper< M >::
+Self* cpExtensions::Visualization::OpenGLMeshMapper< M >::
New( )
{
return( new Self( ) );
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+void cpExtensions::Visualization::OpenGLMeshMapper< M >::
RenderPiece( vtkRenderer* aren, vtkActor* act )
{
vtkOpenGLClearErrorMacro( );
// -------------------------------------------------------------------------
template< class M >
-void cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+void cpExtensions::Visualization::OpenGLMeshMapper< M >::
ReleaseGraphicsResources( vtkWindow* win )
{
if( win && win->GetMapped( ) )
// -------------------------------------------------------------------------
template< class M >
-int cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+int cpExtensions::Visualization::OpenGLMeshMapper< M >::
Draw( vtkRenderer* aren, vtkActor* act )
{
vtkOpenGLClearErrorMacro( );
// -------------------------------------------------------------------------
template< class M >
-cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+cpExtensions::Visualization::OpenGLMeshMapper< M >::
OpenGLMeshMapper( )
: Superclass( ),
TotalCells( 0 ),
// -------------------------------------------------------------------------
template< class M >
-cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+cpExtensions::Visualization::OpenGLMeshMapper< M >::
~OpenGLMeshMapper( )
{
if( this->LastWindow )
// -------------------------------------------------------------------------
template< class M >
-bool cpPlugins::Extensions::Visualization::OpenGLMeshMapper< M >::
+bool cpExtensions::Visualization::OpenGLMeshMapper< M >::
_ConfigureOpenGL( )
{
M* input = this->GetInput( );
return( true );
}
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
+#endif // __CPEXTENSIONS__VISUALIZATION__OPENGLMESHMAPPER__HXX__
// eof - $RCSfile$
-#include <cpPlugins/Extensions/Visualization/SeedWidgetCorrector.h>
+#include <cpExtensions/Visualization/SeedWidgetCorrector.h>
#include <vtkCellPicker.h>
#include <vtkSeedWidget.h>
#include <vtkRenderWindowInteractor.h>
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::SeedWidgetCorrector*
-cpPlugins::Extensions::Visualization::SeedWidgetCorrector::
+cpExtensions::Visualization::SeedWidgetCorrector*
+cpExtensions::Visualization::SeedWidgetCorrector::
New( )
{
- return( new cpPlugins::Extensions::Visualization::SeedWidgetCorrector );
+ return( new cpExtensions::Visualization::SeedWidgetCorrector );
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::SeedWidgetCorrector::
+void cpExtensions::Visualization::SeedWidgetCorrector::
Configure( vtkCellPicker* picker )
{
this->m_Picker = picker;
}
// -------------------------------------------------------------------------
-void cpPlugins::Extensions::Visualization::SeedWidgetCorrector::
+void cpExtensions::Visualization::SeedWidgetCorrector::
Execute( vtkObject* caller, unsigned long eventId, void* arguments )
{
vtkSeedWidget* wdg = dynamic_cast< vtkSeedWidget* >( caller );
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::SeedWidgetCorrector::
+cpExtensions::Visualization::SeedWidgetCorrector::
SeedWidgetCorrector( )
: vtkCommand( ),
m_Picker( NULL )
}
// -------------------------------------------------------------------------
-cpPlugins::Extensions::Visualization::SeedWidgetCorrector::
+cpExtensions::Visualization::SeedWidgetCorrector::
~SeedWidgetCorrector( )
{
}
-#ifndef __CPPLUGINS__EXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
-#define __CPPLUGINS__EXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
+#ifndef __CPEXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
+#define __CPEXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
-#include <cpPlugins/Extensions/cpPlugins_Extensions_Export.h>
+#include <cpExtensions/cpExtensions_Export.h>
#include <vtkCommand.h>
class vtkCellPicker;
class vtkSeedWidget;
-namespace cpPlugins
-{
- namespace Extensions
+namespace cpExtensions
{
namespace Visualization
{
/**
*/
- class cpPlugins_Extensions_EXPORT SeedWidgetCorrector
+ class cpExtensions_EXPORT SeedWidgetCorrector
: public vtkCommand
{
public:
} // ecapseman
- } // ecapseman
-
} // ecapseman
-#endif // __CPPLUGINS__EXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
+#endif // __CPEXTENSIONS__VISUALIZATION__SEEDWIDGETCORRECTOR__H__
// eof - $RCSfile$
-SUBDIRS(
- Extensions
+SET(LIBRARY_NAME cpPlugins)
+
+## ===============
+## = Source code =
+## ===============
+
+FILE(GLOB Interface_LIB_HEADERS_H "Interface/*.h")
+FILE(GLOB Interface_LIB_HEADERS_HPP "Interface/*.hpp")
+FILE(GLOB Interface_LIB_HEADERS_HXX "Interface/*.hxx")
+FILE(GLOB Interface_LIB_SOURCES_C "Interface/*.c")
+FILE(GLOB Interface_LIB_SOURCES_CPP "Interface/*.cpp")
+FILE(GLOB Interface_LIB_SOURCES_CXX "Interface/*.cxx")
+
+SET(
+ LIB_HEADERS_H
+ Plugins/ImageReader.h
+ Plugins/ImageWriter.h
+ Plugins/MeshReader.h
+ Plugins/MeshWriter.h
+ Plugins/MarchingCubes.h
+ Plugins/OtsuThresholdImageFilter.h
+ )
+SET(
+ LIB_SOURCES_CXX
+ Plugins/Host.cxx
+ Plugins/ImageReader.cxx
+ Plugins/ImageWriter.cxx
+ Plugins/MeshReader.cxx
+ Plugins/MeshWriter.cxx
+ Plugins/MarchingCubes.cxx
+ Plugins/OtsuThresholdImageFilter.cxx
+ )
+
+## =====================
+## = Compilation rules =
+## =====================
+
+ADD_LIBRARY(
+ ${LIBRARY_NAME}
+ SHARED
+ ${Interface_LIB_SOURCES_C}
+ ${Interface_LIB_SOURCES_CPP}
+ ${Interface_LIB_SOURCES_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/${LIBRARY_NAME}_Export.h
+ STATIC_DEFINE ${LIBRARY_NAME}_BUILT_AS_STATIC
+ )
+TARGET_LINK_LIBRARIES(
+ ${LIBRARY_NAME}
+ ${ITK_LIBRARIES}
+ ${VTK_LIBRARIES}
+ cpPlugins_Pluma
+ )
+
+## ========================
+## -- Installation rules --
+## ========================
+
+INSTALL(
+ TARGETS ${LIBRARY_NAME}
+ RUNTIME DESTINATION bin
+ LIBRARY DESTINATION lib
+ ARCHIVE DESTINATION lib/static
+ )
+
+SET(
+ local_install_dirs
Interface
- Plugins
)
+FOREACH(dir ${local_install_dirs})
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpPlugins/Interface
+ FILES_MATCHING PATTERN "*.h"
+ )
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpPlugins/Interface
+ FILES_MATCHING PATTERN "*.hxx"
+ )
+ INSTALL(
+ DIRECTORY ${dir}
+ DESTINATION include/cpPlugins/Interface
+ FILES_MATCHING PATTERN "*.hpp"
+ )
+ENDFOREACH(dir)
+
+INSTALL(
+ FILES
+ ${PROJECT_BINARY_DIR}/lib/cpPlugins/Interface/${LIBRARY_NAME}_Export.h
+ DESTINATION include/cpPlugins/Interface
+ )
+
## eof - $RCSfile$
#include <string>
#include <vtkDataObject.h>
#include <vtkSmartPointer.h>
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/Object.h>
#define ITK_MANUAL_INSTANTIATION
{
/**
*/
- class cpPlugins_Interface_EXPORT DataObject
+ class cpPlugins_EXPORT DataObject
: public Object
{
public:
#ifndef __CPPLUGINS__INTERFACE__FILTEROBJECT__H__
#define __CPPLUGINS__INTERFACE__FILTEROBJECT__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ProcessObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT FilterObject
+ class cpPlugins_EXPORT FilterObject
: public ProcessObject
{
public:
#include <map>
#include <string>
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/DataObject.h>
#define ITK_MANUAL_INSTANTIATION
{
/**
*/
- class cpPlugins_Interface_EXPORT Image
+ class cpPlugins_EXPORT Image
: public DataObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__IMAGESINK__H__
#define __CPPLUGINS__INTERFACE__IMAGESINK__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/SinkObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT ImageSink
+ class cpPlugins_EXPORT ImageSink
: public SinkObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__IMAGESOURCE__H__
#define __CPPLUGINS__INTERFACE__IMAGESOURCE__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/SourceObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT ImageSource
+ class cpPlugins_EXPORT ImageSource
: public SourceObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__IMAGETOIMAGEFILTER__H__
#define __CPPLUGINS__INTERFACE__IMAGETOIMAGEFILTER__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/FilterObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT ImageToImageFilter
+ class cpPlugins_EXPORT ImageToImageFilter
: public FilterObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__IMAGETOMESHFILTER__H__
#define __CPPLUGINS__INTERFACE__IMAGETOMESHFILTER__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/FilterObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT ImageToMeshFilter
+ class cpPlugins_EXPORT ImageToMeshFilter
: public FilterObject
{
public:
#include <vector>
#include <Pluma/Pluma.hpp>
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/Object.h>
#include <cpPlugins/Interface/ProcessObject.h>
{
/**
*/
- class cpPlugins_Interface_EXPORT Interface
+ class cpPlugins_EXPORT Interface
{
public:
typedef std::vector< ObjectProvider* > TProviders;
#ifndef __CPPLUGINS__INTERFACE__MESH__H__
#define __CPPLUGINS__INTERFACE__MESH__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/DataObject.h>
class vtkPolyData;
{
/**
*/
- class cpPlugins_Interface_EXPORT Mesh
+ class cpPlugins_EXPORT Mesh
: public DataObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__MESHSINK__H__
#define __CPPLUGINS__INTERFACE__MESHSINK__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/SinkObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT MeshSink
+ class cpPlugins_EXPORT MeshSink
: public SinkObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__MESHSOURCE__H__
#define __CPPLUGINS__INTERFACE__MESHSOURCE__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/SourceObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT MeshSource
+ class cpPlugins_EXPORT MeshSource
: public SourceObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__MESHTOIMAGEFILTER__H__
#define __CPPLUGINS__INTERFACE__MESHTOIMAGEFILTER__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/FilterObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT MeshToImageFilter
+ class cpPlugins_EXPORT MeshToImageFilter
: public FilterObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__MESHTOMESHFILTER__H__
#define __CPPLUGINS__INTERFACE__MESHTOMESHFILTER__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/FilterObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT MeshToMeshFilter
+ class cpPlugins_EXPORT MeshToMeshFilter
: public FilterObject
{
public:
#include <string>
#include <Pluma/Pluma.hpp>
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#define ITK_MANUAL_INSTANTIATION
#include <itkObject.h>
// -------------------------------------------------------------------------
#define CPPLUGINS_PROVIDER_HEADER_BEGIN( TYPE ) \
- class cpPlugins_Interface_EXPORT TYPE##Provider \
+ class cpPlugins_EXPORT TYPE##Provider \
: public pluma::Provider \
{ \
private: \
{
/**
*/
- class cpPlugins_Interface_EXPORT Object
+ class cpPlugins_EXPORT Object
: public itk::Object
{
public:
#include <ostream>
#include <string>
#include <vector>
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
namespace cpPlugins
{
{
/**
*/
- class cpPlugins_Interface_EXPORT Parameters
+ class cpPlugins_EXPORT Parameters
{
// -------------------------------------------------------------------
friend std::ostream& operator<<(
#ifndef __CPPLUGINS__INTERFACE__PROCESSOBJECT__H__
#define __CPPLUGINS__INTERFACE__PROCESSOBJECT__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/Object.h>
#include <cpPlugins/Interface/DataObject.h>
#include <cpPlugins/Interface/Parameters.h>
{
/**
*/
- class cpPlugins_Interface_EXPORT ProcessObject
+ class cpPlugins_EXPORT ProcessObject
: public Object
{
public:
#ifndef __CPPLUGINS__INTERFACE__SINKOBJECT__H__
#define __CPPLUGINS__INTERFACE__SINKOBJECT__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ProcessObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT SinkObject
+ class cpPlugins_EXPORT SinkObject
: public ProcessObject
{
public:
#ifndef __CPPLUGINS__INTERFACE__SOURCEOBJECT__H__
#define __CPPLUGINS__INTERFACE__SOURCEOBJECT__H__
-#include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ProcessObject.h>
namespace cpPlugins
{
/**
*/
- class cpPlugins_Interface_EXPORT SourceObject
+ class cpPlugins_EXPORT SourceObject
: public ProcessObject
{
public:
#include <vector>
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ImageSource.h>
#define ITK_MANUAL_INSTANTIATION
#ifndef __CPPLUGINS__PLUGINS__IMAGEWRITER__H__
#define __CPPLUGINS__PLUGINS__IMAGEWRITER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ImageSink.h>
namespace cpPlugins
#ifndef __CPPLUGINS__PLUGINS__MARCHINGCUBES__H__
#define __CPPLUGINS__PLUGINS__MARCHINGCUBES__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ImageToMeshFilter.h>
class vtkPolyDataAlgorithm;
#ifndef __CPPLUGINS__PLUGINS__MESHREADER__H__
#define __CPPLUGINS__PLUGINS__MESHREADER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/MeshSource.h>
class vtkDataReader;
#ifndef __CPPLUGINS__PLUGINS__MESHWRITER__H__
#define __CPPLUGINS__PLUGINS__MESHWRITER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/MeshSink.h>
class vtkDataWriter;
#ifndef __CPPLUGINS__PLUGINS__OTSUTHRESHOLDIMAGEFILTER__H__
#define __CPPLUGINS__PLUGINS__OTSUTHRESHOLDIMAGEFILTER__H__
-#include <cpPlugins/Plugins/cpPlugins_Export.h>
+#include <cpPlugins/cpPlugins_Export.h>
#include <cpPlugins/Interface/ImageToImageFilter.h>
namespace cpPlugins
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff