[Insight-users] Running time for a level set segmentation method
john smith
mkitkinsightuser at gmail.com
Tue Apr 12 12:49:03 EDT 2011
I made this change and I reran my program. But is still running without any
result.Could you have a look at the code for any mistakes?
2011/4/12 Sergio Vera <sergio.vera at alma3d.com>
> Hi John
>
> It all comes down to see if this same code is being compiled in Debug mode
> (very slow) or in Release mode (much faster)
> The setting of release/debug is compiler/IDE dependant. You have to select
> one or another. Probably, you are compiling by default in Debug mode.
>
> 1 hour doing a complex task is not strange when using Debug Code on 3D
> images if they are big enough. Check your compiler settings to see how to
> switch to release mode and rerun the example.
>
> Regards
>
> On Tue, Apr 12, 2011 at 1:17 PM, john smith <mkitkinsightuser at gmail.com>wrote:
>
>> Here is the code for "GeodesicActiveContourImageFilter". It is quite
>> similar with the "ShapeDetectionLevelSetFilter". I took it drom the software
>> guide for itk, but I use it for 3D image.
>>
>> ////////// code /////////////////
>>
>> /*=========================================================================
>>
>> Program: Insight Segmentation & Registration Toolkit
>> Module: $RCSfile: GeodesicActiveContourImageFilter.cxx,v $
>> Language: C++
>> Date: $Date: 2009-03-17 21:44:42 $
>> Version: $Revision: 1.45 $
>>
>> Copyright (c) Insight Software Consortium. All rights reserved.
>> See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for
>> details.
>>
>> This software is distributed WITHOUT ANY WARRANTY; without even
>> the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
>> PURPOSE. See the above copyright notices for more information.
>>
>>
>> =========================================================================*/
>> #if defined(_MSC_VER)
>> #pragma warning ( disable : 4786 )
>> #endif
>>
>> #ifdef __BORLANDC__
>> #define ITK_LEAN_AND_MEAN
>> #endif
>>
>> // Software Guide : BeginCommandLineArgs
>> // INPUTS: {BrainProtonDensitySlice.png}
>> // OUTPUTS: {GeodesicActiveContourImageFilterOutput5.png}
>> // 81 114 5 1.0 -0.5 3.0 2
>> // Software Guide : EndCommandLineArgs
>> // Software Guide : BeginCommandLineArgs
>> // INPUTS: {BrainProtonDensitySlice.png}
>> // OUTPUTS: {GeodesicActiveContourImageFilterOutput6.png}
>> // 99 114 5 1.0 -0.5 3.0 2
>> // Software Guide : EndCommandLineArgs
>> // Software Guide : BeginCommandLineArgs
>> // INPUTS: {BrainProtonDensitySlice.png}
>> // OUTPUTS: {GeodesicActiveContourImageFilterOutput8.png}
>> // 40 90 5 0.5 -0.3 2.0 10
>> // Software Guide : EndCommandLineArgs
>> // Software Guide : BeginCommandLineArgs
>> // INPUTS: {BrainProtonDensitySlice.png}
>> // OUTPUTS: {GeodesicActiveContourImageFilterOutput7.png}
>> // OUTPUTS: [GeodesicActiveContourImageFilterOutput1.png]
>> // OUTPUTS: [GeodesicActiveContourImageFilterOutput2.png]
>> // OUTPUTS: [GeodesicActiveContourImageFilterOutput3.png]
>> // 56 92 5 1.0 -0.3 2.0 10
>> // Software Guide : EndCommandLineArgs
>>
>> // Software Guide : BeginLatex
>> //
>> // The use of the \doxygen{GeodesicActiveContourLevelSetImageFilter} is
>> // illustrated in the following example. The implementation of this filter
>> in
>> // ITK is based on the paper by Caselles \cite{Caselles1997}. This
>> // implementation extends the functionality of the
>> // \doxygen{ShapeDetectionLevelSetImageFilter} by the addition of a third
>> // advection term which attracts the level set to the object boundaries.
>> //
>> // GeodesicActiveContourLevelSetImageFilter expects two inputs. The first
>> is
>> // an initial level set in the form of an \doxygen{Image}. The second
>> input
>> // is a feature image. For this algorithm, the feature image is an edge
>> // potential image that basically follows the same rules used for the
>> // ShapeDetectionLevelSetImageFilter discussed in
>> // Section~\ref{sec:ShapeDetectionLevelSetFilter}. The configuration of
>> this
>> // example is quite similar to the example on the use of the
>> // ShapeDetectionLevelSetImageFilter. We omit most of the redundant
>> // description. A look at the code will reveal the great degree of
>> similarity
>> // between both examples.
>> //
>> // \begin{figure} \center
>> //
>> \includegraphics[width=\textwidth]{GeodesicActiveContoursCollaborationDiagram1.eps}
>> // \itkcaption[GeodesicActiveContourLevelSetImageFilter collaboration
>> // diagram]{Collaboration diagram for the
>> GeodesicActiveContourLevelSetImageFilter
>> // applied to a segmentation task.}
>> // \label{fig:GeodesicActiveContoursCollaborationDiagram}
>> // \end{figure}
>> //
>> // Figure~\ref{fig:GeodesicActiveContoursCollaborationDiagram} shows the
>> major
>> // components involved in the application of the
>> // GeodesicActiveContourLevelSetImageFilter to a segmentation task.
>> // This pipeline is quite similar to the one used by the
>> // ShapeDetectionLevelSetImageFilter in
>> // section~\ref{sec:ShapeDetectionLevelSetFilter}.
>> //
>> // The pipeline involves a first stage of smoothing using the
>> // \doxygen{CurvatureAnisotropicDiffusionImageFilter}. The smoothed image
>> is
>> // passed as the input to the
>> // \doxygen{GradientMagnitudeRecursiveGaussianImageFilter} and then to the
>> // \doxygen{SigmoidImageFilter} in order to produce the edge potential
>> image.
>> // A set of user-provided seeds is passed to a
>> // \doxygen{FastMarchingImageFilter} in order to compute the distance map.
>> A
>> // constant value is subtracted from this map in order to obtain a level
>> set
>> // in which the \emph{zero set} represents the initial contour. This level
>> // set is also passed as input to the
>> // GeodesicActiveContourLevelSetImageFilter.
>> //
>> // Finally, the level set generated by the
>> // GeodesicActiveContourLevelSetImageFilter is passed to a
>> // \doxygen{BinaryThresholdImageFilter} in order to produce a binary mask
>> // representing the segmented object.
>> //
>> // Let's start by including the headers of the main filters involved in
>> the
>> // preprocessing.
>> //
>> // Software Guide : EndLatex
>>
>>
>> // Software Guide : BeginCodeSnippet
>> #include "itkImage.h"
>> #include "itkGeodesicActiveContourLevelSetImageFilter.h"
>> // Software Guide : EndCodeSnippet
>>
>>
>> #include "itkCurvatureAnisotropicDiffusionImageFilter.h"
>> #include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
>> #include "itkSigmoidImageFilter.h"
>> #include "itkFastMarchingImageFilter.h"
>> #include "itkRescaleIntensityImageFilter.h"
>> #include "itkBinaryThresholdImageFilter.h"
>> #include "itkImageFileReader.h"
>> #include "itkImageFileWriter.h"
>>
>>
>> int main( int argc, char *argv[] )
>> {
>> if( argc < 11 )
>> {
>> std::cerr << "Missing Parameters " << std::endl;
>> std::cerr << "Usage: " << argv[0];
>> std::cerr << " inputImage outputImage";
>> std::cerr << " seedX seedY seedZ InitialDistance";
>> std::cerr << " Sigma SigmoidAlpha SigmoidBeta";
>> std::cerr << " PropagationScaling" << std::endl;
>> return 1;
>> }
>>
>>
>> // Software Guide : BeginLatex
>> //
>> // We now define the image type using a particular pixel type and
>> // dimension. In this case the \code{float} type is used for the pixels
>> // due to the requirements of the smoothing filter.
>> //
>> // Software Guide : EndLatex
>>
>> // Software Guide : BeginCodeSnippet
>> typedef float InternalPixelType;
>> const unsigned int Dimension = 3;
>> typedef itk::Image< InternalPixelType, Dimension > InternalImageType;
>> // Software Guide : EndCodeSnippet
>>
>>
>> // The following lines instantiate the thresholding filter that will
>> // process the final level set at the output of the
>> // GeodesicActiveContourLevelSetImageFilter.
>> //
>> typedef unsigned char OutputPixelType;
>> typedef itk::Image< OutputPixelType, Dimension > OutputImageType;
>> typedef itk::BinaryThresholdImageFilter<
>> InternalImageType,
>> OutputImageType > ThresholdingFilterType;
>>
>> ThresholdingFilterType::Pointer thresholder =
>> ThresholdingFilterType::New();
>>
>> thresholder->SetLowerThreshold( -1000.0 );
>> thresholder->SetUpperThreshold( 0.0 );
>>
>> thresholder->SetOutsideValue( 0 );
>> thresholder->SetInsideValue( 255 );
>>
>>
>> // We instantiate reader and writer types in the following lines.
>> //
>> typedef itk::ImageFileReader< InternalImageType > ReaderType;
>> typedef itk::ImageFileWriter< OutputImageType > WriterType;
>>
>> ReaderType::Pointer reader = ReaderType::New();
>> WriterType::Pointer writer = WriterType::New();
>>
>> reader->SetFileName( argv[1] );
>> writer->SetFileName( argv[2] );
>>
>>
>> // The RescaleIntensityImageFilter type is declared below. This filter
>> will
>> // renormalize image before sending them to writers.
>> //
>> typedef itk::RescaleIntensityImageFilter<
>> InternalImageType,
>> OutputImageType > CastFilterType;
>>
>>
>> // The \doxygen{CurvatureAnisotropicDiffusionImageFilter} type is
>> // instantiated using the internal image type.
>> //
>> typedef itk::CurvatureAnisotropicDiffusionImageFilter<
>> InternalImageType,
>> InternalImageType > SmoothingFilterType;
>>
>> SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New();
>>
>>
>> // The types of the
>> // GradientMagnitudeRecursiveGaussianImageFilter and
>> // SigmoidImageFilter are instantiated using the internal image
>> // type.
>> //
>> typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<
>> InternalImageType,
>> InternalImageType > GradientFilterType;
>> typedef itk::SigmoidImageFilter<
>> InternalImageType,
>> InternalImageType > SigmoidFilterType;
>>
>> GradientFilterType::Pointer gradientMagnitude =
>> GradientFilterType::New();
>>
>> SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New();
>>
>>
>> // The minimum and maximum values of the SigmoidImageFilter output
>> // are defined with the methods \code{SetOutputMinimum()} and
>> // \code{SetOutputMaximum()}. In our case, we want these two values to
>> be
>> // $0.0$ and $1.0$ respectively in order to get a nice speed image to
>> feed
>> // the \code{FastMarchingImageFilter}. Additional details on the user
>> of the
>> // \doxygen{SigmoidImageFilter} are presented in
>> // section~\ref{sec:IntensityNonLinearMapping}.
>>
>> sigmoid->SetOutputMinimum( 0.0 );
>> sigmoid->SetOutputMaximum( 1.0 );
>>
>>
>> // We declare now the type of the FastMarchingImageFilter that
>> // will be used to generate the initial level set in the form of a
>> distance
>> // map.
>> //
>> typedef itk::FastMarchingImageFilter<
>> InternalImageType,
>> InternalImageType >
>> FastMarchingFilterType;
>>
>>
>> // Next we construct one filter of this class using the \code{New()}
>> // method.
>> //
>> FastMarchingFilterType::Pointer fastMarching =
>> FastMarchingFilterType::New();
>>
>> // Software Guide : BeginLatex
>> //
>> // In the following lines we instantiate the type of the
>> // GeodesicActiveContourLevelSetImageFilter and create an object of
>> this
>> // type using the \code{New()} method.
>> //
>> // Software Guide : EndLatex
>>
>> // Software Guide : BeginCodeSnippet
>> typedef itk::GeodesicActiveContourLevelSetImageFilter<
>> InternalImageType,
>> InternalImageType > GeodesicActiveContourFilterType;
>> GeodesicActiveContourFilterType::Pointer geodesicActiveContour =
>>
>> GeodesicActiveContourFilterType::New();
>> // Software Guide : EndCodeSnippet
>>
>>
>> // Software Guide : BeginLatex
>> //
>> // For the GeodesicActiveContourLevelSetImageFilter, scaling parameters
>> // are used to trade off between the propagation (inflation), the
>> // curvature (smoothing) and the advection terms. These parameters are
>> set
>> // using methods \code{SetPropagationScaling()},
>> // \code{SetCurvatureScaling()} and \code{SetAdvectionScaling()}. In
>> this
>> // example, we will set the curvature and advection scales to one and
>> let
>> // the propagation scale be a command-line argument.
>> //
>> //
>> \index{itk::Geodesic\-Active\-Contour\-LevelSet\-Image\-Filter!SetPropagationScaling()}
>> //
>> \index{itk::Segmentation\-Level\-Set\-Image\-Filter!SetPropagationScaling()}
>> //
>> \index{itk::Geodesic\-Active\-Contour\-LevelSet\-Image\-Filter!SetCurvatureScaling()}
>> //
>> \index{itk::Segmentation\-Level\-Set\-Image\-Filter!SetCurvatureScaling()}
>> //
>> \index{itk::Geodesic\-Active\-Contour\-LevelSet\-Image\-Filter!SetAdvectionScaling()}
>> //
>> \index{itk::Segmentation\-Level\-Set\-Image\-Filter!SetAdvectionScaling()}
>> //
>> // Software Guide : EndLatex
>>
>> const double propagationScaling = atof( argv[10] );
>>
>> // Software Guide : BeginCodeSnippet
>> geodesicActiveContour->SetPropagationScaling( propagationScaling );
>> geodesicActiveContour->SetCurvatureScaling( 1.0 );
>> geodesicActiveContour->SetAdvectionScaling( 1.0 );
>> // Software Guide : EndCodeSnippet
>>
>> // Once activiated the level set evolution will stop if the convergence
>> // criteria or if the maximum number of iterations is reached. The
>> // convergence criteria is defined in terms of the root mean squared
>> (RMS)
>> // change in the level set function. The evolution is said to have
>> // converged if the RMS change is below a user specified threshold. In
>> a
>> // real application is desirable to couple the evolution of the zero
>> set
>> // to a visualization module allowing the user to follow the evolution
>> of
>> // the zero set. With this feedback, the user may decide when to stop
>> the
>> // algorithm before the zero set leaks through the regions of low
>> gradient
>> // in the contour of the anatomical structure to be segmented.
>>
>> geodesicActiveContour->SetMaximumRMSError( 0.02 );
>> geodesicActiveContour->SetNumberOfIterations( 800 );
>>
>>
>> // Software Guide : BeginLatex
>> //
>> // The filters are now connected in a pipeline indicated in
>> // Figure~\ref{fig:GeodesicActiveContoursCollaborationDiagram} using
>> the
>> // following lines:
>> //
>> // Software Guide : EndLatex
>>
>> // Software Guide : BeginCodeSnippet
>> smoothing->SetInput( reader->GetOutput() );
>> gradientMagnitude->SetInput( smoothing->GetOutput() );
>> sigmoid->SetInput( gradientMagnitude->GetOutput() );
>>
>> geodesicActiveContour->SetInput( fastMarching->GetOutput() );
>> geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() );
>>
>> thresholder->SetInput( geodesicActiveContour->GetOutput() );
>> writer->SetInput( thresholder->GetOutput() );
>> // Software Guide : EndCodeSnippet
>>
>>
>> // The CurvatureAnisotropicDiffusionImageFilter requires a couple of
>> // parameter to be defined. The following are typical values for $2D$
>> // images. However they may have to be adjusted depending on the amount
>> of
>> // noise present in the input image. This filter has been discussed in
>> // section~\ref{sec:GradientAnisotropicDiffusionImageFilter}.
>>
>> smoothing->SetTimeStep( 0.0625 );
>> smoothing->SetNumberOfIterations( 5 );
>> smoothing->SetConductanceParameter( 9.0 );
>>
>>
>> // The GradientMagnitudeRecursiveGaussianImageFilter performs the
>> // equivalent of a convolution with a Gaussian kernel, followed by a
>> // derivative operator. The sigma of this Gaussian can be used to
>> control
>> // the range of influence of the image edges. This filter has been
>> discussed
>> // in Section~\ref{sec:GradientMagnitudeRecursiveGaussianImageFilter}
>>
>> const double sigma = atof( argv[7] );
>> gradientMagnitude->SetSigma( sigma );
>>
>>
>> // The SigmoidImageFilter requires two parameters that define the
>> linear
>> // transformation to be applied to the sigmoid argument. This
>> parameters
>> // have been discussed in Sections~\ref{sec:IntensityNonLinearMapping}
>> and
>> // \ref{sec:FastMarchingImageFilter}.
>>
>> const double alpha = atof( argv[8] );
>> const double beta = atof( argv[9] );
>>
>> sigmoid->SetAlpha( alpha );
>> sigmoid->SetBeta( beta );
>>
>>
>> // The FastMarchingImageFilter requires the user to provide a seed
>> // point from which the level set will be generated. The user can
>> actually
>> // pass not only one seed point but a set of them. Note the the
>> // FastMarchingImageFilter is used here only as a helper in the
>> // determination of an initial level set. We could have used the
>> // \doxygen{DanielssonDistanceMapImageFilter} in the same way.
>> //
>> // The seeds are passed stored in a container. The type of this
>> // container is defined as \code{NodeContainer} among the
>> // FastMarchingImageFilter traits.
>> //
>> typedef FastMarchingFilterType::NodeContainer NodeContainer;
>> typedef FastMarchingFilterType::NodeType NodeType;
>>
>> NodeContainer::Pointer seeds = NodeContainer::New();
>>
>> InternalImageType::IndexType seedPosition;
>>
>> seedPosition[0] = atoi( argv[3] );
>> seedPosition[1] = atoi( argv[4] );
>> seedPosition[2] = atoi( argv[5] );
>>
>> // Nodes are created as stack variables and initialized with a value
>> and an
>> // \doxygen{Index} position. Note that here we assign the value of
>> minus the
>> // user-provided distance to the unique node of the seeds passed to the
>> // FastMarchingImageFilter. In this way, the value will increment
>> // as the front is propagated, until it reaches the zero value
>> corresponding
>> // to the contour. After this, the front will continue propagating
>> until it
>> // fills up the entire image. The initial distance is taken here from
>> the
>> // command line arguments. The rule of thumb for the user is to select
>> this
>> // value as the distance from the seed points at which she want the
>> initial
>> // contour to be.
>> const double initialDistance = atof( argv[6] );
>>
>> NodeType node;
>>
>> const double seedValue = - initialDistance;
>>
>> node.SetValue( seedValue );
>> node.SetIndex( seedPosition );
>>
>>
>> // The list of nodes is initialized and then every node is inserted
>> using
>> // the \code{InsertElement()}.
>>
>> seeds->Initialize();
>> seeds->InsertElement( 0, node );
>>
>>
>> // The set of seed nodes is passed now to the
>> // FastMarchingImageFilter with the method
>> // \code{SetTrialPoints()}.
>> //
>> fastMarching->SetTrialPoints( seeds );
>>
>>
>> // Since the FastMarchingImageFilter is used here just as a
>> // Distance Map generator. It does not require a speed image as input.
>> // Instead the constant value $1.0$ is passed using the
>> // \code{SetSpeedConstant()} method.
>> //
>> fastMarching->SetSpeedConstant( 1.0 );
>>
>>
>> // Here we configure all the writers required to see the intermediate
>> // outputs of the pipeline. This is added here only for
>> // pedagogical/debugging purposes. These intermediate output are
>> normaly not
>> // required. Only the output of the final thresholding filter should be
>> // relevant. Observing intermediate output is helpful in the process
>> of
>> // fine tuning the parameters of filters in the pipeline.
>> //
>> CastFilterType::Pointer caster1 = CastFilterType::New();
>> CastFilterType::Pointer caster2 = CastFilterType::New();
>> CastFilterType::Pointer caster3 = CastFilterType::New();
>> CastFilterType::Pointer caster4 = CastFilterType::New();
>>
>> WriterType::Pointer writer1 = WriterType::New();
>> WriterType::Pointer writer2 = WriterType::New();
>> WriterType::Pointer writer3 = WriterType::New();
>> WriterType::Pointer writer4 = WriterType::New();
>>
>> caster1->SetInput( smoothing->GetOutput() );
>> writer1->SetInput( caster1->GetOutput() );
>> writer1->SetFileName("GeodesicActiveContourImageFilterOutput1.hdr");
>> caster1->SetOutputMinimum( 0 );
>> caster1->SetOutputMaximum( 255 );
>> writer1->Update();
>>
>> caster2->SetInput( gradientMagnitude->GetOutput() );
>> writer2->SetInput( caster2->GetOutput() );
>> writer2->SetFileName("GeodesicActiveContourImageFilterOutput2.hdr");
>> caster2->SetOutputMinimum( 0 );
>> caster2->SetOutputMaximum( 255 );
>> writer2->Update();
>>
>> caster3->SetInput( sigmoid->GetOutput() );
>> writer3->SetInput( caster3->GetOutput() );
>> writer3->SetFileName("GeodesicActiveContourImageFilterOutput3.hdr");
>> caster3->SetOutputMinimum( 0 );
>> caster3->SetOutputMaximum( 255 );
>> writer3->Update();
>>
>> caster4->SetInput( fastMarching->GetOutput() );
>> writer4->SetInput( caster4->GetOutput() );
>> writer4->SetFileName("GeodesicActiveContourImageFilterOutput4.hdr");
>> caster4->SetOutputMinimum( 0 );
>> caster4->SetOutputMaximum( 255 );
>>
>>
>> // The FastMarchingImageFilter requires the user to specify the
>> // size of the image to be produced as output. This is done using the
>> // \code{SetOutputSize()}. Note that the size is obtained here from the
>> // output image of the smoothing filter. The size of this image is
>> valid
>> // only after the \code{Update()} methods of this filter has been
>> called
>> // directly or indirectly.
>> //
>> fastMarching->SetOutputSize(
>> reader->GetOutput()->GetBufferedRegion().GetSize() );
>>
>>
>> // Software Guide : BeginLatex
>> //
>> // The invocation of the \code{Update()} method on the writer triggers
>> the
>> // execution of the pipeline. As usual, the call is placed in a
>> // \code{try/catch} block should any errors occur or exceptions be
>> thrown.
>> //
>> // Software Guide : EndLatex
>>
>> // Software Guide : BeginCodeSnippet
>> try
>> {
>> writer->Update();
>> }
>> catch( itk::ExceptionObject & excep )
>> {
>> std::cerr << "Exception caught !" << std::endl;
>> std::cerr << excep << std::endl;
>> }
>> // Software Guide : EndCodeSnippet
>>
>> // Print out some useful information
>> std::cout << std::endl;
>> std::cout << "Max. no. iterations: " <<
>> geodesicActiveContour->GetNumberOfIterations() << std::endl;
>> std::cout << "Max. RMS error: " <<
>> geodesicActiveContour->GetMaximumRMSError() << std::endl;
>> std::cout << std::endl;
>> std::cout << "No. elpased iterations: " <<
>> geodesicActiveContour->GetElapsedIterations() << std::endl;
>> std::cout << "RMS change: " << geodesicActiveContour->GetRMSChange() <<
>> std::endl;
>>
>> writer4->Update();
>>
>>
>> // The following writer type is used to save the output of the
>> time-crossing
>> // map in a file with apropiate pixel representation. The advantage of
>> saving
>> // this image in native format is that it can be used with a viewer to
>> help
>> // determine an appropriate threshold to be used on the output of the
>> // fastmarching filter.
>> //
>> // typedef itk::ImageFileWriter< InternalImageType > InternalWriterType;
>>
>> // InternalWriterType::Pointer mapWriter = InternalWriterType::New();
>> // mapWriter->SetInput( fastMarching->GetOutput() );
>> // mapWriter->SetFileName("GeodesicActiveContourImageFilterOutput4.mha");
>> // mapWriter->Update();
>>
>> // InternalWriterType::Pointer speedWriter = InternalWriterType::New();
>> // speedWriter->SetInput( sigmoid->GetOutput() );
>> //
>> speedWriter->SetFileName("GeodesicActiveContourImageFilterOutput3.mha");
>> // speedWriter->Update();
>>
>> // InternalWriterType::Pointer gradientWriter =
>> InternalWriterType::New();
>> // gradientWriter->SetInput( gradientMagnitude->GetOutput() );
>> //
>> gradientWriter->SetFileName("GeodesicActiveContourImageFilterOutput2.mha");
>> // gradientWriter->Update();
>>
>>
>> // Software Guide : BeginLatex
>> //
>> // Let's now run this example using as input the image
>> // \code{BrainProtonDensitySlice.png} provided in the directory
>> // \code{Examples/Data}. We can easily segment the major anatomical
>> // structures by providing seeds in the appropriate locations.
>> // Table~\ref{tab:GeodesicActiveContourImageFilterOutput2} presents the
>> // parameters used for some structures.
>> //
>> // \begin{table}
>> // \begin{center}
>> // \begin{tabular}{|l|c|c|c|c|c|c|c|c|}
>> // \hline
>> // Structure & Seed Index & Distance & $\sigma$ &
>> // $\alpha$ & $\beta$ & Propag. & Output Image \\ \hline
>> // Left Ventricle & $(81,114)$ & 5.0 & 1.0 & -0.5 & 3.0 & 2.0 &
>> First \\ \hline
>> // Right Ventricle & $(99,114)$ & 5.0 & 1.0 & -0.5 & 3.0 & 2.0 &
>> Second \\ \hline
>> // White matter & $(56, 92)$ & 5.0 & 1.0 & -0.3 & 2.0 & 10.0 &
>> Third \\ \hline
>> // Gray matter & $(40, 90)$ & 5.0 & 0.5 & -0.3 & 2.0 & 10.0 &
>> Fourth \\ \hline
>> // \end{tabular}
>> // \end{center}
>> // \itkcaption[GeodesicActiveContour segmentation example
>> parameters]{Parameters used
>> // for segmenting some brain structures shown in
>> // Figure~\ref{fig:GeodesicActiveContourImageFilterOutput2} using the
>> filter
>> // GeodesicActiveContourLevelSetImageFilter.
>> // \label{tab:GeodesicActiveContourImageFilterOutput2}}
>> // \end{table}
>> //
>> // Figure~\ref{fig:GeodesicActiveContourImageFilterOutput} presents the
>> // intermediate outputs of the pipeline illustrated in
>> // Figure~\ref{fig:GeodesicActiveContoursCollaborationDiagram}. They
>> are
>> // from left to right: the output of the anisotropic diffusion filter,
>> the
>> // gradient magnitude of the smoothed image and the sigmoid of the
>> gradient
>> // magnitude which is finally used as the edge potential for the
>> // GeodesicActiveContourLevelSetImageFilter.
>> //
>> // \begin{figure} \center
>> // \includegraphics[height=0.40\textheight]{BrainProtonDensitySlice.eps}
>> //
>> \includegraphics[height=0.40\textheight]{GeodesicActiveContourImageFilterOutput1.eps}
>> //
>> \includegraphics[height=0.40\textheight]{GeodesicActiveContourImageFilterOutput2.eps}
>> //
>> \includegraphics[height=0.40\textheight]{GeodesicActiveContourImageFilterOutput3.eps}
>> // \itkcaption[GeodesicActiveContourLevelSetImageFilter intermediate
>> // output]{Images generated by the segmentation process based on the
>> // GeodesicActiveContourLevelSetImageFilter. From left to right and top
>> to
>> // bottom: input image to be segmented, image smoothed with an
>> // edge-preserving smoothing filter, gradient magnitude of the smoothed
>> // image, sigmoid of the gradient magnitude. This last image, the
>> sigmoid, is
>> // used to compute the speed term for the front propagation.}
>> // \label{fig:GeodesicActiveContourImageFilterOutput} \end{figure}
>> //
>> // Segmentations of the main brain structures are presented in
>> // Figure~\ref{fig:GeodesicActiveContourImageFilterOutput2}. The
>> results
>> // are quite similar to those obtained with the
>> // ShapeDetectionLevelSetImageFilter in
>> // Section~\ref{sec:ShapeDetectionLevelSetFilter}.
>> //
>> // Note that a relatively larger propagation scaling value was required
>> to
>> // segment the white matter. This is due to two factors: the lower
>> // contrast at the border of the white matter and the complex shape of
>> the
>> // structure. Unfortunately the optimal value of these scaling
>> parameters
>> // can only be determined by experimentation. In a real application we
>> // could imagine an interactive mechanism by which a user supervises
>> the
>> // contour evolution and adjusts these parameters accordingly.
>> //
>> // \begin{figure} \center
>> //
>> \includegraphics[width=0.24\textwidth]{GeodesicActiveContourImageFilterOutput5.eps}
>> //
>> \includegraphics[width=0.24\textwidth]{GeodesicActiveContourImageFilterOutput6.eps}
>> //
>> \includegraphics[width=0.24\textwidth]{GeodesicActiveContourImageFilterOutput7.eps}
>> //
>> \includegraphics[width=0.24\textwidth]{GeodesicActiveContourImageFilterOutput8.eps}
>> // \itkcaption[GeodesicActiveContourImageFilter segmentations]{Images
>> generated by the
>> // segmentation process based on the GeodesicActiveContourImageFilter.
>> From left to
>> // right: segmentation of the left ventricle, segmentation of the right
>> // ventricle, segmentation of the white matter, attempt of segmentation
>> of
>> // the gray matter.}
>> // \label{fig:GeodesicActiveContourImageFilterOutput2}
>> // \end{figure}
>> //
>> // Software Guide : EndLatex
>>
>> return 0;
>>
>> }
>>
>>
>>
>>
>>
>>
>>
>>
>> 2011/4/12 Sergio Vera <sergio.vera at alma3d.com>
>>
>>> Hi John
>>> Debug or Release Code?
>>>
>>> On Tue, Apr 12, 2011 at 11:54 AM, john smith <mkitkinsightuser at gmail.com
>>> > wrote:
>>>
>>>> Hello to everyone,
>>>>
>>>> I am running the "ShapeDetectionLevelSetFilter", but for 3D images. The
>>>> runnung time has overcome the 1 hour and it is still running. Is it normal?
>>>> How is the average time for running a level set segmentation method for a 3D
>>>> image?
>>>>
>>>> Thnaks
>>>>
>>>> _____________________________________
>>>> Powered by www.kitware.com
>>>>
>>>> Visit other Kitware open-source projects at
>>>> http://www.kitware.com/opensource/opensource.html
>>>>
>>>> Kitware offers ITK Training Courses, for more information visit:
>>>> http://www.kitware.com/products/protraining.html
>>>>
>>>> Please keep messages on-topic and check the ITK FAQ at:
>>>> http://www.itk.org/Wiki/ITK_FAQ
>>>>
>>>> Follow this link to subscribe/unsubscribe:
>>>> http://www.itk.org/mailman/listinfo/insight-users
>>>>
>>>>
>>>
>>>
>>> --
>>> Sergio Vera
>>>
>>> Alma IT Systems
>>> C/ Vilana, 4B, 4º 1ª
>>> 08022 Barcelona
>>> T. (+34) 932 380 592
>>> www.alma3d.com
>>>
>>
>>
>
>
> --
> Sergio Vera
>
> Alma IT Systems
> C/ Vilana, 4B, 4º 1ª
> 08022 Barcelona
> T. (+34) 932 380 592
> www.alma3d.com
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.itk.org/pipermail/insight-users/attachments/20110412/6cc2260d/attachment.htm>
More information about the Insight-users
mailing list