// @email florez-l@javeriana.edu.co
// =========================================================================
-#include <chrono>
-#include <map>
+#include <sstream>
+#include <string>
+#include <tclap/CmdLine.h>
#include <itkImage.h>
-#include <itkImageFileReader.h>
-#include <itkImageFileWriter.h>
#include <fpa/Filters/Image/Mori.h>
+#include "Functions.h"
// -------------------------------------------------------------------------
const unsigned int Dim = 3;
-typedef short TPixel;
-typedef unsigned char TLabel;
+typedef short TPixel;
+typedef unsigned char TLabel;
typedef itk::Image< TPixel, Dim > TImage;
typedef itk::Image< TLabel, Dim > TLabels;
// -------------------------------------------------------------------------
-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 _TImage >
-void WriteImage( const _TImage* image, const std::string& fname )
-{
- 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;
-}
-
-// -------------------------------------------------------------------------
-bool ParseArgs(
- std::map< std::string, std::string >& args, int argc, char* argv[]
- )
+int main( int argc, char* argv[] )
{
- std::set< std::string > mandatory;
- mandatory.insert( "in" );
- mandatory.insert( "out" );
- mandatory.insert( "seed" );
-
- args[ "minimum_threshold" ] = "-850";
- args[ "signal_kernel_size" ] = "20";
- args[ "signal_threshold" ] = "100";
- args[ "signal_influence" ] = "0.5";
- args[ "lower_threshold" ] = "-1024";
- args[ "upper_threshold" ] = "0";
- args[ "delta_threshold" ] = "1";
-
- int i = 1;
- while( i < argc )
+ typedef TCLAP::ValueArg< std::string > _TStringArg;
+ typedef TCLAP::ValueArg< double > _TRealArg;
+ typedef TCLAP::ValueArg< unsigned long > _TUIntArg;
+ typedef TCLAP::ValueArg< TPixel > _TPixelArg;
+
+ // Parse input line
+ _TStringArg in( "i", "input", "Input image", true, "", "file" );
+ _TStringArg out( "o", "output", "Output image", true, "", "file" );
+ _TStringArg signal( "s", "signal", "Output signal", false, "", "file" );
+ _TStringArg aSeed( "p", "seed", "Input seed", true, "", "\"x y z\"" );
+ _TPixelArg mThr( "t", "min_thr", "Minimum threshold", false, -850, "value (-850)" );
+ _TUIntArg sKernel( "k", "kernel", "Kernel size", false, 20, "value (20)" );
+ _TRealArg sThr( "r", "signal_thr", "Signal threshold", false, 100, "value (100)" );
+ _TRealArg sInfluence( "f", "signal_influence", "Signal influence", false, 0.5, "value (0.5)" );
+ _TPixelArg lower( "l", "lower", "Lower threshold", false, -1024, "value (-1024)" );
+ _TPixelArg upper( "u", "upper", "Upper threshold", false, 0, "value (0)" );
+ _TPixelArg delta( "d", "delta", "Delta threshold", false, 1, "value (1)" );
+ try
{
- std::string cmd = argv[ i ] + 1;
- if( cmd == "seed" )
- {
- std::stringstream seed;
- seed
- << argv[ i + 1 ] << ";"
- << argv[ i + 2 ] << ";"
- << argv[ i + 3 ];
- args[ cmd ] = seed.str( );
- i += 4;
- }
- else
- {
- args[ cmd ] = argv[ i + 1 ];
- i += 2;
-
- } // fi
-
- } // elihw
-
- bool complete = true;
- for( std::string t: mandatory )
- complete &= ( args.find( t ) != args.end( ) );
-
- if( !complete )
+ TCLAP::CmdLine cmd( "Mori segmentation", ' ', "1.0.0" );
+ cmd.add( delta );
+ cmd.add( upper );
+ cmd.add( lower );
+ cmd.add( sInfluence );
+ cmd.add( sThr );
+ cmd.add( sKernel );
+ cmd.add( mThr );
+ cmd.add( aSeed );
+ cmd.add( signal );
+ cmd.add( out );
+ cmd.add( in );
+ cmd.parse( argc, argv );
+ }
+ catch( TCLAP::ArgException& err )
{
std::cerr
- << "Usage: " << argv[ 0 ] << std::endl
- << "\t-in filename" << std::endl
- << "\t-out filename" << std::endl
- << "\t-seed x y z" << std::endl
- << "\t[-out_signal filename]" << std::endl
- << "\t[-minimum_threshold value]" << std::endl
- << "\t[-signal_kernel_size value]" << std::endl
- << "\t[-signal_threshold value]" << std::endl
- << "\t[-signal_influence value]" << std::endl
- << "\t[-lower_threshold value]" << std::endl
- << "\t[-upper_threshold value]" << std::endl
- << "\t[-delta_threshold value]" << std::endl;
- return( false );
+ << "===============================" << std::endl
+ << "Error caught: " << std::endl
+ << err.error( ) << " " << err.argId( )
+ << "===============================" << std::endl
+ << std::endl;
+ return( 1 );
- } // fi
- return( true );
-}
+ } // yrt
+
+ // Get seed
+ std::istringstream sSeed( aSeed.getValue( ) );
+ TImage::PointType seed;
+ sSeed >> seed[ 0 ] >> seed[ 1 ] >> seed[ 2 ];
-// -------------------------------------------------------------------------
-int main( int argc, char* argv[] )
-{
- std::map< std::string, std::string > args;
try
{
- if( ParseArgs( args, argc, argv ) )
+ // Read image
+ TImage::Pointer input_image;
+ CTBronchi::ReadImage( input_image, in.getValue( ) );
+
+ // Mori segmentation
+ typedef fpa::Filters::Image::Mori< TImage, TLabels > _TMori;
+ _TMori::Pointer mori = _TMori::New( );
+ mori->SetInput( input_image );
+ mori->SetSeed( seed );
+ mori->SetInsideValue( 1 );
+ mori->SetOutsideValue( 0 );
+ mori->SetMinimumThreshold( mThr.getValue( ) );
+ mori->SetSignalKernelSize( sKernel.getValue( ) );
+ mori->SetSignalThreshold( sThr.getValue( ) );
+ mori->SetSignalInfluence( sInfluence.getValue( ) );
+ mori->SetThresholds(
+ lower.getValue( ), upper.getValue( ), delta.getValue( )
+ );
+ double t = CTBronchi::MeasureTime( mori );
+ std::cout << "Mori executed in " << t << " s" << std::endl;
+
+ // Write result
+ CTBronchi::WriteImage( mori->GetOutput( ), out.getValue( ) );
+
+ // Write signal
+ if( signal.getValue( ) != "" )
{
- // Parse seed
- 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
- TImage::Pointer input_image;
- ReadImage( input_image, args[ "in" ] );
-
- // Mori segmentation
- typedef fpa::Filters::Image::Mori< TImage, TLabels > TMori;
- TMori::Pointer mori = TMori::New( );
- mori->SetInput( input_image );
- mori->SetSeed( seed );
- mori->SetInsideValue( 1 );
- mori->SetOutsideValue( 0 );
- mori->SetMinimumThreshold(
- TPixel( std::atof( args[ "minimum_threshold" ].c_str( ) ) )
- );
- mori->SetSignalKernelSize(
- std::atoi( args[ "signal_kernel_size" ].c_str( ) )
- );
- mori->SetSignalThreshold(
- std::atof( args[ "signal_threshold" ].c_str( ) )
- );
- mori->SetSignalInfluence(
- std::atof( args[ "signal_influence" ].c_str( ) )
- );
- mori->SetThresholds(
- TPixel( std::atof( args[ "lower_threshold" ].c_str( ) ) ),
- TPixel( std::atof( args[ "upper_threshold" ].c_str( ) ) ),
- TPixel( std::atof( args[ "delta_threshold" ].c_str( ) ) )
- );
- double t = MeasureTime( mori );
- std::cout << "Mori executed in " << t << " s" << std::endl;
- WriteImage( mori->GetOutput( ), args[ "out" ] );
-
- std::map< std::string, std::string >::const_iterator i =
- args.find( "out_signal" );
- if( i != args.end( ) )
+ std::stringstream signalStr;
+ unsigned long nthr = mori->GetNumberOfEvaluatedThresholds( );
+ signalStr << "# nThr = " << nthr << std::endl;
+ signalStr << "# Opt = " << mori->GetOptimumThreshold( ) << std::endl;
+ for( unsigned long j = 0; j < nthr; ++j )
{
- 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;
+ typename _TMori::TPeak p;
+ double x, y;
+ mori->GetSignalValues( j, x, y, p );
+ signalStr << x << " " << y << std::endl;
- } // rof
- std::ofstream signals_str( i->second.c_str( ) );
- signals_str << signal.str( );
- signals_str.close( );
+ } // rof
+ std::ofstream oStrSignals( signal.getValue( ).c_str( ) );
+ oStrSignals << signalStr.str( );
+ oStrSignals.close( );
- } // fi
- }
- else
- return( 1 );
+ } // fi
}
catch( std::exception& err )
{
git://git.creatis.insa-lyon.fr / FrontAlgorithms.git / blobdiff