X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=appli%2FCTBronchi%2FMoriSegmentation.cxx;h=90a1bf3333b608aa93392ab9210a82bde94310db;hb=9817c556a0b8b5e3b332d45f07faa84d91afb2d0;hp=dcbae23addd5d556e37814759cf05673691874e9;hpb=d2f5533aef455b7d862dbfbe72c42c5497eaf98b;p=FrontAlgorithms.git

diff --git a/appli/CTBronchi/MoriSegmentation.cxx b/appli/CTBronchi/MoriSegmentation.cxx
index dcbae23..90a1bf3 100644
--- a/appli/CTBronchi/MoriSegmentation.cxx
+++ b/appli/CTBronchi/MoriSegmentation.cxx
@@ -3,196 +3,119 @@
 // @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 )
   {