Exemples ImageAdaptor

Examples/DataRepresentation/Image/CMakeLists.txt

@@ -24,15 +24,15 @@ TARGET_LINK_LIBRARIES(RGBImage OTBCommon OTBIO ITKCommon ITKIO)
 ADD_EXECUTABLE(VectorImage VectorImage.cxx )
 TARGET_LINK_LIBRARIES(VectorImage OTBCommon ITKCommon OTBIO ITKIO)
 
-#ADD_EXECUTABLE(ImageAdaptor1 ImageAdaptor1.cxx )
-#TARGET_LINK_LIBRARIES(ImageAdaptor1 ITKCommon ITKIO)
+ADD_EXECUTABLE(ImageAdaptor1 ImageAdaptor1.cxx )
+TARGET_LINK_LIBRARIES(ImageAdaptor1 OTBCommon ITKCommon OTBIO ITKIO)
 
-#ADD_EXECUTABLE(ImageAdaptor2 ImageAdaptor2.cxx )
-#TARGET_LINK_LIBRARIES(ImageAdaptor2 ITKCommon ITKIO)
+ADD_EXECUTABLE(ImageAdaptor2 ImageAdaptor2.cxx )
+TARGET_LINK_LIBRARIES(ImageAdaptor2 OTBCommon ITKCommon OTBIO ITKIO)
 
-#ADD_EXECUTABLE(ImageAdaptor3 ImageAdaptor3.cxx )
-#TARGET_LINK_LIBRARIES(ImageAdaptor3 ITKCommon ITKIO)
+ADD_EXECUTABLE(ImageAdaptor3 ImageAdaptor3.cxx )
+TARGET_LINK_LIBRARIES(ImageAdaptor3 OTBCommon ITKCommon OTBIO ITKIO)
 
-#ADD_EXECUTABLE(ImageAdaptor4 ImageAdaptor4.cxx )
-#TARGET_LINK_LIBRARIES(ImageAdaptor4 ITKCommon ITKIO)
+ADD_EXECUTABLE(ImageAdaptor4 ImageAdaptor4.cxx )
+TARGET_LINK_LIBRARIES(ImageAdaptor4 OTBCommon ITKCommon OTBIO ITKIO)
 

Examples/DataRepresentation/Image/ImageAdaptor1.cxx

+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile: ImageAdaptor1.cxx,v $
+  Language:  C++
+  Date:      $Date: 2004/12/28 14:45:15 $
+  Version:   $Revision: 1.12 $
+
+  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
+
+
+// Software Guide : BeginLatex
+//
+//This example illustrates how the \doxygen{itk}{ImageAdaptor} can be used to cast 
+// an image from one pixel type to another. In particular, we will 
+// \emph{adapt} an \code{unsigned char} image to make it appear as an image of 
+// pixel type \code{float}.
+// 
+// \index{itk::ImageAdaptor!Instantiation}
+// \index{itk::ImageAdaptor!Header}
+//
+// We begin by including the relevant headers.
+//
+// Software Guide : EndLatex 
+
+// Software Guide : BeginCodeSnippet
+#include "otbImage.h"
+#include "itkImageAdaptor.h"
+// Software Guide : EndCodeSnippet
+
+
+#include "itkImageRegionIteratorWithIndex.h"
+#include "otbImageFileReader.h"
+
+
+//  Software Guide : BeginLatex
+//
+// First, we need to define a \emph{pixel accessor} class that does the actual
+// conversion. Note that in general, the only valid operations for pixel 
+// accessors are those that only require the value of the input pixel. As 
+// such, neighborhood type operations are not possible. A pixel accessor must 
+// provide methods \code{Set()} and \code{Get()}, and define the types of 
+// \code{InternalPixelType} and \code{ExternalPixelType}. The 
+// \code{InternalPixelType} corresponds to the pixel type of the image to be 
+// adapted (\code{unsigned char} in this example). The \code{ExternalPixelType}
+// corresponds to the pixel type we wish to emulate with the ImageAdaptor 
+// (\code{float} in this case). 
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+class CastPixelAccessor  
+{
+public:
+  typedef unsigned char InternalType;
+  typedef float         ExternalType;
+
+  static void Set(InternalType & output, const ExternalType & input) 
+    {
+      output = static_cast<InternalType>( input );
+    }
+
+  static ExternalType Get( const InternalType & input ) 
+    {
+      return static_cast<ExternalType>( input );
+    }
+};
+// Software Guide : EndCodeSnippet
+
+
+//-------------------------
+//
+//   Main code
+//
+//-------------------------
+
+int main( int argc, char *argv[] ) 
+{
+  if( argc < 2 )
+    {
+    std::cerr << "Usage: " << std::endl;
+    std::cerr << "ImageAdaptor1   inputFileName" << std::endl;
+    return -1;
+    }
+
+
+//  Software Guide : BeginLatex
+//
+//  The CastPixelAccessor class simply applies a
+//  \code{static\_cast} to the pixel values. We now use this pixel accessor
+//  to define the image adaptor type and create an instance using
+//  the standard \code{New()} method.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef unsigned char  InputPixelType;
+  const   unsigned int   Dimension = 2;
+  typedef otb::Image< InputPixelType, Dimension >   ImageType;
+
+  typedef itk::ImageAdaptor< ImageType, CastPixelAccessor > ImageAdaptorType;
+  ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New();
+// Software Guide : EndCodeSnippet
+
+// Software Guide : BeginLatex
+//
+// We also create an image reader templated over the input image type and
+// read the input image from file.
+//
+// Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef otb::ImageFileReader< ImageType >   ReaderType;
+  ReaderType::Pointer reader = ReaderType::New();  
+// Software Guide : EndCodeSnippet
+
+
+  reader->SetFileName( argv[1] );
+  reader->Update();
+
+
+//  Software Guide : BeginLatex
+//
+//  The output of the reader is then connected as the input to the image
+//  adaptor.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  adaptor->SetImage( reader->GetOutput() );
+// Software Guide : EndCodeSnippet
+ 
+
+//  Software Guide : BeginLatex
+//
+//  In the following code, we visit the image using an iterator 
+//  instantiated using the adapted image type and compute the
+//  sum of the pixel values.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef itk::ImageRegionIteratorWithIndex< ImageAdaptorType >  IteratorType;
+  IteratorType  it( adaptor, adaptor->GetBufferedRegion() );
+
+  double sum = 0.0;
+  it.GoToBegin();
+  while( !it.IsAtEnd() )
+    {
+    float value = it.Get();
+    sum += value;
+    ++it;
+    }
+// Software Guide : EndCodeSnippet
+
+
+std::cout << "Sum of pixels is: " << sum << std::endl;
+
+
+//  Software Guide : BeginLatex
+//
+// Although in this example, we are just performing a simple summation, the key 
+// concept is that access to pixels is performed as if the pixel is of type
+//  \code{float}. Additionally, it should be noted that the adaptor is used 
+// as if it was an actual image and not as a filter. ImageAdaptors conform 
+// to the same API as the  \doxygen{otb}{Image} class.
+//
+//  Software Guide : EndLatex 
+
+
+  return 0;
+}
+
+
+

Examples/DataRepresentation/Image/ImageAdaptor2.cxx

+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile: ImageAdaptor2.cxx,v $
+  Language:  C++
+  Date:      $Date: 2005/11/20 13:27:52 $
+  Version:   $Revision: 1.14 $
+
+  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
+
+
+// Software Guide : BeginLatex
+//
+// This example illustrates how to use the \doxygen{itk}{ImageAdaptor}
+// to access the individual components of an RGB image. In this case, we 
+// create an ImageAdaptor that will accept a RGB image as input and 
+// presents it as a scalar image. The pixel data
+// will be taken directly from the red channel of the original image.
+// 
+// \index{itk::ImageAdaptor!Instantiation}
+// \index{itk::ImageAdaptor!Header}
+//
+// Software Guide : EndLatex 
+
+#include "otbImage.h"
+#include "itkImageAdaptor.h"
+#include "itkImageRegionIteratorWithIndex.h"
+#include "otbImageFileReader.h"
+#include "otbImageFileWriter.h"
+#include "itkRescaleIntensityImageFilter.h"
+
+
+//  Software Guide : BeginLatex
+//
+//  As with the previous example, the bulk of the effort in creating the image 
+//  adaptor is associated with the definition of the pixel accessor class. In 
+//  this case, the accessor converts a RGB vector to a scalar containing the 
+//  red channel component. Note that in the following, we do not need to define
+//  the \code{Set()} method since we only expect the adaptor to be used for 
+//  reading data from the image.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+class RedChannelPixelAccessor  
+{
+public:
+  typedef itk::RGBPixel<float>   InternalType;
+  typedef               float    ExternalType;
+
+  static ExternalType Get( const InternalType & input ) 
+    {
+      return static_cast<ExternalType>( input.GetRed() );
+    }
+};
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  The \code{Get()} method simply calls the \code{GetRed()} method
+//  defined in the \doxygen{itk}{RGBPixel} class.
+//
+//  Software Guide : EndLatex 
+
+
+//-------------------------
+//
+//   Main code
+//
+//-------------------------
+
+int main( int argc, char *argv[] ) 
+{
+  if( argc < 3 )
+    {
+    std::cerr << "Usage: " << std::endl;
+    std::cerr << "ImageAdaptor2   inputRGBFileName outputRedChannelFileName" << std::endl;
+    return -1;
+    }
+
+
+//  Software Guide : BeginLatex
+//
+//  Now we use the internal pixel type of the pixel accessor to define the
+//  input image type, and then proceed to instantiate the ImageAdaptor type.
+//
+//  \index{PixelAccessor!RGB red channel}
+//  \index{itk::ImageAdaptor!RGB red channel}
+//  \index{ImageAdaptor!RGB red channel}
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef RedChannelPixelAccessor::InternalType  InputPixelType;
+  const   unsigned int   Dimension = 2;
+  typedef otb::Image< InputPixelType, Dimension >   ImageType;
+
+  typedef itk::ImageAdaptor<  ImageType, 
+                              RedChannelPixelAccessor > ImageAdaptorType;
+
+  ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New();
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  We create an image reader and connect the output to the adaptor
+//  as before.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef otb::ImageFileReader< ImageType >   ReaderType;
+  ReaderType::Pointer reader = ReaderType::New();  
+// Software Guide : EndCodeSnippet
+
+  reader->SetFileName( argv[1] );
+  reader->Update();
+
+// Software Guide : BeginCodeSnippet
+  adaptor->SetImage( reader->GetOutput() );
+// Software Guide : EndCodeSnippet
+ 
+
+//  Software Guide : BeginLatex
+//
+//  We create an \doxygen{itk}{RescaleIntensityImageFilter} and an
+//  \doxygen{otb}{ImageFileWriter} to rescale the dynamic range of the pixel values
+//  and send the extracted channel to an image file. Note that the image type
+//  used for the rescaling filter is the \code{ImageAdaptorType} itself. That
+//  is, the adaptor type is used in the same context as an image type.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef otb::Image< unsigned char, Dimension >   OutputImageType;
+  typedef itk::RescaleIntensityImageFilter< ImageAdaptorType, 
+                                            OutputImageType 
+                                               >   RescalerType;
+
+  RescalerType::Pointer rescaler = RescalerType::New();
+  typedef otb::ImageFileWriter< OutputImageType >   WriterType;
+  WriterType::Pointer writer = WriterType::New();
+// Software Guide : EndCodeSnippet
+
+
+  writer->SetFileName( argv[2] );
+
+
+//  Software Guide : BeginLatex
+//
+//  Now we connect the adaptor as the input to the rescaler and set the
+//  parameters for the intensity rescaling.
+//
+//  Software Guide : EndLatex 
+
+// Software Guide : BeginCodeSnippet
+  rescaler->SetOutputMinimum(  0  );
+  rescaler->SetOutputMaximum( 255 );
+
+  rescaler->SetInput( adaptor );
+  writer->SetInput( rescaler->GetOutput() );
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  Finally, we invoke the \code{Update()} method on the writer and take
+//  precautions to catch any exception that may be thrown during
+//  the execution of the pipeline. 
+//
+//  Software Guide : EndLatex 
+
+// Software Guide : BeginCodeSnippet
+  try
+    {
+    writer->Update();
+    }
+  catch( itk::ExceptionObject & excp )
+    {
+    std::cerr << "Exception caught " << excp << std::endl;
+    return 1;
+    }
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  ImageAdaptors for the green and blue channels can easily be implemented by
+//  modifying the pixel accessor of the red channel and then using the
+//  new pixel accessor for instantiating the type of an image adaptor. 
+//  The following define a green channel pixel accessor.
+//
+//  \index{PixelAccessor!RGB green channel}
+//  \index{itk::ImageAdaptor!RGB green channel}
+//  \index{ImageAdaptor!RGB green channel}
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  class GreenChannelPixelAccessor  
+  {
+  public:
+    typedef itk::RGBPixel<float>   InternalType;
+    typedef               float    ExternalType;
+
+    static ExternalType Get( const InternalType & input ) 
+      {
+        return static_cast<ExternalType>( input.GetGreen() );
+      }
+  };
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+// A blue channel pixel accessor is similarly defined.
+//
+//  \index{PixelAccessor!RGB blue channel}
+//  \index{itk::ImageAdaptor!RGB blue channel}
+//  \index{ImageAdaptor!RGB blue channel}
+//
+//  Software Guide : EndLatex 
+
+// Software Guide : BeginCodeSnippet
+  class BlueChannelPixelAccessor  
+  {
+  public:
+    typedef itk::RGBPixel<float>   InternalType;
+    typedef               float    ExternalType;
+
+    static ExternalType Get( const InternalType & input ) 
+      {
+        return static_cast<ExternalType>( input.GetBlue() );
+      }
+  };
+// Software Guide : EndCodeSnippet
+
+
+
+  return 0;
+}
+
+
+

Examples/DataRepresentation/Image/ImageAdaptor3.cxx

+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile: ImageAdaptor3.cxx,v $
+  Language:  C++
+  Date:      $Date: 2005/11/20 13:27:52 $
+  Version:   $Revision: 1.13 $
+
+  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
+
+
+// Software Guide : BeginLatex
+//
+// This example illustrates the use of \doxygen{itk}{ImageAdaptor}
+// to obtain access to the components of a vector image. 
+// Specifically, it shows how to manage pixel accessors containing
+// internal parameters. In this example we create an image of vectors by using
+// a gradient filter. Then, we use an image adaptor to extract one of the
+// components of the vector image. The vector type used by the gradient filter
+// is the \doxygen{itk}{CovariantVector} class. 
+//
+// We start by including the relevant headers.
+// 
+// \index{itk::ImageAdaptor!Instantiation}
+// \index{itk::ImageAdaptor!Header}
+// \index{itk::PixelAccessor!with parameters}
+//
+// Software Guide : EndLatex 
+
+#include "otbImage.h"
+#include "itkImageAdaptor.h"
+#include "itkImageRegionIteratorWithIndex.h"
+#include "otbImageFileReader.h"
+#include "otbImageFileWriter.h"
+#include "itkRescaleIntensityImageFilter.h"
+
+
+// Software Guide : BeginCodeSnippet
+#include "itkCovariantVector.h"
+#include "itkGradientRecursiveGaussianImageFilter.h"
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  A pixel accessors class may have internal parameters that affect the
+//  operations performed on input pixel data. Image adaptors support
+//  parameters in their internal pixel accessor by using
+//  the assignment operator. Any pixel accessor which has internal
+//  parameters must therefore implement the assignment operator. 
+//  The following defines a pixel accessor for extracting 
+//  components from a vector pixel. The 
+//  \code{m\_Index} member variable is used to select the vector component 
+//  to be returned.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+class VectorPixelAccessor  
+{
+public:
+  typedef itk::CovariantVector<float,2>   InternalType;
+  typedef                      float      ExternalType;
+
+  void operator=( const VectorPixelAccessor & vpa )
+    {
+      m_Index = vpa.m_Index;
+    }
+  ExternalType Get( const InternalType & input ) const 
+    {
+      return static_cast<ExternalType>( input[ m_Index ] );
+    }
+  void SetIndex( unsigned int index )
+    {
+      m_Index = index;
+    }
+private:
+  unsigned int m_Index;
+};
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  The \code{Get()} method simply returns the \emph{i}-th component of
+//  the vector as indicated by the index. The assignment operator transfers the
+//  value of the index member variable from one instance of the pixel accessor
+//  to another.
+//
+//  Software Guide : EndLatex 
+
+
+//-------------------------
+//
+//   Main code
+//
+//-------------------------
+
+int main( int argc, char *argv[] ) 
+{
+  if( argc < 4 )
+    {
+    std::cerr << "Usage: " << std::endl;
+    std::cerr << "ImageAdaptor3   inputFileName outputComponentFileName ";
+    std::cerr << " indexOfComponentToExtract" << std::endl;
+    return -1;
+    }
+
+
+//  Software Guide : BeginLatex
+//
+//  In order to test the pixel accessor, we generate an image of vectors using
+//  the \doxygen{itk}{GradientRecursiveGaussianImageFilter}. This
+//  filter produces an output image of \doxygen{itk}{CovariantVector} pixel type.
+//  Covariant vectors are the natural representation for gradients since they
+//  are the equivalent of normals to iso-values manifolds.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef unsigned char  InputPixelType;
+  const   unsigned int   Dimension = 2;
+  typedef otb::Image< InputPixelType,  Dimension  >   InputImageType;
+  typedef itk::CovariantVector< float, Dimension  >   VectorPixelType; 
+  typedef otb::Image< VectorPixelType, Dimension  >   VectorImageType;
+  typedef itk::GradientRecursiveGaussianImageFilter< InputImageType,
+                                        VectorImageType> GradientFilterType;
+
+  GradientFilterType::Pointer gradient = GradientFilterType::New();
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  We instantiate the ImageAdaptor using the vector image type as
+//  the first template parameter and the pixel accessor as the second
+//  template parameter.
+//
+//  Software Guide : EndLatex 
+
+
+
+// Software Guide : BeginCodeSnippet
+  typedef itk::ImageAdaptor<  VectorImageType, 
+                              VectorPixelAccessor > ImageAdaptorType;
+
+  ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New();
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  The index of the component to be extracted is specified
+//  from the command line. In the following, we create the accessor,
+//  set the index and connect the accessor to the image adaptor using
+//  the \code{SetPixelAccessor()} method.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  VectorPixelAccessor  accessor;
+  accessor.SetIndex( atoi( argv[3] ) );
+  adaptor->SetPixelAccessor( accessor );
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  We create a reader to load the image specified from the 
+//  command line and pass its output as the input to the gradient filter.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef otb::ImageFileReader< InputImageType >   ReaderType;
+  ReaderType::Pointer reader = ReaderType::New();  
+  gradient->SetInput( reader->GetOutput() );
+
+  reader->SetFileName( argv[1] );
+  gradient->Update();
+//  Software Guide : EndCodeSnippet 
+
+
+//  Software Guide : BeginLatex
+//
+//  We now connect the output of the gradient filter as input to the 
+//  image adaptor.  The adaptor emulates a  scalar image whose pixel values 
+//  are taken from the selected component of the vector image.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  adaptor->SetImage( gradient->GetOutput() );
+// Software Guide : EndCodeSnippet
+ 
+
+  typedef otb::Image< unsigned char, Dimension >   OutputImageType;
+  typedef itk::RescaleIntensityImageFilter< ImageAdaptorType, OutputImageType> 
+    RescalerType;
+  RescalerType::Pointer rescaler = RescalerType::New();
+  typedef otb::ImageFileWriter< OutputImageType >   WriterType;
+  WriterType::Pointer writer = WriterType::New();
+
+  writer->SetFileName( argv[2] );
+
+  rescaler->SetOutputMinimum(  0  );
+  rescaler->SetOutputMaximum( 255 );
+
+  rescaler->SetInput( adaptor );
+  writer->SetInput( rescaler->GetOutput() );
+  writer->Update();
+
+
+
+  return 0;
+}
+
+
+

Examples/DataRepresentation/Image/ImageAdaptor4.cxx

+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile: ImageAdaptor4.cxx,v $
+  Language:  C++
+  Date:      $Date: 2005/11/20 13:27:52 $
+  Version:   $Revision: 1.12 $
+
+  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
+
+//  Software Guide : BeginCommandLineArgs
+//    INPUTS: {QB_Suburb.png}
+//    OUTPUTS: {ImageAdaptorThresholdingA.png}
+//    100
+//  Software Guide : EndCommandLineArgs
+//  Software Guide : BeginCommandLineArgs
+//    INPUTS: {QB_Suburb.png}
+//    OUTPUTS: {ImageAdaptorThresholdingB.png}
+//    200
+//  Software Guide : EndCommandLineArgs
+
+// Software Guide : BeginLatex
+//
+// Image adaptors can also be used to perform simple pixel-wise computations 
+// on image data. The following example illustrates how to use the 
+// \doxygen{itk}{ImageAdaptor} for image thresholding.
+//
+// \index{itk::ImageAdaptor!Instantiation}
+// \index{itk::ImageAdaptor!Header}
+// \index{itk::ImageAdaptor!performing computation}
+// \index{itk::PixelAccessor!with parameters}
+// \index{itk::PixelAccessor!performing computation}
+//
+// Software Guide : EndLatex 
+
+#include "otbImage.h"
+#include "itkImageAdaptor.h"
+#include "otbImageFileReader.h"
+#include "otbImageFileWriter.h"
+#include "itkRescaleIntensityImageFilter.h"
+
+
+//  Software Guide : BeginLatex
+//
+//  A pixel accessor for image thresholding requires that the accessor
+//  maintain the threshold value. Therefore, it must also implement the
+//  assignment operator to set this internal parameter.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+class ThresholdingPixelAccessor  
+{
+public:
+  typedef unsigned char      InternalType;
+  typedef unsigned char      ExternalType;
+
+  ExternalType Get( const InternalType & input ) const 
+    {
+      return (input > m_Threshold) ? 1 : 0;
+    }
+  void SetThreshold( const InternalType threshold )
+    {
+      m_Threshold = threshold;
+    }
+
+  void operator=( const ThresholdingPixelAccessor & vpa )
+    {
+      m_Threshold = vpa.m_Threshold;
+    }
+private:
+  InternalType m_Threshold;
+};
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  The \code{Get()} method returns one if the input pixel is above
+//  the threshold and zero otherwise. The assignment operator transfers 
+//  the value of the threshold member
+//  variable from one instance of the pixel accessor to another.
+//
+//  Software Guide : EndLatex 
+
+
+//-------------------------
+//
+//   Main code
+//
+//-------------------------
+
+int main( int argc, char *argv[] ) 
+{
+  if( argc < 4 )
+    {
+    std::cerr << "Usage: " << std::endl;
+    std::cerr << "ImageAdaptor4   inputFileName outputBinaryFileName ";
+    std::cerr << " thresholdValue" << std::endl;
+    return -1;
+    }
+
+
+//  Software Guide : BeginLatex
+//
+//  To create an image adaptor, we first instantiate an image type
+//  whose pixel type is the same as the internal pixel type of the pixel
+//  accessor.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef ThresholdingPixelAccessor::InternalType     PixelType;
+  const   unsigned int   Dimension = 2;
+  typedef otb::Image< PixelType,  Dimension >   ImageType;
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  We instantiate the ImageAdaptor using the image type as the
+//  first template parameter and the pixel accessor as the second template
+//  parameter.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef itk::ImageAdaptor<  ImageType, 
+                              ThresholdingPixelAccessor > ImageAdaptorType;
+
+  ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New();
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  The threshold value is set from the command line. A threshold
+//  pixel accessor is created and connected to the image adaptor
+//  in the same manner as in the previous example.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  ThresholdingPixelAccessor  accessor;
+  accessor.SetThreshold( atoi( argv[3] ) );
+  adaptor->SetPixelAccessor( accessor );
+// Software Guide : EndCodeSnippet
+
+
+//  Software Guide : BeginLatex
+//
+//  We create a reader to load the input image and connect the output
+//  of the reader as the input to the adaptor.
+//
+//  Software Guide : EndLatex 
+
+
+// Software Guide : BeginCodeSnippet
+  typedef otb::ImageFileReader< ImageType >   ReaderType;
+  ReaderType::Pointer reader = ReaderType::New();  
+  reader->SetFileName( argv[1] );
+  reader->Update();
+
+  adaptor->SetImage( reader->GetOutput() );
+//  Software Guide : EndCodeSnippet 
+
+
+  typedef itk::RescaleIntensityImageFilter< ImageAdaptorType, 
+                                            ImageType > RescalerType;
+
+  RescalerType::Pointer rescaler = RescalerType::New();
+  typedef otb::ImageFileWriter< ImageType >   WriterType;
+  WriterType::Pointer writer = WriterType::New();
+
+
+  writer->SetFileName( argv[2] );
+
+  rescaler->SetOutputMinimum(  0  );
+  rescaler->SetOutputMaximum( 255 );
+
+  rescaler->SetInput( adaptor );
+  writer->SetInput( rescaler->GetOutput() );
+  writer->Update();
+
+
+//  Software Guide : BeginLatex
+//
+// \begin{figure} \center
+// \includegraphics[width=0.32\textwidth]{QB_Suburb.eps}
+// \includegraphics[width=0.32\textwidth]{ImageAdaptorThresholdingA.eps}
+// \includegraphics[width=0.32\textwidth]{ImageAdaptorThresholdingB.eps}
+// \itkcaption[Image Adaptor for performing computations]{Using
+// ImageAdaptor to perform a simple image computation. An
+// ImageAdaptor is used to perform binary thresholding on
+// the input image on the  left. The center image was created using a 
+// threshold of 100, while the
+// image on the right corresponds to a  threshold of 200.}
+// \label{fig:ImageAdaptorThresholding}
+// \end{figure}
+//
+//  As before, we rescale the emulated scalar image before writing it
+//  out to file.
+//  Figure~\ref{fig:ImageAdaptorThresholding} illustrates the result of
+//  applying the thresholding adaptor to a typical gray scale image using two
+//  different threshold values. Note that the same effect could have been
+//  achieved by using the \doxygen{itk}{BinaryThresholdImageFilter} but at the
+//  price of holding an extra copy of the image in memory.
+//
+//  Software Guide : EndLatex 
+
+
+  return 0;
+}
+
+
+