// @email florez-l@javeriana.edu.co
// =========================================================================
-#include <chrono>
-#include <fstream>
-#include <limits>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
#include <itkImage.h>
-#include <itkImageFileReader.h>
-#include <itkImageFileWriter.h>
-#include <fpa/Filters/Image/Mori.h>
+#include <itkAbsoluteValueDifferenceImageFilter.h>
+#include <itkBinaryThresholdImageFilter.h>
+#include <CTBronchi/Functions.h>
+#include <CTBronchi/Mori.h>
#include <CTBronchi/MoriLabelling.h>
+#include <CTBronchi/RandomWalker.h>
// -------------------------------------------------------------------------
const unsigned int Dim = 3;
typedef short TInputPixel;
typedef unsigned char TLabelPixel;
-typedef itk::Image< TInputPixel, Dim > TInputImage;
+typedef itk::Image< TInputPixel, Dim > TImage;
typedef itk::Image< TLabelPixel, Dim > TLabelImage;
-typedef std::map< std::string, std::string > TMap;
-
-// -------------------------------------------------------------------------
-TMap Args;
-TInputImage::PointType global_seed;
-TLabelPixel inside_value = std::numeric_limits< TLabelPixel >::max( );
-TLabelPixel outside_value = TLabelPixel( 0 );
-
-// -------------------------------------------------------------------------
-double MeasureTime( itk::ProcessObject* f )
-{
- std::chrono::time_point< std::chrono::high_resolution_clock > s, e;
- std::chrono::duration< double > t;
- s = std::chrono::high_resolution_clock::now( );
- f->Update( );
- e = std::chrono::high_resolution_clock::now( );
- t = e - s;
- return( t.count( ) );
-}
-
-// -------------------------------------------------------------------------
-template< class _TImagePtr >
-void ReadImage( _TImagePtr& image, const std::string& fname )
-{
- typedef typename _TImagePtr::ObjectType _TImage;
- typedef itk::ImageFileReader< _TImage > _TReader;
- typename _TReader::Pointer reader = _TReader::New( );
- reader->SetFileName( fname );
- double t = MeasureTime( reader );
- std::cout << "Read " << fname << " in " << t << " s" << std::endl;
- image = reader->GetOutput( );
- image->DisconnectPipeline( );
-}
-
-// -------------------------------------------------------------------------
-template< class _TImagePtr >
-void WriteImage( const _TImagePtr& image, const std::string& fname )
-{
- typedef typename _TImagePtr::ObjectType _TImage;
- typedef itk::ImageFileWriter< _TImage > _TWriter;
- typename _TWriter::Pointer writer = _TWriter::New( );
- writer->SetFileName( fname );
- writer->SetInput( image );
- double t = MeasureTime( writer );
- std::cout << "Wrote " << fname << " in " << t << " s" << std::endl;
-}
-
-// -------------------------------------------------------------------------
-template< class _TInputPtr, class _TOutputPtr >
-void Mori( _TOutputPtr& output, const _TInputPtr& input )
-{
- typedef typename _TInputPtr::ObjectType _TInput;
- typedef typename _TOutputPtr::ObjectType _TOutput;
- typedef fpa::Filters::Image::Mori< _TInput, _TOutput > _TMori;
-
- typename _TMori::Pointer mori = _TMori::New( );
- mori->SetInput( input );
- mori->SetSeed( global_seed );
- mori->SetInsideValue( inside_value );
- mori->SetOutsideValue( outside_value );
- mori->SetMinimumThreshold(
- TInputPixel( std::atof( Args[ "mori_minimum_threshold" ].c_str( ) ) )
- );
- mori->SetSignalKernelSize(
- std::atoi( Args[ "mori_signal_kernel_size" ].c_str( ) )
- );
- mori->SetSignalThreshold(
- std::atof( Args[ "mori_signal_threshold" ].c_str( ) )
- );
- mori->SetSignalInfluence(
- std::atof( Args[ "mori_signal_influence" ].c_str( ) )
- );
- mori->SetThresholds(
- TInputPixel( std::atof( Args[ "mori_lower_threshold" ].c_str( ) ) ),
- TInputPixel( std::atof( Args[ "mori_upper_threshold" ].c_str( ) ) ),
- TInputPixel( std::atof( Args[ "mori_delta_threshold" ].c_str( ) ) )
- );
- double t = MeasureTime( mori );
- std::cout << "Mori executed in " << t << " s" << std::endl;
- output = mori->GetOutput( );
-
- TMap::const_iterator i = Args.find( "out_mori" );
- if( i != Args.end( ) )
- WriteImage( output, i->second );
-
- i = Args.find( "out_signal" );
- if( i != Args.end( ) )
- {
- std::stringstream signal;
- unsigned long nthr = mori->GetNumberOfEvaluatedThresholds( );
- signal << "# nThr = " << nthr << std::endl;
- signal << "# Opt = " << mori->GetOptimumThreshold( ) << std::endl;
- for( unsigned long j = 0; j < nthr; ++j )
- {
- typename _TMori::TPeak p;
- double x, y;
- mori->GetSignalValues( j, x, y, p );
- signal << x << " " << y << std::endl;
-
- } // rof
-
- std::ofstream signals_str( i->second.c_str( ) );
- signals_str << signal.str( );
- signals_str.close( );
-
- } // fi
- output->DisconnectPipeline( );
-}
-
-// -------------------------------------------------------------------------
-template< class _TInputPtr, class _TOutputPtr >
-void Label( _TOutputPtr& output, const _TInputPtr& input )
-{
-}
-
-// -------------------------------------------------------------------------
-bool ParseArgs( int argc, char* argv[] )
-{
- std::set< std::string > mandatory;
- mandatory.insert( "in" );
- mandatory.insert( "out_segmentation" );
- mandatory.insert( "seed_x" );
- mandatory.insert( "seed_y" );
- mandatory.insert( "seed_z" );
-
- Args[ "mori_minimum_threshold" ] = "-850";
- Args[ "mori_signal_kernel_size" ] = "20";
- Args[ "mori_signal_threshold" ] = "100";
- Args[ "mori_signal_influence" ] = "0.5";
- Args[ "mori_lower_threshold" ] = "-1024";
- Args[ "mori_upper_threshold" ] = "0";
- Args[ "mori_delta_threshold" ] = "1";
- for( int i = 1; i < argc; i += 2 )
- Args[ argv[ i ] + 1 ] = argv[ i + 1 ];
-
- bool complete = true;
- for( std::string t: mandatory )
- complete &= ( Args.find( t ) != Args.end( ) );
-
- if( !complete )
- {
- std::cerr
- << "Usage: " << argv[ 0 ] << std::endl
- << "\t-in filename" << std::endl
- << "\t-out_segmentation filename" << std::endl
- << "\t-seed_x value -seed_y value -seed_z value" << std::endl
- << "\t[-out_mori filename]" << std::endl
- << "\t[-out_signal filename]" << std::endl
- << "\t[-out_labels filename]" << std::endl
- << "\t[-mori_minimum_threshold value]" << std::endl
- << "\t[-mori_signal_kernel_size value]" << std::endl
- << "\t[-mori_signal_threshold value]" << std::endl
- << "\t[-mori_signal_influence value]" << std::endl
- << "\t[-mori_lower_threshold value]" << std::endl
- << "\t[-mori_upper_threshold value]" << std::endl
- << "\t[-mori_delta_threshold value]" << std::endl;
- return( false );
-
- } // fi
- return( true );
-}
// -------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
+ std::map< std::string, std::string > args;
try
{
- if( ParseArgs( argc, argv ) )
+ if( CTBronchi::ParseArgs( args, argc, argv ) )
{
// Parse seed
- global_seed[ 0 ] = std::atof( Args[ "seed_x" ].c_str( ) );
- global_seed[ 1 ] = std::atof( Args[ "seed_y" ].c_str( ) );
- global_seed[ 2 ] = std::atof( Args[ "seed_z" ].c_str( ) );
+ TImage::PointType seed;
+ char* str = new char[ args[ "seed" ].size( ) + 1 ];
+ strcpy( str, args[ "seed" ].c_str( ) );
+ seed[ 0 ] = std::atof( strtok( str, ";" ) );
+ seed[ 1 ] = std::atof( strtok( NULL, ";" ) );
+ seed[ 2 ] = std::atof( strtok( NULL, ";" ) );
// Read input image
- TInputImage::Pointer input_image;
- ReadImage( input_image, Args[ "in" ] );
+ TImage::Pointer input_image;
+ CTBronchi::ReadImage( input_image, args[ "in" ] );
// Mori segmentation
TLabelImage::Pointer mori;
- Mori( mori, input_image );
+ TInputPixel opt_thr = CTBronchi::Mori( mori, input_image, seed, args );
- // Create labels
+ // Label image
TLabelImage::Pointer labels;
- Label( labels, mori );
-
- return( 0 );
-
- } // fi
- return( 1 );
+ CTBronchi::Label( labels, input_image, mori, opt_thr, args );
+
+ // Final labels
+ TLabelImage::Pointer final_labels;
+ CTBronchi::RandomWalker( final_labels, input_image, labels, args );
+
+ // Extract label 1
+ typedef itk::BinaryThresholdImageFilter< TLabelImage, TLabelImage > TBinThr;
+ TBinThr::Pointer bin_thr = TBinThr::New( );
+ bin_thr->SetInput( final_labels );
+ bin_thr->SetLowerThreshold( 1 );
+ bin_thr->SetUpperThreshold( 1 );
+ bin_thr->SetInsideValue( 1 );
+ bin_thr->SetOutsideValue( 0 );
+ double t = CTBronchi::MeasureTime( bin_thr );
+ std::cout << "Label extracted in " << t << " s" << std::endl;
+ TLabelImage::Pointer segmentation = bin_thr->GetOutput( );
+
+ // Save
+ CTBronchi::WriteImage( segmentation, args[ "out" ] );
+
+ // Save difference
+ std::map< std::string, std::string >::const_iterator i =
+ args.find( "out_diff" );
+ if( i != args.end( ) )
+ {
+ typedef itk::AbsoluteValueDifferenceImageFilter< TLabelImage, TLabelImage, TLabelImage > TDiff;
+ TDiff::Pointer diff = TDiff::New( );
+ diff->SetInput1( mori );
+ diff->SetInput2( segmentation );
+ t = CTBronchi::MeasureTime( diff );
+ std::cout << "Difference computed in " << t << " s" << std::endl;
+ TLabelImage::Pointer difference = diff->GetOutput( );
+ CTBronchi::WriteImage( difference, i->second );
+
+ } // fi
+ }
+ else
+ return( 1 );
}
catch( std::exception& err )
{
return( 1 );
} // yrt
- /* TODO
- if [ -z "$label_upper_threshold" ]; then label_upper_threshold="-600"; fi
- if [ -z "$label_inside" ]; then label_inside="1"; fi
- if [ -z "$label_outside" ]; then label_outside="2"; fi
- if [ -z "$random_walker_beta" ]; then random_walker_beta="20"; fi
- */
+ return( 0 );
}
// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / FrontAlgorithms.git / blobdiff