+// =========================================================================
+// @author Leonardo Florez Valencia
+// @email florez-l@javeriana.edu.co
+// =========================================================================
+
#ifndef __fpa__Image__SkeletonFilter__hxx__
#define __fpa__Image__SkeletonFilter__hxx__
-#include <fpa/Base/Functors/Inverse.h>
-#include <fpa/Image/Functors/SimpleNeighborhood.h>
#include <itkImageRegionIteratorWithIndex.h>
+#include <itkMinimumMaximumImageCalculator.h>
+
+#include <fpa/Image/Functors/VertexIdentity.h>
+#include <fpa/Base/Functors/InvertValue.h>
// -------------------------------------------------------------------------
-#define fpa_Image_SkeletonFilter_OutputMacro( o_n, o_t ) \
- template< class _TImage > \
- typename fpa::Image::SkeletonFilter< _TImage >:: \
- o_t* fpa::Image::SkeletonFilter< _TImage >:: \
- Get##o_n( ) \
- { \
- return( \
- dynamic_cast< o_t* >( \
- this->itk::ProcessObject::GetOutput( this->m_##o_n##Idx ) \
- ) \
- ); \
- }
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+SetInput( const TScalarImage* image )
+{
+ // Do nothing
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+SetInput( const TImage* image )
+{
+ this->m_DistanceMap->SetInput( image );
+ this->Superclass::SetInput( this->m_DistanceMap->GetOutput( ) );
+}
-fpa_Image_SkeletonFilter_OutputMacro( Skeleton, TSkeleton );
-fpa_Image_SkeletonFilter_OutputMacro( Marks, TMarks );
+// -------------------------------------------------------------------------
+template< class _TImage, class _TScalar >
+_TImage* fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+GetInput( )
+{
+ return( this->m_DistanceMap->GetInput( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TScalar >
+const _TImage* fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+GetInput( ) const
+{
+ return( this->m_DistanceMap->GetInput( ) );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TScalar >
+typename fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+TSkeleton* fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+GetSkeleton( )
+{
+ return(
+ dynamic_cast< TSkeleton* >(
+ this->itk::ProcessObject::GetOutput( this->m_SkeletonIdx )
+ )
+ );
+}
+
+// -------------------------------------------------------------------------
+template< class _TImage, class _TScalar >
+typename fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+TMarks* fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+GetMarks( )
+{
+ return(
+ dynamic_cast< TMarks* >(
+ this->itk::ProcessObject::GetOutput( this->m_MarksIdx )
+ )
+ );
+}
// -------------------------------------------------------------------------
-template< class _TImage >
-fpa::Image::SkeletonFilter< _TImage >::
+template< class _TImage, class _TScalar >
+fpa::Image::SkeletonFilter< _TImage, _TScalar >::
SkeletonFilter( )
- : Superclass( )
+ : Superclass( ),
+ m_SeedFromMaximumDistance( false )
{
- typedef typename _TImage::PixelType _TPixel;
- typedef typename _TImage::Superclass _TImageBase;
- typedef fpa::Image::Functors::SimpleNeighborhood< _TImageBase > _TNeighFunc;
- typedef fpa::Base::Functors::Inverse< _TPixel, _TPixel > _TInvFunc;
+ typedef fpa::Image::Functors::VertexIdentity< TScalarImage, _TScalar > _TVertexFunc;
+ typedef fpa::Base::Functors::InvertValue< _TScalar, _TScalar > _TValueFunc;
+
+ typename _TVertexFunc::Pointer vertex_func = _TVertexFunc::New( );
+ typename _TValueFunc::Pointer value_func = _TValueFunc::New( );
+ value_func->SetAlpha( 1 );
+ value_func->SetBeta( 1 );
+
+ this->SetFunctor( vertex_func );
+ this->SetFunctor( value_func );
+
+ this->m_DistanceMap = TDistanceMap::New( );
+ this->m_DistanceMap->InsideIsPositiveOn( );
+ this->m_DistanceMap->SquaredDistanceOff( );
+ this->m_DistanceMap->UseImageSpacingOn( );
unsigned int nOutputs = this->GetNumberOfRequiredOutputs( );
this->SetNumberOfRequiredOutputs( nOutputs + 2 );
typename TMarks::Pointer marks = TMarks::New( );
this->SetNthOutput( this->m_SkeletonIdx, skeleton.GetPointer( ) );
this->SetNthOutput( this->m_MarksIdx, marks.GetPointer( ) );
-
- typename _TNeighFunc::Pointer nfunc = _TNeighFunc::New( );
- nfunc->SetOrder( 2 );
- this->SetNeighborhoodFunction( nfunc );
-
- typename _TInvFunc::Pointer ifunc = _TInvFunc::New( );
- this->SetCostConversionFunction( ifunc );
}
// -------------------------------------------------------------------------
-template< class _TImage >
-fpa::Image::SkeletonFilter< _TImage >::
+template< class _TImage, class _TScalar >
+fpa::Image::SkeletonFilter< _TImage, _TScalar >::
~SkeletonFilter( )
{
}
// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_BeforeGenerateData( )
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+GenerateData( )
{
- this->Superclass::_BeforeGenerateData( );
+ // Prepare distance map
+ this->m_DistanceMap->Update( );
+
+ // Update start seed
+ TVertex seed;
+ if( this->m_SeedFromMaximumDistance )
+ {
+ typedef itk::MinimumMaximumImageCalculator< TScalarImage > _TMinMax;
+ typename _TMinMax::Pointer minmax = _TMinMax::New( );
+ minmax->SetImage( this->m_DistanceMap->GetOutput( ) );
+ minmax->Compute( );
+ seed = minmax->GetIndexOfMaximum( );
+ }
+ else
+ seed = *( this->BeginSeeds( ) );
+ this->m_Seeds.clear( );
+ this->m_Seeds.insert( seed );
+
+ // Prepare skeleton candidates queue
this->m_SkeletonQueue.clear( );
+
+ // Go!
+ this->Superclass::GenerateData( );
+
+ // Backtracking
+ _TAdjacencies A;
+ std::vector< TVertex > end_points;
+ this->_EndPoints( end_points, A );
+ this->_Skeleton( end_points, A );
}
// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_UpdateResult( const _TQueueNode& n )
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+_SetOutputValue( const TVertex& vertex, const TOutputValue& value )
{
typedef typename _TSkeletonQueue::value_type _TSkeletonQueueValue;
- this->Superclass::_UpdateResult( n );
- double d = double( this->GetInput( )->GetPixel( n.Vertex ) );
+ this->Superclass::_SetOutputValue( vertex, value );
+ double d = double( this->m_DistanceMap->GetOutput( )->GetPixel( vertex ) );
if( d >= double( 0 ) )
{
// Update skeleton candidates
d += double( 1e-5 );
- double v = double( n.Result ) / ( d * d );
- this->m_SkeletonQueue.insert( _TSkeletonQueueValue( v, n.Vertex ) );
+ double v = double( value ) / ( d * d );
+ this->m_SkeletonQueue.insert( _TSkeletonQueueValue( v, vertex ) );
} // fi
}
// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_AfterGenerateData( )
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+_EndPoints( std::vector< TVertex >& end_points, _TAdjacencies& A )
{
- this->Superclass::_AfterGenerateData( );
-
- _TAdjacencies A;
- std::vector< TIndex > end_points;
- this->_EndPoints( end_points, A );
- this->_Skeleton( end_points, A );
-}
+ typedef typename _TSkeletonQueue::value_type _TSkeletonQueueValue;
-// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_EndPoints( std::vector< TIndex >& end_points, _TAdjacencies& A )
-{
- auto marks = this->GetMarks( );
- auto mst = this->GetMinimumSpanningTree( );
- auto spac = marks->GetSpacing( );
+ TMarks* marks = this->GetMarks( );
+ TMST* mst = this->GetMinimumSpanningTree( );
+ typename TImage::SpacingType spac = marks->GetSpacing( );
// Some values
marks->SetLargestPossibleRegion( mst->GetLargestPossibleRegion( ) );
while( this->m_SkeletonQueue.size( ) > 0 )
{
// Get node
- auto nIt = this->m_SkeletonQueue.begin( );
- auto n = *nIt;
+ typename _TSkeletonQueue::iterator nIt = this->m_SkeletonQueue.begin( );
+ _TSkeletonQueueValue n = *nIt;
this->m_SkeletonQueue.erase( nIt );
// Mark it and update end-points
end_points.push_back( n.second );
// Mark path
- TIndex it = n.second;
- TIndex p = mst->GetParent( it );
+ TVertex it = n.second;
+ TVertex p = mst->GetParent( it );
while( it != p )
{
this->_MarkSphere( it );
}
// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_Skeleton( const std::vector< TIndex >& end_points, _TAdjacencies& A )
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+_Skeleton( const std::vector< TVertex >& end_points, _TAdjacencies& A )
{
- typedef itk::Image< unsigned long, Self::Dimension > _TTagsImage;
- typedef typename TMST::TPath _TPath;
+ typedef typename TSkeleton::TPath _TPath;
+ typedef itk::Image< unsigned long, TImage::ImageDimension > _TTagsImage;
- auto mst = this->GetMinimumSpanningTree( );
- auto skeleton = this->GetSkeleton( );
+ TMST* mst = this->GetMinimumSpanningTree( );
+ TSkeleton* skeleton = this->GetSkeleton( );
// Tag branches
typename _TTagsImage::Pointer tags = _TTagsImage::New( );
tags->SetBufferedRegion( mst->GetBufferedRegion( ) );
tags->Allocate( );
tags->FillBuffer( 0 );
- for( auto eIt = end_points.begin( ); eIt != end_points.end( ); ++eIt )
+ for( TVertex it: end_points )
{
- TIndex it = *eIt;
- TIndex p = mst->GetParent( it );
+ TVertex p = mst->GetParent( it );
while( it != p )
{
tags->SetPixel( it, tags->GetPixel( it ) + 1 );
} // rof
// Build paths (branches)
- for( auto eIt = end_points.begin( ); eIt != end_points.end( ); ++eIt )
+ for( TVertex it: end_points )
{
- TIndex it = *eIt;
- TIndex p = mst->GetParent( it );
- TIndex sIdx = *eIt;
+ TVertex p = mst->GetParent( it );
+ TVertex sIdx = it;
typename _TPath::Pointer path = _TPath::New( );
path->SetReferenceImage( mst );
while( it != p )
}
// -------------------------------------------------------------------------
-template< class _TImage >
-void fpa::Image::SkeletonFilter< _TImage >::
-_MarkSphere( const TIndex& idx )
+template< class _TImage, class _TScalar >
+void fpa::Image::SkeletonFilter< _TImage, _TScalar >::
+_MarkSphere( const TVertex& idx )
{
typedef itk::ImageRegionIteratorWithIndex< TMarks > _TMarksIt;
- static const double _eps = std::sqrt( double( Self::Dimension + 1 ) );
- auto input = this->GetInput( );
- auto marks = this->GetMarks( );
- auto spac = input->GetSpacing( );
- auto region = input->GetRequestedRegion( );
+ static const double _eps = std::sqrt( double( TImage::ImageDimension + 1 ) );
+ const TScalarImage* dmap = this->m_DistanceMap->GetOutput( );
+ TMarks* marks = this->GetMarks( );
+ typename TImage::SpacingType spac = dmap->GetSpacing( );
+ typename TImage::RegionType region = dmap->GetRequestedRegion( );
- typename _TImage::PointType cnt;
- input->TransformIndexToPhysicalPoint( idx, cnt );
- double r = double( input->GetPixel( idx ) ) * _eps;
+ typename TImage::PointType cnt;
+ dmap->TransformIndexToPhysicalPoint( idx, cnt );
+ double r = double( dmap->GetPixel( idx ) ) * _eps;
- TIndex i0, i1;
- for( unsigned int d = 0; d < Self::Dimension; ++d )
+ TVertex i0, i1;
+ for( unsigned int d = 0; d < TImage::ImageDimension; ++d )
{
long off = long( std::ceil( r / double( spac[ d ] ) ) );
if( off < 3 )
} // rof
- typename _TImage::SizeType size;
- for( unsigned int d = 0; d < Self::Dimension; ++d )
+ typename TImage::SizeType size;
+ for( unsigned int d = 0; d < TImage::ImageDimension; ++d )
size[ d ] = i1[ d ] - i0[ d ] + 1;
- typename _TImage::RegionType neighRegion;
+ typename TImage::RegionType neighRegion;
neighRegion.SetIndex( i0 );
neighRegion.SetSize( size );
_TMarksIt mIt( marks, neighRegion );
for( mIt.GoToBegin( ); !mIt.IsAtEnd( ); ++mIt )
{
- TIndex w = mIt.GetIndex( );
- typename _TImage::PointType p;
+ TVertex w = mIt.GetIndex( );
+ typename TImage::PointType p;
marks->TransformIndexToPhysicalPoint( w, p );
mIt.Set( 1 );
git://git.creatis.insa-lyon.fr / FrontAlgorithms.git / blobdiff