STYLE: formatting indentation (Code)

Code/BasicFilters/otbFunctionWithNeighborhoodToImageFilter.h

@@ -51,7 +51,7 @@ namespace otb
 
 template <class TInputImage, class TOutputImage,class TFunction    >
 class ITK_EXPORT FunctionWithNeighborhoodToImageFilter :
-    public FunctionToImageFilter<TInputImage,TOutputImage,TFunction>
+      public FunctionToImageFilter<TInputImage,TOutputImage,TFunction>
 {
 public:
   /** Standard class typedefs. */
@@ -87,14 +87,14 @@ public:
   /** Connect one of the operands for pixel-wise addition. */
   //void SetInput( const TInputImage *image);
 
-/** Set the internal spatial function. */
-  void SetFunction( FunctionType* PixelFunction ) 
-    {
-      Superclass::SetFunction( PixelFunction ); 
-      //m_Radius = this->GetFunction()->GetRadius();
-      //m_Offset = this->GetFunction()->GetOffset();
-      this->Modified(); 
-    };
+  /** Set the internal spatial function. */
+  void SetFunction( FunctionType* PixelFunction )
+  {
+    Superclass::SetFunction( PixelFunction );
+    //m_Radius = this->GetFunction()->GetRadius();
+    //m_Offset = this->GetFunction()->GetOffset();
+    this->Modified();
+  };
 
   /** Image dimensions */
   itkStaticConstMacro(InputImageDimension, unsigned int,

Code/BasicFilters/otbFunctionWithNeighborhoodToImageFilter.txx

@@ -64,7 +64,7 @@ template <class TInputImage, class TOutputImage, class TFunction  >
 void
 FunctionWithNeighborhoodToImageFilter<TInputImage,TOutputImage,TFunction>
 ::GenerateInputRequestedRegion()
-{ 
+{
   // call the superclass' implementation of this method
   Superclass::GenerateInputRequestedRegion();
 
@@ -73,9 +73,9 @@ FunctionWithNeighborhoodToImageFilter<TInputImage,TOutputImage,TFunction>
   OutputImagePointer outputPtr = this->GetOutput();
 
   if ( !inputPtr || !outputPtr )
-    {
+  {
     return;
-    }
+  }
   // get a copy of the input requested region (should equal the output
   // requested region)
   InputImageRegionType inputRequestedRegion = inputPtr->GetRequestedRegion();
@@ -83,17 +83,17 @@ FunctionWithNeighborhoodToImageFilter<TInputImage,TOutputImage,TFunction>
   // pad the input requested region by the operator radius
   InputImageSizeType maxRad;
   maxRad[0] = m_Radius[0] + vcl_abs(m_Offset[0]);
-  maxRad[1] = m_Radius[0] + vcl_abs(m_Offset[1]); 
+  maxRad[1] = m_Radius[0] + vcl_abs(m_Offset[1]);
   inputRequestedRegion.PadByRadius( maxRad );
 
   // crop the input requested region at the input's largest possible region
   if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
-    {
+  {
     inputPtr->SetRequestedRegion( inputRequestedRegion );
     return;
-    }
+  }
   else
-    {
+  {
     // Couldn't crop the region (requested region is outside the largest
     // possible region).  Throw an exception.
 
@@ -104,12 +104,12 @@ FunctionWithNeighborhoodToImageFilter<TInputImage,TOutputImage,TFunction>
     itk::InvalidRequestedRegionError e(__FILE__, __LINE__);
     itk::OStringStream msg;
     msg << this->GetNameOfClass()
-        << "::GenerateInputRequestedRegion()";
+    << "::GenerateInputRequestedRegion()";
     e.SetLocation(msg.str().c_str());
     e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
     e.SetDataObject(inputPtr);
     throw e;
-    }
+  }
 }
 
 
@@ -135,15 +135,15 @@ FunctionWithNeighborhoodToImageFilter<TInputImage,TOutputImage,TFunction>
   inputIt.GoToBegin();
   outputIt.GoToBegin();
 
-  while( !inputIt.IsAtEnd() )
-    {
-      //std::cout<<"MOTHER "<<threadId<<" : "<<inputIt.GetIndex()<<" "<<inputIt.Get()<<std::endl;
-      outputIt.Set( static_cast<OutputImagePixelType>(this->GetFunction()->EvaluateAtIndex(inputIt.GetIndex())) );
-      ++inputIt;
-      ++outputIt;
+  while ( !inputIt.IsAtEnd() )
+  {
+    //std::cout<<"MOTHER "<<threadId<<" : "<<inputIt.GetIndex()<<" "<<inputIt.Get()<<std::endl;
+    outputIt.Set( static_cast<OutputImagePixelType>(this->GetFunction()->EvaluateAtIndex(inputIt.GetIndex())) );
+    ++inputIt;
+    ++outputIt;
 
-      progress.CompletedPixel(); // potential exception thrown here
-    }
+    progress.CompletedPixel(); // potential exception thrown here
+  }
 }
 } // end namespace otb
 

Code/BasicFilters/otbKeyPointDensityImageFilter.h

@@ -28,89 +28,89 @@ PURPOSE.  See the above copyright notices for more information.
 
 
 /** \class KeyPointDensityImageFilter
- *  \brief 
+ *  \brief
 
  *
  */
 
 namespace otb
 {
-  template <class TInputImage , class TDetector, class TOutputImage>
-    class ITK_EXPORT KeyPointDensityImageFilter
-    : public itk::ImageToImageFilter<TInputImage, TOutputImage>
-    {
-
-    public:
-
-    /** Standard class typedefs. */
-      typedef KeyPointDensityImageFilter                                            Self;
-      typedef itk::ImageToImageFilter<TInputImage,TOutputImage>           Superclass ;
-      typedef itk::SmartPointer<Self>                                     Pointer;
-      typedef itk::SmartPointer<const Self>                               ConstPointer;
-
-      /** Method for creation through the object factory. */
-      itkNewMacro(Self);
-
-      /** Run-time type information (and related methods). */
-      itkTypeMacro(KeyPointDensityImageFilter,itk::ImageToImageFilter);
-
-
-      /** Template parameters typedefs*/
-      typedef TInputImage                                  InputImageType;
-      typedef typename InputImageType::Pointer             InputImagePointerType;
-  
-      /** OutputImageType typedef support*/
-      typedef TOutputImage                                 OutputImageType;
-      typedef typename OutputImageType::Pointer            OutputImagePointerType;
-  
-      /** Detector typedef Support*/
-      typedef TDetector                                      DetectorType;
-      typedef typename DetectorType::OutputPointSetType      PointSetType;
-      typedef typename DetectorType::Pointer                 DetectorPointerType;
-      
-      /** PointSetToDensityImageFilter support*/
-      typedef otb::PointSetToDensityImageFilter<PointSetType, OutputImageType> PointSetToDensityImageType;
-      typedef typename PointSetToDensityImageType::Pointer                     PointSetToDensityImagePointerType;
-      
-      /** Get/Set the radius of the neighborhood over which the
-	  statistics are evaluated */
-      itkSetMacro( NeighborhoodRadius, unsigned int );
-      itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int );
-
-
-      /**Set/Get Descriptor from the otbCountmageFunction*/
-      virtual void SetDetector(DetectorType* detector);
-      virtual DetectorType* GetDetector();
-      
-    protected:
-
-      /**
-       * Constructor.
-       */
-      KeyPointDensityImageFilter();
-      /**
-       * Destructor.
-       */
-      virtual ~KeyPointDensityImageFilter();
-      /**
-       * Standard PrintSelf method.
-       */
-      virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
-      /**
-       * Main computation method.
-       */
-      //virtual void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-      virtual void GenerateData( );
-	    
-  private:
-
-      KeyPointDensityImageFilter(const Self&); //purposely not implemented
-      void operator=(const Self&); //purposely not implemented
-      
-      DetectorPointerType                m_Detector;
-      PointSetToDensityImagePointerType  m_PointSetToDensityImageFilter;
-      unsigned int                       m_NeighborhoodRadius;
-    };
+template <class TInputImage , class TDetector, class TOutputImage>
+class ITK_EXPORT KeyPointDensityImageFilter
+      : public itk::ImageToImageFilter<TInputImage, TOutputImage>
+{
+
+public:
+
+  /** Standard class typedefs. */
+  typedef KeyPointDensityImageFilter                                            Self;
+  typedef itk::ImageToImageFilter<TInputImage,TOutputImage>           Superclass ;
+  typedef itk::SmartPointer<Self>                                     Pointer;
+  typedef itk::SmartPointer<const Self>                               ConstPointer;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkTypeMacro(KeyPointDensityImageFilter,itk::ImageToImageFilter);
+
+
+  /** Template parameters typedefs*/
+  typedef TInputImage                                  InputImageType;
+  typedef typename InputImageType::Pointer             InputImagePointerType;
+
+  /** OutputImageType typedef support*/
+  typedef TOutputImage                                 OutputImageType;
+  typedef typename OutputImageType::Pointer            OutputImagePointerType;
+
+  /** Detector typedef Support*/
+  typedef TDetector                                      DetectorType;
+  typedef typename DetectorType::OutputPointSetType      PointSetType;
+  typedef typename DetectorType::Pointer                 DetectorPointerType;
+
+  /** PointSetToDensityImageFilter support*/
+  typedef otb::PointSetToDensityImageFilter<PointSetType, OutputImageType> PointSetToDensityImageType;
+  typedef typename PointSetToDensityImageType::Pointer                     PointSetToDensityImagePointerType;
+
+  /** Get/Set the radius of the neighborhood over which the
+  statistics are evaluated */
+  itkSetMacro( NeighborhoodRadius, unsigned int );
+  itkGetConstReferenceMacro( NeighborhoodRadius, unsigned int );
+
+
+  /**Set/Get Descriptor from the otbCountmageFunction*/
+  virtual void SetDetector(DetectorType* detector);
+  virtual DetectorType* GetDetector();
+
+protected:
+
+  /**
+   * Constructor.
+   */
+  KeyPointDensityImageFilter();
+  /**
+   * Destructor.
+   */
+  virtual ~KeyPointDensityImageFilter();
+  /**
+   * Standard PrintSelf method.
+   */
+  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
+  /**
+   * Main computation method.
+   */
+  //virtual void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
+  virtual void GenerateData( );
+
+private:
+
+  KeyPointDensityImageFilter(const Self&); //purposely not implemented
+  void operator=(const Self&); //purposely not implemented
+
+  DetectorPointerType                m_Detector;
+  PointSetToDensityImagePointerType  m_PointSetToDensityImageFilter;
+  unsigned int                       m_NeighborhoodRadius;
+};
 }
 #ifndef OTB_MANUAL_INSTANTIATION
 #include "otbKeyPointDensityImageFilter.txx"

Code/BasicFilters/otbKeyPointDensityImageFilter.txx

@@ -24,35 +24,35 @@ PURPOSE.  See the above copyright notices for more information.
 
 namespace otb
 {
-  /**---------------------------------------------------------
-   * Constructor
-   ----------------------------------------------------------*/
-  template <class TInputImage , class TDetector, class TOutputImage>
-  KeyPointDensityImageFilter<TInputImage , TDetector,  TOutputImage>
-  ::KeyPointDensityImageFilter()
-  {
-    this->SetNumberOfRequiredInputs( 1 );
-    m_NeighborhoodRadius = 1;
-    m_Detector =  DetectorType::New();
-    m_PointSetToDensityImageFilter = PointSetToDensityImageType::New();
-  }
-
-
- /*---------------------------------------------------------
-  * Destructor.c
-  ----------------------------------------------------------*/
-  template <class TInputImage , class TDetector, class TOutputImage>
-  KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
-  ::~KeyPointDensityImageFilter()
-  {}
-
-  /**
-   * threaded Generate Data
-   */
-
-  /**
- * ThreadedGenerateData Performs the pixel-wise addition
+/**---------------------------------------------------------
+ * Constructor
+ ----------------------------------------------------------*/
+template <class TInputImage , class TDetector, class TOutputImage>
+KeyPointDensityImageFilter<TInputImage , TDetector,  TOutputImage>
+::KeyPointDensityImageFilter()
+{
+  this->SetNumberOfRequiredInputs( 1 );
+  m_NeighborhoodRadius = 1;
+  m_Detector =  DetectorType::New();
+  m_PointSetToDensityImageFilter = PointSetToDensityImageType::New();
+}
+
+
+/*---------------------------------------------------------
+ * Destructor.c
+ ----------------------------------------------------------*/
+template <class TInputImage , class TDetector, class TOutputImage>
+KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
+::~KeyPointDensityImageFilter()
+{}
+
+/**
+ * threaded Generate Data
  */
+
+/**
+* ThreadedGenerateData Performs the pixel-wise addition
+*/
 template <class TInputImage , class TDetector,  class TOutputImage>
 void
 KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
@@ -61,12 +61,12 @@ KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
 {
   typename Superclass::OutputImagePointer      outputImage = this->GetOutput();
   InputImagePointerType ptr = const_cast<InputImageType *>(this->GetInput());
-  if(!ptr)
+  if (!ptr)
     return ;
 
   /** Detector*/
   m_Detector->SetInput(ptr);
-  
+
   /** Applying the pointsetTodensityImageFilter*/
   m_PointSetToDensityImageFilter->SetInput(m_Detector->GetOutput());
   m_PointSetToDensityImageFilter->SetRadius(m_NeighborhoodRadius);
@@ -74,48 +74,48 @@ KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
   m_PointSetToDensityImageFilter->SetSize(ptr->GetLargestPossibleRegion().GetSize());
   m_PointSetToDensityImageFilter->SetOrigin(ptr->GetOrigin());
   m_PointSetToDensityImageFilter->Update();
-  
+
   /** updating the output*/
   this->GraftOutput(m_PointSetToDensityImageFilter->GetOutput());
 }
 
 
-  /**
-   * Set Detector 
-   */
-  template <class TInputImage , class TDetector, class TOutputImage>
-  void
-  KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
-  ::SetDetector(DetectorType* detector)
-  {
-    m_Detector = detector;
-  }
-  
-  
-  /**
-   * Get Detector 
-   */
-  template <class TInputImage , class TDetector, class TOutputImage>
-  typename KeyPointDensityImageFilter< TInputImage ,  TDetector,  TOutputImage >
-  ::DetectorType *
-  KeyPointDensityImageFilter< TInputImage , TDetector, TOutputImage >
-  ::GetDetector()
-  {
-    return m_Detector;
-  }
-  
-
-
-  /*----------------------------------------------------------------
-    PrintSelf
-    -----------------------------------------------------------------*/
-  template <class TInputImage , class TDetector, class TOutputImage>
-  void
-  KeyPointDensityImageFilter< TInputImage ,  TDetector,  TOutputImage >
-  ::PrintSelf(std::ostream& os, itk::Indent indent) const
-  {
-    Superclass::PrintSelf(os, indent);
-    os << indent << "Neighborhood Radius " << m_NeighborhoodRadius   << std::endl;
-  }
+/**
+ * Set Detector
+ */
+template <class TInputImage , class TDetector, class TOutputImage>
+void
+KeyPointDensityImageFilter<TInputImage, TDetector, TOutputImage >
+::SetDetector(DetectorType* detector)
+{
+  m_Detector = detector;
+}
+
+
+/**
+ * Get Detector
+ */
+template <class TInputImage , class TDetector, class TOutputImage>
+typename KeyPointDensityImageFilter< TInputImage ,  TDetector,  TOutputImage >
+::DetectorType *
+KeyPointDensityImageFilter< TInputImage , TDetector, TOutputImage >
+::GetDetector()
+{
+  return m_Detector;
+}
+
+
+
+/*----------------------------------------------------------------
+  PrintSelf
+  -----------------------------------------------------------------*/
+template <class TInputImage , class TDetector, class TOutputImage>
+void
+KeyPointDensityImageFilter< TInputImage ,  TDetector,  TOutputImage >
+::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+  Superclass::PrintSelf(os, indent);
+  os << indent << "Neighborhood Radius " << m_NeighborhoodRadius   << std::endl;
+}
 
 }/** end namesapce otb*/

Code/BasicFilters/otbPointSetDensityFunction.txx

@@ -50,7 +50,7 @@ PointSetDensityFunction< TPointSet,   TOutput>
   typename otb::Image<OutputType,2>::IndexType  index;
   index[0] = static_cast<long int>(input[0]);
   index[1] = static_cast<long int>(input[1]);
-  
+
   int accu = 0;
   double surface = M_PI*vcl_pow(2.,static_cast<double>(m_Radius));
 

Code/BasicFilters/otbUnaryFunctorObjectListFilter.txx

@@ -76,13 +76,13 @@ UnaryFunctorObjectListFilter<TInputList,TOutputList,TFunction>
   OutputListPointer outputPtr = this->GetOutput();
   for (unsigned int i=0; i< this->m_ObjectListPerThread.size(); ++i)
   {
-  if(this->m_ObjectListPerThread[i].IsNotNull())
+    if (this->m_ObjectListPerThread[i].IsNotNull())
     {
-    for (OutputListIterator it = this->m_ObjectListPerThread[i]->Begin();
-         it != this->m_ObjectListPerThread[i]->End();
-         ++it)
+      for (OutputListIterator it = this->m_ObjectListPerThread[i]->Begin();
+           it != this->m_ObjectListPerThread[i]->End();
+           ++it)
       {
-      outputPtr->PushBack(it.Get());
+        outputPtr->PushBack(it.Get());
       }
     }
   }

Code/Common/otbUnaryFunctorNeighborhoodWithOffsetImageFilter.h

@@ -23,7 +23,8 @@
 #include "itkConstNeighborhoodIterator.h"
 #include "itkProcessObject.h"
 
-namespace otb {
+namespace otb
+{
 /** \class UnaryFunctorNeighborhoodWithOffsetImageFilter
  * \brief Implements neighborhood-wise generic operation on image
  *
@@ -35,7 +36,7 @@ namespace otb {
  */
 template <class TInputImage, class TOutputImage, class TFunction >
 class ITK_EXPORT UnaryFunctorNeighborhoodWithOffsetImageFilter
-  : public itk::ImageToImageFilter<TInputImage,TOutputImage>
+      : public itk::ImageToImageFilter<TInputImage,TOutputImage>
 {
 public:
   /** Standard class typedefs. */
@@ -71,11 +72,11 @@ public:
   itkGetMacro(Radius,unsigned int);
   /** Set/Get the offset */
   void SetOffset(InputImageOffsetType off)
-    {
-      m_Offset = off;
-      this->GetFunctor().SetOffset(off);
-      this->Modified();
-    };
+  {
+    m_Offset = off;
+    this->GetFunctor().SetOffset(off);
+    this->Modified();
+  };
   itkGetMacro(Offset,InputImageOffsetType);
 
   /** Get the functor object.  The functor is returned by reference.
@@ -84,15 +85,18 @@ public:
    * SmartPointer.) */
   FunctorType& GetFunctor()
   {
-        this->Modified();
-        return m_Functor;
+    this->Modified();
+    return m_Functor;
   }
 
   /** Get the functor object.  The functor is returned by reference.
    * (Functors do not have to derive from itk::LightObject, so they do
    * not necessarily have a reference count. So we cannot return a
    * SmartPointer.) */
-  const FunctorType& GetFunctor() const { return m_Functor; };
+  const FunctorType& GetFunctor() const
+  {
+    return m_Functor;
+  };
 
   /** Set the functor object.  This replaces the current Functor with a
    * copy of the specified Functor. This allows the user to specify a
@@ -145,9 +149,9 @@ private:
   void operator=(const Self&); //purposely not implemented
 
   unsigned int m_Radius;
-  
+
   FunctorType m_Functor;
-  
+
 
   InputImageOffsetType m_Offset;
 };

Code/Common/otbUnaryFunctorNeighborhoodWithOffsetImageFilter.txx

@@ -50,11 +50,11 @@ UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage,TOutputImage,TFunction
 {
   Superclass::BeforeThreadedGenerateData();
 
-  for(unsigned int i =0; i<this->GetNumberOfThreads(); i++)
-    {
-      m_FunctorList.push_back(m_Functor);
-    }
- }
+  for (unsigned int i =0; i<this->GetNumberOfThreads(); i++)
+  {
+    m_FunctorList.push_back(m_Functor);
+  }
+}
 
 
 template <class TInputImage, class TOutputImage, class TFunction  >
@@ -71,9 +71,9 @@ UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage,TOutputImage,TFunction
   typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
 
   if ( !inputPtr || !outputPtr )
-    {
+  {
     return;
-    }
+  }
   // get a copy of the input requested region (should equal the output
   // requested region)
   typename TInputImage::RegionType inputRequestedRegion;
@@ -82,17 +82,17 @@ UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage,TOutputImage,TFunction
   // pad the input requested region by the operator radius
   InputImageSizeType maxRad;
   maxRad[0] = m_Radius + vcl_abs(m_Offset[0]);
-  maxRad[1] = m_Radius + vcl_abs(m_Offset[1]);; 
+  maxRad[1] = m_Radius + vcl_abs(m_Offset[1]);;
   inputRequestedRegion.PadByRadius( maxRad );
 
   // crop the input requested region at the input's largest possible region
   if ( inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()) )
-    {
+  {
     inputPtr->SetRequestedRegion( inputRequestedRegion );
     return;
-    }
+  }
   else
-    {
+  {
     // Couldn't crop the region (requested region is outside the largest
     // possible region).  Throw an exception.
 
@@ -103,12 +103,12 @@ UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage,TOutputImage,TFunction
     itk::InvalidRequestedRegionError e(__FILE__, __LINE__);
     itk::OStringStream msg;
     msg << this->GetNameOfClass()
-        << "::GenerateInputRequestedRegion()";
+    << "::GenerateInputRequestedRegion()";
     e.SetLocation(msg.str().c_str());
     e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
     e.SetDataObject(inputPtr);
     throw e;
-    }
+  }
 }
 
 /**
@@ -118,7 +118,8 @@ template <class TInputImage, class TOutputImage, class TFunction >
 void
 UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage, TOutputImage, TFunction>
 ::ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, int threadId)
-{ std::cout<<"threadId : "<<threadId<<std::endl;
+{
+  std::cout<<"threadId : "<<threadId<<std::endl;
   itk::ZeroFluxNeumannBoundaryCondition<TInputImage> nbc;
   itk::ZeroFluxNeumannBoundaryCondition<TInputImage> nbcOff;
   // We use dynamic_cast since inputs are stored as DataObjects.  The
@@ -159,32 +160,32 @@ UnaryFunctorNeighborhoodWithOffsetImageFilter<TInputImage, TOutputImage, TFuncti
   fitOff=faceList.begin();
 
   while (fit!=faceList.end() && fitOff!=faceListOff.end())
-    {  
-      // neighborhood iterator
-      neighInputIt = itk::ConstNeighborhoodIterator<TInputImage>(r, inputPtr, *fit);
-      neighInputIt.OverrideBoundaryCondition(&nbc);
-      neighInputIt.GoToBegin();
-      // Neighborhood+offset iterator
-      neighInputOffIt = itk::ConstNeighborhoodIterator<TInputImage>(rOff, inputPtr, *fitOff);
-      neighInputOffIt.OverrideBoundaryCondition(&nbcOff);
-      neighInputOffIt.GoToBegin();
-
-      outputIt = itk::ImageRegionIterator<TOutputImage>(outputPtr, *fit);
-
-      while ( ! outputIt.IsAtEnd() )
-	{
-
-	  outputIt.Set( m_FunctorList[threadId]( neighInputIt, neighInputOffIt) );
-
-	  ++neighInputIt;
-	  ++neighInputOffIt;
-	  ++outputIt;
-	  progress.CompletedPixel();
-	}
-      ++fit;
-      ++fitOff;
+  {
+    // neighborhood iterator
+    neighInputIt = itk::ConstNeighborhoodIterator<TInputImage>(r, inputPtr, *fit);
+    neighInputIt.OverrideBoundaryCondition(&nbc);
+    neighInputIt.GoToBegin();
+    // Neighborhood+offset iterator
+    neighInputOffIt = itk::ConstNeighborhoodIterator<TInputImage>(rOff, inputPtr, *fitOff);
+    neighInputOffIt.OverrideBoundaryCondition(&nbcOff);
+    neighInputOffIt.GoToBegin();
+
+    outputIt = itk::ImageRegionIterator<TOutputImage>(outputPtr, *fit);
+
+    while ( ! outputIt.IsAtEnd() )
+    {
+
+      outputIt.Set( m_FunctorList[threadId]( neighInputIt, neighInputOffIt) );
+
+      ++neighInputIt;
+      ++neighInputOffIt;
+      ++outputIt;
+      progress.CompletedPixel();
     }
-std::cout<<"threadIdFIN : "<<threadId<<std::endl;
+    ++fit;
+    ++fitOff;
+  }
+  std::cout<<"threadIdFIN : "<<threadId<<std::endl;
 }
 
 } // end namespace otb

Code/FeatureExtraction/otbCloudDetectionFilter.h

@@ -26,15 +26,15 @@ namespace otb
 /** \class CloudDetectionFilter
  * \brief Applies cloud detection functor to an image.
  */
-template <class TInputImage, class TOutputImage, class TFunction = Functor::CloudDetectionFunctor< 
-                                          ITK_TYPENAME TInputImage::PixelType, ITK_TYPENAME TOutputImage::PixelType> >
+template <class TInputImage, class TOutputImage, class TFunction = Functor::CloudDetectionFunctor<
+ITK_TYPENAME TInputImage::PixelType, ITK_TYPENAME TOutputImage::PixelType> >
 class ITK_EXPORT CloudDetectionFilter : public itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, TFunction >
 {
 public:
   /** Standard class typedefs. */
   typedef CloudDetectionFilter                          Self;
-  typedef typename itk::UnaryFunctorImageFilter < TInputImage, TOutputImage, TFunction > 
-                                                        Superclass;
+  typedef typename itk::UnaryFunctorImageFilter < TInputImage, TOutputImage, TFunction >
+  Superclass;
   typedef itk::SmartPointer<Self>                       Pointer;
   typedef itk::SmartPointer<const Self>                 ConstPointer;
 
@@ -66,7 +66,7 @@ public:
 protected:
   CloudDetectionFilter();
 
-  virtual ~CloudDetectionFilter(){};
+  virtual ~CloudDetectionFilter() {};
 
   virtual void BeforeThreadedGenerateData();
 

Code/FeatureExtraction/otbCloudDetectionFilter.txx

@@ -111,7 +111,10 @@ CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
 template <class TInputImage, class TOutputImage, class TFunction>
 void
 CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
-::SetMinThreshold(double threshold){ this->GetFunctor().SetMinThreshold(threshold); }
+::SetMinThreshold(double threshold)
+{
+  this->GetFunctor().SetMinThreshold(threshold);
+}
 
 /**
  * SetMaxThreshold
@@ -119,7 +122,10 @@ CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
 template <class TInputImage, class TOutputImage, class TFunction>
 void
 CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
-::SetMaxThreshold(double threshold){ this->GetFunctor().SetMaxThreshold(threshold); }
+::SetMaxThreshold(double threshold)
+{
+  this->GetFunctor().SetMaxThreshold(threshold);
+}
 
 /**
  * GetMinThreshold
@@ -127,7 +133,10 @@ CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
 template <class TInputImage, class TOutputImage, class TFunction>
 double
 CloudDetectionFilter<TInputImage,TOutputImage,TFunction>
-::GetMinThreshold(){  return this->GetFunctor().GetMinThreshold(); }
+::GetMinThreshold()
+{
+  return this->GetFunctor().GetMinThreshold();
+}
 
 /**
  * GetMaxThreshold

Code/FeatureExtraction/otbCloudDetectionFunctor.h

@@ -23,48 +23,72 @@
 
 namespace otb
 {
-  /** \class CloudDetectionFunctor
-   *  \brief This functor first uses CloudEstimatorFunctor
-   *  \brief And then binarise the image with two thresholds
-   */
+/** \class CloudDetectionFunctor
+ *  \brief This functor first uses CloudEstimatorFunctor
+ *  \brief And then binarise the image with two thresholds
+ */
 namespace Functor
 {
 template<class TInput,class TOutputValue>
 class CloudDetectionFunctor
 {
- public:
+public:
   typedef CloudEstimatorFunctor<TInput, TOutputValue> CloudEstimatorFunctorType;
 
   CloudDetectionFunctor()
-    {
-      m_MinThreshold = 0.0;
-      m_MaxThreshold = 1.0;
-    };
+  {
+    m_MinThreshold = 0.0;
+    m_MaxThreshold = 1.0;
+  };
 
-  ~CloudDetectionFunctor(){};
+  ~CloudDetectionFunctor() {};
   inline TOutputValue operator()(const TInput& inPix)
+  {
+    if ( (m_CloudEstimatorFunctor(inPix)>m_MinThreshold) && (m_CloudEstimatorFunctor(inPix)<m_MaxThreshold) )
     {
-      if( (m_CloudEstimatorFunctor(inPix)>m_MinThreshold) && (m_CloudEstimatorFunctor(inPix)<m_MaxThreshold) )
-      {
-        return 1;
-      }
-      else 
-      {
-        return 0;
-      }
+      return 1;
     }
-
-  void SetReferencePixel( TInput ref ){ m_CloudEstimatorFunctor.SetReferencePixel(ref); };
-  void SetVariance(double variance){ m_CloudEstimatorFunctor.SetVariance(variance); };
-  void SetMinThreshold(double threshold){ m_MinThreshold = threshold; };
-  void SetMaxThreshold(double threshold){ m_MaxThreshold = threshold; };
-  double GetMinThreshold(){ return m_MinThreshold; };
-  double GetMaxThreshold(){ return m_MaxThreshold; };
-  double GetVariance(){ return m_CloudEstimatorFunctor.GetVariance(); };
-  TInput GetReferencePixel(){ return m_CloudEstimatorFunctor.GetReferencePixel(); };
-
-
- protected:
+    else
+    {
+      return 0;
+    }
+  }
+
+  void SetReferencePixel( TInput ref )
+  {
+    m_CloudEstimatorFunctor.SetReferencePixel(ref);
+  };
+  void SetVariance(double variance)
+  {
+    m_CloudEstimatorFunctor.SetVariance(variance);
+  };
+  void SetMinThreshold(double threshold)
+  {
+    m_MinThreshold = threshold;
+  };
+  void SetMaxThreshold(double threshold)
+  {
+    m_MaxThreshold = threshold;
+  };
+  double GetMinThreshold()
+  {
+    return m_MinThreshold;
+  };
+  double GetMaxThreshold()
+  {
+    return m_MaxThreshold;
+  };
+  double GetVariance()
+  {
+    return m_CloudEstimatorFunctor.GetVariance();
+  };
+  TInput GetReferencePixel()
+  {
+    return m_CloudEstimatorFunctor.GetReferencePixel();
+  };
+
+
+protected:
   CloudEstimatorFunctorType m_CloudEstimatorFunctor;
   double m_MinThreshold;
   double m_MaxThreshold;

Code/FeatureExtraction/otbCloudEstimatorFilter.h

@@ -28,15 +28,15 @@ namespace otb
  * \brief Multiplies by a gaussian coefficient
  * \brief Applies a color reversal.
  */
-template <class TInputImage, class TOutputImage, class TFunction = Functor::SpectralAngleFunctor< 
-                                          ITK_TYPENAME TInputImage::PixelType, ITK_TYPENAME TOutputImage::PixelType> >
+template <class TInputImage, class TOutputImage, class TFunction = Functor::SpectralAngleFunctor<
+ITK_TYPENAME TInputImage::PixelType, ITK_TYPENAME TOutputImage::PixelType> >
 class ITK_EXPORT CloudEstimatorFilter : public itk::UnaryFunctorImageFilter< TInputImage, TOutputImage, TFunction >
 {
 public:
   /** Standard class typedefs. */
   typedef CloudEstimatorFilter                          Self;
-  typedef typename itk::UnaryFunctorImageFilter < TInputImage, TOutputImage, TFunction > 
-                                                        Superclass;
+  typedef typename itk::UnaryFunctorImageFilter < TInputImage, TOutputImage, TFunction >
+  Superclass;
   typedef itk::SmartPointer<Self>                       Pointer;
   typedef itk::SmartPointer<const Self>                 ConstPointer;
 
@@ -64,7 +64,7 @@ public:
 protected:
   CloudEstimatorFilter();
 
-  virtual ~CloudEstimatorFilter(){};
+  virtual ~CloudEstimatorFilter() {};
 
   virtual void BeforeThreadedGenerateData();
 

Code/FeatureExtraction/otbCloudEstimatorFunctor.h

@@ -23,76 +23,82 @@
 
 namespace otb
 {
-  /** \class CloudEstimatorFunctor
-   *  \brief This functor first computes the spectral angle according to a reference pixel.
-   *  \brief Then multiplies the result by a gaussian coefficient
-   *  \brief And reverse the pixel values.
-   */
+/** \class CloudEstimatorFunctor
+ *  \brief This functor first computes the spectral angle according to a reference pixel.
+ *  \brief Then multiplies the result by a gaussian coefficient
+ *  \brief And reverse the pixel values.
+ */
 namespace Functor
 {
 template<class TInput,class TOutputValue>
 class CloudEstimatorFunctor
 {
- public:
+public:
   typedef SpectralAngleFunctor<TInput, TOutputValue> SpectralAngleFunctorType;
 
   CloudEstimatorFunctor()
-    {
-      m_ReferencePixel.SetSize(4);
-      m_ReferencePixel.Fill(1);
-      m_RefNorm = 2.0;
-      m_Variance = 1.0;
-      m_Denom = 1.0;
-    };
-
-  ~CloudEstimatorFunctor(){};
+  {
+    m_ReferencePixel.SetSize(4);
+    m_ReferencePixel.Fill(1);
+    m_RefNorm = 2.0;
+    m_Variance = 1.0;
+    m_Denom = 1.0;
+  };
+
+  ~CloudEstimatorFunctor() {};
   inline TOutputValue operator()(const TInput& inPix)
-    {
+  {
 
-      TOutputValue lOut;
-      double lRes = 0.0;
-      double lCurPixNorm = 0.0;
-      double lGaussianCoef = 1.0;
+    TOutputValue lOut;
+    double lRes = 0.0;
+    double lCurPixNorm = 0.0;
+    double lGaussianCoef = 1.0;
 
-      // Compute the Gaussian Coef
-      for (unsigned int i=0; i<std::min(inPix.Size(),m_ReferencePixel.Size()); i++)
-      {
-        lCurPixNorm += inPix[i]*inPix[i];
-      }
-      lCurPixNorm = vcl_sqrt(static_cast<double>(lCurPixNorm));
-      lGaussianCoef = vcl_exp(- vcl_pow((lCurPixNorm-m_RefNorm),2) / m_Denom ) ;
+    // Compute the Gaussian Coef
+    for (unsigned int i=0; i<std::min(inPix.Size(),m_ReferencePixel.Size()); i++)
+    {
+      lCurPixNorm += inPix[i]*inPix[i];
+    }
+    lCurPixNorm = vcl_sqrt(static_cast<double>(lCurPixNorm));
+    lGaussianCoef = vcl_exp(- vcl_pow((lCurPixNorm-m_RefNorm),2) / m_Denom ) ;
 
-      // Reverse the SpectralAngle values and set them between [0;1]
-      lRes =  lGaussianCoef * ((M_PI-m_SpectralAngleFunctor(inPix)) / M_PI);
+    // Reverse the SpectralAngle values and set them between [0;1]
+    lRes =  lGaussianCoef * ((M_PI-m_SpectralAngleFunctor(inPix)) / M_PI);
 
-      lOut = static_cast<TOutputValue>(lRes);
-      return lOut;
+    lOut = static_cast<TOutputValue>(lRes);
+    return lOut;
 
-    }
+  }
 
   void SetReferencePixel( TInput ref )
+  {
+    m_ReferencePixel = ref;
+    m_SpectralAngleFunctor.SetReferencePixel(ref);
+    m_RefNorm = 0.0;
+    for (unsigned int i = 0; i<ref.Size(); i++)
     {
-      m_ReferencePixel = ref;
-      m_SpectralAngleFunctor.SetReferencePixel(ref);
-      m_RefNorm = 0.0;
-      for(unsigned int i = 0; i<ref.Size(); i++)
-      {
-        m_RefNorm += ref[i]*ref[i];
-      }
-      m_RefNorm = vcl_sqrt(static_cast<double>(m_RefNorm)); 
-      SetVariance(m_Variance);
-    };
-
-  void SetVariance(double variance)
-    {
-      m_Variance = variance;
-      m_Denom = 2 * variance * variance * m_RefNorm * m_RefNorm;
+      m_RefNorm += ref[i]*ref[i];
     }
+    m_RefNorm = vcl_sqrt(static_cast<double>(m_RefNorm));
+    SetVariance(m_Variance);
+  };
 
-  TInput GetReferencePixel(){ return m_ReferencePixel; };
-  double GetVariance(){ return m_Variance; };
-
- protected:
+  void SetVariance(double variance)
+  {
+    m_Variance = variance;
+    m_Denom = 2 * variance * variance * m_RefNorm * m_RefNorm;
+  }
+
+  TInput GetReferencePixel()
+  {
+    return m_ReferencePixel;
+  };
+  double GetVariance()
+  {
+    return m_Variance;
+  };
+
+protected:
   SpectralAngleFunctorType m_SpectralAngleFunctor;
   TInput m_ReferencePixel;
   double m_RefNorm;

Code/FeatureExtraction/otbEnergyTextureFunctor.h

@@ -23,92 +23,101 @@
 namespace otb
 {
 namespace Functor
-  {
-    /** \class EnergyTextureFunctor
-     *  \brief This functor calculates the local energy of an image
-     *
-     *   Computes the sqaure gradient which is computed using offset and 
-     *   angle pixel of the neighborhood.
-     *   TIterInput is an ietrator, TOutput is a PixelType.
-     *
-     *  \ingroup Functor
-     *  \ingroup Statistics
-     */
+{
+/** \class EnergyTextureFunctor
+ *  \brief This functor calculates the local energy of an image
+ *
+ *   Computes the sqaure gradient which is computed using offset and
+ *   angle pixel of the neighborhood.
+ *   TIterInput is an ietrator, TOutput is a PixelType.
+ *
+ *  \ingroup Functor
+ *  \ingroup Statistics
+ */
 template <class TIterInput1, class TIterInput2, class TOutput>
 class EnergyTextureFunctor
- {
- public:
-   EnergyTextureFunctor(){ m_Offset.Fill(1); };
-   ~EnergyTextureFunctor(){};
-
-   typedef TIterInput1                    IterType1;
-   typedef TIterInput2                    IterType2;
-   typedef TOutput                        OutputType;
-   typedef typename IterType1::OffsetType OffsetType;
-   typedef typename IterType1::RadiusType RadiusType;
-   typedef typename OutputType::ValueType OutputPixelType;
-   
-   void SetOffset(OffsetType off){ m_Offset=off; };
-    OffsetType GetOffset(){ return m_Offset; };
-
-   inline TOutput operator()(const TIterInput1 &it, const TIterInput2 &itOff)
-     {
-       RadiusType radius = it.GetRadius();
-       unsigned int nbComp = it.GetCenterPixel().GetSize();
-       double area = static_cast<double>(radius[0]*radius[1]);
-       OutputType outPix;
-       outPix.SetSize( nbComp );
-       outPix.Fill(0);
-
-       
-       OffsetType offset;
-       offset.Fill(0);
-       OffsetType offsetOff;
-       OffsetType offsetOffInit;  
- 
-       offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
-       offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
-      
-       //std::cout<<offsetOffInit<<std::endl;
- 
-       double temp = 0.;
-       int ll = 0;
-       double norm = 0.;
-       for( unsigned int i=0; i<nbComp; i++ )
-	 {
-	   offsetOff = offsetOffInit;
-	   temp = 0.;
-	   for( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
-	     {
-	       offsetOff[0]++;
-	       offsetOff[1] = offsetOffInit[1];
-	       offset[0] = l;
-	       ll = l*l;
-	       for( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
-		 {
-		   offsetOff[1]++;
-		   offset[1] = k;
-		   norm = vcl_pow(static_cast<double>(itOff.GetPixel(offsetOff)[i]-itOff.GetCenterPixel()[i]), 2);
-		   temp += norm;
-		 }
-	       temp /= area;
-	       outPix[i] = static_cast<OutputPixelType>( vcl_pow(temp, 2) );
-	     }
-	 }
-       
-     
-       return outPix;
-     }
-
- private:
-   OffsetType m_Offset;
-
- };
- 
-
-
-
-  } // namespace Functor
+{
+public:
+  EnergyTextureFunctor()
+  {
+    m_Offset.Fill(1);
+  };
+  ~EnergyTextureFunctor() {};
+
+  typedef TIterInput1                    IterType1;
+  typedef TIterInput2                    IterType2;
+  typedef TOutput                        OutputType;
+  typedef typename IterType1::OffsetType OffsetType;
+  typedef typename IterType1::RadiusType RadiusType;
+  typedef typename OutputType::ValueType OutputPixelType;
+
+  void SetOffset(OffsetType off)
+  {
+    m_Offset=off;
+  };
+  OffsetType GetOffset()
+  {
+    return m_Offset;
+  };
+
+  inline TOutput operator()(const TIterInput1 &it, const TIterInput2 &itOff)
+  {
+    RadiusType radius = it.GetRadius();
+    unsigned int nbComp = it.GetCenterPixel().GetSize();
+    double area = static_cast<double>(radius[0]*radius[1]);
+    OutputType outPix;
+    outPix.SetSize( nbComp );
+    outPix.Fill(0);
+
+
+    OffsetType offset;
+    offset.Fill(0);
+    OffsetType offsetOff;
+    OffsetType offsetOffInit;
+
+    offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
+    offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
+
+    //std::cout<<offsetOffInit<<std::endl;
+
+    double temp = 0.;
+    int ll = 0;
+    double norm = 0.;
+    for ( unsigned int i=0; i<nbComp; i++ )
+    {
+      offsetOff = offsetOffInit;
+      temp = 0.;
+      for ( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
+      {
+        offsetOff[0]++;
+        offsetOff[1] = offsetOffInit[1];
+        offset[0] = l;
+        ll = l*l;
+        for ( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
+        {
+          offsetOff[1]++;
+          offset[1] = k;
+          norm = vcl_pow(static_cast<double>(itOff.GetPixel(offsetOff)[i]-itOff.GetCenterPixel()[i]), 2);
+          temp += norm;
+        }
+        temp /= area;
+        outPix[i] = static_cast<OutputPixelType>( vcl_pow(temp, 2) );
+      }
+    }
+
+
+    return outPix;
+  }
+
+private:
+  OffsetType m_Offset;
+
+};
+
+
+
+
+} // namespace Functor
 } // namespace otb
 
 #endif

Code/FeatureExtraction/otbEnergyTextureImageFunction.h

@@ -29,23 +29,23 @@ namespace otb
  * \class EnergyImageFunction
  * \brief Calculate the energy in the neighborhood of a pixel
  *
- * This class is templated over the input image type and the 
+ * This class is templated over the input image type and the
  * coordinate representation type (e.g. float or double ).
  *
  * \ingroup ImageFunctions
  */
 template <class TInputImage, class TCoordRep = float >
 class ITK_EXPORT EnergyTextureImageFunction :
-  public itk::ImageFunction< TInputImage, ITK_TYPENAME itk::NumericTraits<typename TInputImage::PixelType>::RealType, TCoordRep >
+      public itk::ImageFunction< TInputImage, ITK_TYPENAME itk::NumericTraits<typename TInputImage::PixelType>::RealType, TCoordRep >
 {
-  public:
+public:
   /** Standard class typedefs. */
   typedef EnergyTextureImageFunction Self;
   typedef itk::ImageFunction<TInputImage, ITK_TYPENAME itk::NumericTraits<typename TInputImage::PixelType>::RealType,
   TCoordRep > Superclass;
   typedef itk::SmartPointer<Self> Pointer;
   typedef itk::SmartPointer<const Self>  ConstPointer;
-  
+
   /** Run-time type information (and related methods). */
   itkTypeMacro(EnergyTextureImageFunction, itk::ImageFunction);
 
@@ -66,24 +66,24 @@ class ITK_EXPORT EnergyTextureImageFunction :
   /** Dimension of the underlying image. */
   itkStaticConstMacro(ImageDimension, unsigned int,InputImageType::ImageDimension);
 
-  
+
   /** Evalulate the function at specified index */
   virtual RealType EvaluateAtIndex( const IndexType& index ) const;
-  
+
   /** Evaluate the function at non-integer positions */
   virtual RealType Evaluate( const PointType& point ) const
-    { 
-      IndexType index;
-      this->ConvertPointToNearestIndex( point, index );
-      return this->EvaluateAtIndex( index ); 
-    }
-  virtual RealType EvaluateAtContinuousIndex( 
+  {
+    IndexType index;
+    this->ConvertPointToNearestIndex( point, index );
+    return this->EvaluateAtIndex( index );
+  }
+  virtual RealType EvaluateAtContinuousIndex(
     const ContinuousIndexType& cindex ) const
-    { 
-      IndexType index;
-      this->ConvertContinuousIndexToNearestIndex( cindex, index );
-      return this->EvaluateAtIndex( index ) ; 
-    }
+  {
+    IndexType index;
+    this->ConvertContinuousIndexToNearestIndex( cindex, index );
+    return this->EvaluateAtIndex( index ) ;
+  }
 
   /** Get/Set the radius of the neighborhood over which the
       statistics are evaluated */
@@ -91,10 +91,10 @@ class ITK_EXPORT EnergyTextureImageFunction :
   itkGetMacro( Radius, SizeType);
   itkSetMacro( Offset, OffsetType);
   itkGetMacro( Offset, OffsetType );
- 
+
 protected:
   EnergyTextureImageFunction();
-  ~EnergyTextureImageFunction(){};
+  ~EnergyTextureImageFunction() {};
   void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
 private:

Code/FeatureExtraction/otbEnergyTextureImageFunction.txx

@@ -21,7 +21,7 @@
 #include "otbEnergyTextureImageFunction.h"
 #include "itkConstNeighborhoodIterator.h"
 #include "otbEnergyTextureFunctor.h"
-          
+
 
 namespace otb
 {
@@ -48,7 +48,7 @@ EnergyTextureImageFunction<TInputImage,TCoordRep>
 {
   this->Superclass::PrintSelf(os,indent);
   os << indent << "Radius: "  << m_Radius << std::endl;
-  os << indent << "Offset: "  << m_Offset << std::endl; 
+  os << indent << "Offset: "  << m_Offset << std::endl;
 }
 
 
@@ -61,22 +61,22 @@ typename EnergyTextureImageFunction<TInputImage,TCoordRep>
 EnergyTextureImageFunction<TInputImage,TCoordRep>
 ::EvaluateAtIndex(const IndexType& index) const
 {
-  if( !this->GetInputImage() )
-    {
-      return ( itk::NumericTraits<RealType>::max() );
-    }
-  
+  if ( !this->GetInputImage() )
+  {
+    return ( itk::NumericTraits<RealType>::max() );
+  }
+
   if ( !this->IsInsideBuffer( index ) )
-    {
-      return ( itk::NumericTraits<RealType>::max() );
-    }
-  
+  {
+    return ( itk::NumericTraits<RealType>::max() );
+  }
+
   typedef itk::ConstNeighborhoodIterator<InputImageType> IterType;
   IterType it(m_Radius, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion());
   it.SetLocation(index);
   SizeType radiusOff;
   radiusOff[0] = m_Radius[0] + vcl_abs(m_Offset[0]);
-  radiusOff[1] = m_Radius[1] + vcl_abs(m_Offset[1]);   
+  radiusOff[1] = m_Radius[1] + vcl_abs(m_Offset[1]);
   IterType itOff(radiusOff, this->GetInputImage(), this->GetInputImage()->GetBufferedRegion());
   itOff.SetLocation(index);
 
@@ -87,44 +87,44 @@ EnergyTextureImageFunction<TInputImage,TCoordRep>
   funct.SetOffset(m_Offset);
   funct(it, itOff);
   //FunctType::operator()(it, itOff);
-  
+
   return 0;
   */
   double area = static_cast<double>(m_Radius[0]*m_Radius[1]);
   RealType output;
-  
+
   OffsetType offset;
   offset.Fill(0);
   OffsetType offsetOff;
-  OffsetType offsetOffInit;  
-  
+  OffsetType offsetOffInit;
+
   offsetOffInit[0] = -m_Radius[0]+m_Offset[0]-1; //++ in for
   offsetOffInit[1] = -m_Radius[1]+m_Offset[1]-1; //++ in for
-  
+
   double temp = 0.;
   int ll = 0;
   double norm = 0.;
   offsetOff = offsetOffInit;
   temp = 0.;
-  for( int l = -static_cast<int>(m_Radius[0]); l <= static_cast<int>(m_Radius[0]); l++ )
+  for ( int l = -static_cast<int>(m_Radius[0]); l <= static_cast<int>(m_Radius[0]); l++ )
+  {
+    offsetOff[0]++;
+    offset[0] = l;
+    ll = l*l;
+    offsetOff[1] = offsetOffInit[1];
+    for ( int k = -static_cast<int>(m_Radius[1]); k <= static_cast<int>(m_Radius[1]); k++)
     {
-      offsetOff[0]++;
-      offset[0] = l;
-      ll = l*l;
-      offsetOff[1] = offsetOffInit[1];
-      for( int k = -static_cast<int>(m_Radius[1]); k <= static_cast<int>(m_Radius[1]); k++)
-	{
-	  offsetOff[1]++;
-	  offset[1] = k;
-	  norm = vcl_pow(static_cast<double>(itOff.GetPixel(offsetOff)-itOff.GetCenterPixel()), 2);
-	  temp += norm;
-	}
-      temp /= area;
-      output = static_cast<RealType>( vcl_pow(temp, 2) );
+      offsetOff[1]++;
+      offset[1] = k;
+      norm = vcl_pow(static_cast<double>(itOff.GetPixel(offsetOff)-itOff.GetCenterPixel()), 2);
+      temp += norm;
     }
+    temp /= area;
+    output = static_cast<RealType>( vcl_pow(temp, 2) );
+  }
   return output;
-  
-  
+
+
 
 }
 

Code/FeatureExtraction/otbEntropyTextureFunctor.h

@@ -23,221 +23,227 @@
 namespace otb
 {
 namespace Functor
-  {
-    /** \class EntropyTextureFunctor
-     *  \brief This functor calculates the local energy of an image
-     *
-     *   Computes the sqaure gradient which is computed using offset and 
-     *   angle pixel of the neighborhood.
-     *   TIterInput is an ietrator, TOutput is a PixelType.
-     *
-     *  \ingroup Functor
-     *  \ingroup Statistics
-     */
+{
+/** \class EntropyTextureFunctor
+ *  \brief This functor calculates the local energy of an image
+ *
+ *   Computes the sqaure gradient which is computed using offset and
+ *   angle pixel of the neighborhood.
+ *   TIterInput is an ietrator, TOutput is a PixelType.
+ *
+ *  \ingroup Functor
+ *  \ingroup Statistics
+ */
 template <class TIterInput1, class TIterInput2, class TOutput>
 class EntropyTextureFunctor
- {
- public:
-   EntropyTextureFunctor()
-     { 
-       m_Offset.Fill(1);
-       //m_BinLength = IntVectyorType(0, 1);
-     };
-   ~EntropyTextureFunctor(){};
-
-   typedef TIterInput1                    IterType1;
-   typedef TIterInput2                    IterType2;
-   typedef TOutput                        OutputType;
-   typedef typename IterType1::OffsetType OffsetType;
-   typedef typename IterType1::RadiusType RadiusType;
-   typedef typename OutputType::ValueType OutputPixelType;
-   typedef std::vector<double>            DoubleVectorType;
-   typedef std::vector<int>               IntVectorType;
-   typedef std::vector<IntVectorType>    IntVectorVectorType;
-
-   void SetOffset(OffsetType off){ m_Offset=off; };
-   OffsetType GetOffset(){ return m_Offset; };
-
-   IntVectorVectorType StatComputation(const TIterInput1 &it, const TIterInput2 &itOff)
-     {
-       IntVectorVectorType output;
-       IntVectorType binLength;
-       IntVectorType binLengthOff;
-       RadiusType radius = it.GetRadius();
-       unsigned int nbComp = it.GetCenterPixel().GetSize();
-       m_Mini = DoubleVectorType(nbComp, itk::NumericTraits<double>::max());
-       m_MiniOff = DoubleVectorType(nbComp, itk::NumericTraits<double>::max());
-       m_Maxi = DoubleVectorType(nbComp, itk::NumericTraits<double>::NonpositiveMin());
-       m_MaxiOff = DoubleVectorType(nbComp, itk::NumericTraits<double>::NonpositiveMin());
-       double area = static_cast<double>(radius[0]*radius[1]);
-       double areaInv = 1/area;
-            
-       OffsetType offset;
-       offset.Fill(0);
-       OffsetType offsetOff;
-       OffsetType offsetOffInit;  
- 
-       offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
-       offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
-       IntVectorType mean;
-       IntVectorType meanOff;
-       for( unsigned int i=0; i<nbComp; i++ )
-	 {
-	   offsetOff = offsetOffInit;
-	   double meanCh = 0.;
-	   double meanChOff = 0.;
-	   for( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
-	     {
-	       offsetOff[0]++;
-	       offsetOff[1] = offsetOffInit[1];  
-	       offset[0] = l;
-	       for( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
-		 {
-		   //std::cout<<it.GetPixel(offset)[i]<<std::endl;
-		   offsetOff[1]++;
-		   offset[1] = k;
-		   meanCh += static_cast<double>(it.GetPixel(offset)[i]);
-		   meanChOff += static_cast<double>(itOff.GetPixel(offsetOff)[i]);
-	
-		   m_Mini[i] = std::min(static_cast<double>(it.GetPixel(offset)[i]),   m_Mini[i]);
-		   m_MiniOff[i] = std::min(static_cast<double>(itOff.GetPixel(offsetOff)[i]),   m_MiniOff[i]);
-		   m_Maxi[i] = std::max(static_cast<double>(it.GetPixel(offset)[i]),   m_Maxi[i]);
-		   m_MaxiOff[i] = std::max(static_cast<double>(itOff.GetPixel(offsetOff)[i]),   m_MaxiOff[i]);
-		 }
-	       mean.push_back(meanCh * areaInv);
-	       meanOff.push_back(meanChOff * areaInv);
-	     }
-	 }
-     
-       for( unsigned int i=0; i<nbComp; i++ )
-	 { 
-	   offsetOff = offsetOffInit;
-	   double stdCh = 0.;
-	   double stdChOff = 0.;
-	   for( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
-	     {
-	       offsetOff[0]++;
-	       offsetOff[1] = offsetOffInit[1];  
-	       offset[0] = l;
-	       for( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
-		 {
-		   offsetOff[1]++;
-		   offset[1] = k;
-		   stdCh += vcl_pow( (mean[i]-static_cast<double>(it.GetPixel(offset)[i])), 2);
-		   stdChOff += vcl_pow( (meanOff[i]-static_cast<double>(itOff.GetPixel(offsetOff)[i])), 2);
-		 }
-	     }
-	   stdCh *= areaInv;
-	   stdCh = vcl_sqrt( stdCh );
-	   stdChOff *= areaInv;
-	   stdChOff = vcl_sqrt( stdChOff );
-	   binLength.push_back( (3.5*stdCh) /(vcl_pow(area, 1/3) ) );
-	   binLengthOff.push_back( (3.5*stdChOff) /(vcl_pow(area, 1/3) ) );		
-	 }
-
-       output.push_back(binLength);
-       output.push_back(binLengthOff);
-
-       return output;
-     }
-   
-
-   inline TOutput operator()(const TIterInput1 &it, const TIterInput2 &itOff)
-     {
-       //std::cout<<"operator"<<std::endl;
-       IntVectorVectorType binsLength = this->StatComputation(it, itOff);
-
-       RadiusType radius = it.GetRadius();
-       unsigned int nbComp = it.GetCenterPixel().GetSize();
-       double area = static_cast<double>(radius[0]*radius[1]);
-       double areaInv = 1/area;
-       OutputType outPix;
-       outPix.SetSize( nbComp );
-       outPix.Fill(0);
-
-       
-       OffsetType offset;
-       offset.Fill(0);
-       OffsetType offsetOff;
-       OffsetType offsetOffInit;  
- 
-       offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
-       offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
-
-       int histoIdX = 0;
-       int histoIdY = 0;
-
-       for( unsigned int i=0; i<nbComp; i++ )
-	 { 
-	   //std::cout<<"i :"<<i<<" "<<std::endl;
-
-	   IntVectorType histoTemp;
-	   IntVectorVectorType histo;
-	   if(binsLength[0][i] != 0)
-	     histoTemp = IntVectorType( vcl_floor((m_Maxi[i]-m_Mini[i])/binsLength[0][i])+1, 0 );
-	   else
-	     histoTemp = IntVectorType( 1, 0 );
-	   if(binsLength[1][i] != 0)
-	     histo = IntVectorVectorType( vcl_floor((m_MaxiOff[i]-m_MiniOff[i])/binsLength[1][i])+1, histoTemp );
-	   else
-	     histo = IntVectorVectorType( 1, histoTemp );
- 
-	   //std::cout<<"m_Maxi[i]-m_Mini[i]  "<<m_Maxi[i]<<"  "<<m_Mini[i]<<std::endl;
-	   //std::cout<<"binsLength[0][i] "<<binsLength[0][i]<<std::endl;
-	   //std::cout<<histoTemp.size()<<"   "<<histo.size()<<std::endl;
-
-	   offsetOff = offsetOffInit;
-	   for( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
-	     { //std::cout<<"i :"<<i<<" "<<l<<std::endl;
-	       offsetOff[0]++;
-	       offsetOff[1] = offsetOffInit[1];
-	       offset[0] = l;
-	       for( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
-		 {
-		   //std::cout<<i<<" "<<l<<" "<<k<<std::endl;
-		   offsetOff[1]++;
-		   offset[1] = k;
-		   if( binsLength[1][i] != 0)
-		     histoIdX = vcl_floor( (itOff.GetPixel(offsetOff)[i]-m_MiniOff[i]) / binsLength[1][i] );
-		   else
-		     histoIdX = 0;
-		   if( binsLength[0][i] !=0 )
-		     histoIdY = vcl_floor( (it.GetPixel(offset)[i]-m_Mini[i]) / binsLength[0][i] );
-		   else
-		     histoIdY = 0;
-		   histo[histoIdX][histoIdY]++;
-	
-		 }
-	     }
-	   for(unsigned r = 0; r<binsLength.size(); r++)
-	     {
-	       for(unsigned s = 0; s<binsLength[r].size(); s++)
-		 {
-		   double p = binsLength[r][s] * areaInv;
-		   if(p != 0)
-		     outPix[i] += static_cast<OutputPixelType>(p * vcl_log(p));
-		 }  
-	     }
-	   
-	 }
-       
-       //std::cout<<"operator FIN"<<std::endl;   
-       return outPix;
-
-     }
-
- private:
-   OffsetType m_Offset;
-   DoubleVectorType m_Mini;
-   DoubleVectorType m_MiniOff;
-   DoubleVectorType m_Maxi;
-   DoubleVectorType m_MaxiOff;
- };
- 
-
-
-
-  } // namespace Functor
+{
+public:
+  EntropyTextureFunctor()
+  {
+    m_Offset.Fill(1);
+    //m_BinLength = IntVectyorType(0, 1);
+  };
+  ~EntropyTextureFunctor() {};
+
+  typedef TIterInput1                    IterType1;
+  typedef TIterInput2                    IterType2;
+  typedef TOutput                        OutputType;
+  typedef typename IterType1::OffsetType OffsetType;
+  typedef typename IterType1::RadiusType RadiusType;
+  typedef typename OutputType::ValueType OutputPixelType;
+  typedef std::vector<double>            DoubleVectorType;
+  typedef std::vector<int>               IntVectorType;
+  typedef std::vector<IntVectorType>    IntVectorVectorType;
+
+  void SetOffset(OffsetType off)
+  {
+    m_Offset=off;
+  };
+  OffsetType GetOffset()
+  {
+    return m_Offset;
+  };
+
+  IntVectorVectorType StatComputation(const TIterInput1 &it, const TIterInput2 &itOff)
+  {
+    IntVectorVectorType output;
+    IntVectorType binLength;
+    IntVectorType binLengthOff;
+    RadiusType radius = it.GetRadius();
+    unsigned int nbComp = it.GetCenterPixel().GetSize();
+    m_Mini = DoubleVectorType(nbComp, itk::NumericTraits<double>::max());
+    m_MiniOff = DoubleVectorType(nbComp, itk::NumericTraits<double>::max());
+    m_Maxi = DoubleVectorType(nbComp, itk::NumericTraits<double>::NonpositiveMin());
+    m_MaxiOff = DoubleVectorType(nbComp, itk::NumericTraits<double>::NonpositiveMin());
+    double area = static_cast<double>(radius[0]*radius[1]);
+    double areaInv = 1/area;
+
+    OffsetType offset;
+    offset.Fill(0);
+    OffsetType offsetOff;
+    OffsetType offsetOffInit;
+
+    offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
+    offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
+    IntVectorType mean;
+    IntVectorType meanOff;
+    for ( unsigned int i=0; i<nbComp; i++ )
+    {
+      offsetOff = offsetOffInit;
+      double meanCh = 0.;
+      double meanChOff = 0.;
+      for ( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
+      {
+        offsetOff[0]++;
+        offsetOff[1] = offsetOffInit[1];
+        offset[0] = l;
+        for ( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
+        {
+          //std::cout<<it.GetPixel(offset)[i]<<std::endl;
+          offsetOff[1]++;
+          offset[1] = k;
+          meanCh += static_cast<double>(it.GetPixel(offset)[i]);
+          meanChOff += static_cast<double>(itOff.GetPixel(offsetOff)[i]);
+
+          m_Mini[i] = std::min(static_cast<double>(it.GetPixel(offset)[i]),   m_Mini[i]);
+          m_MiniOff[i] = std::min(static_cast<double>(itOff.GetPixel(offsetOff)[i]),   m_MiniOff[i]);
+          m_Maxi[i] = std::max(static_cast<double>(it.GetPixel(offset)[i]),   m_Maxi[i]);
+          m_MaxiOff[i] = std::max(static_cast<double>(itOff.GetPixel(offsetOff)[i]),   m_MaxiOff[i]);
+        }
+        mean.push_back(meanCh * areaInv);
+        meanOff.push_back(meanChOff * areaInv);
+      }
+    }
+
+    for ( unsigned int i=0; i<nbComp; i++ )
+    {
+      offsetOff = offsetOffInit;
+      double stdCh = 0.;
+      double stdChOff = 0.;
+      for ( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
+      {
+        offsetOff[0]++;
+        offsetOff[1] = offsetOffInit[1];
+        offset[0] = l;
+        for ( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
+        {
+          offsetOff[1]++;
+          offset[1] = k;
+          stdCh += vcl_pow( (mean[i]-static_cast<double>(it.GetPixel(offset)[i])), 2);
+          stdChOff += vcl_pow( (meanOff[i]-static_cast<double>(itOff.GetPixel(offsetOff)[i])), 2);
+        }
+      }
+      stdCh *= areaInv;
+      stdCh = vcl_sqrt( stdCh );
+      stdChOff *= areaInv;
+      stdChOff = vcl_sqrt( stdChOff );
+      binLength.push_back( (3.5*stdCh) /(vcl_pow(area, 1/3) ) );
+      binLengthOff.push_back( (3.5*stdChOff) /(vcl_pow(area, 1/3) ) );
+    }
+
+    output.push_back(binLength);
+    output.push_back(binLengthOff);
+
+    return output;
+  }
+
+
+  inline TOutput operator()(const TIterInput1 &it, const TIterInput2 &itOff)
+  {
+    //std::cout<<"operator"<<std::endl;
+    IntVectorVectorType binsLength = this->StatComputation(it, itOff);
+
+    RadiusType radius = it.GetRadius();
+    unsigned int nbComp = it.GetCenterPixel().GetSize();
+    double area = static_cast<double>(radius[0]*radius[1]);
+    double areaInv = 1/area;
+    OutputType outPix;
+    outPix.SetSize( nbComp );
+    outPix.Fill(0);
+
+
+    OffsetType offset;
+    offset.Fill(0);
+    OffsetType offsetOff;
+    OffsetType offsetOffInit;
+
+    offsetOffInit[0] = -radius[0]+m_Offset[0]-1;
+    offsetOffInit[1] = -radius[1]+m_Offset[1]-1;
+
+    int histoIdX = 0;
+    int histoIdY = 0;
+
+    for ( unsigned int i=0; i<nbComp; i++ )
+    {
+      //std::cout<<"i :"<<i<<" "<<std::endl;
+
+      IntVectorType histoTemp;
+      IntVectorVectorType histo;
+      if (binsLength[0][i] != 0)
+        histoTemp = IntVectorType( vcl_floor((m_Maxi[i]-m_Mini[i])/binsLength[0][i])+1, 0 );
+      else
+        histoTemp = IntVectorType( 1, 0 );
+      if (binsLength[1][i] != 0)
+        histo = IntVectorVectorType( vcl_floor((m_MaxiOff[i]-m_MiniOff[i])/binsLength[1][i])+1, histoTemp );
+      else
+        histo = IntVectorVectorType( 1, histoTemp );
+
+      //std::cout<<"m_Maxi[i]-m_Mini[i]  "<<m_Maxi[i]<<"  "<<m_Mini[i]<<std::endl;
+      //std::cout<<"binsLength[0][i] "<<binsLength[0][i]<<std::endl;
+      //std::cout<<histoTemp.size()<<"   "<<histo.size()<<std::endl;
+
+      offsetOff = offsetOffInit;
+      for ( int l = -static_cast<int>(radius[0]); l <= static_cast<int>(radius[0]); l++ )
+      { //std::cout<<"i :"<<i<<" "<<l<<std::endl;
+        offsetOff[0]++;
+        offsetOff[1] = offsetOffInit[1];
+        offset[0] = l;
+        for ( int k = -static_cast<int>(radius[1]); k <= static_cast<int>(radius[1]); k++)
+        {
+          //std::cout<<i<<" "<<l<<" "<<k<<std::endl;
+          offsetOff[1]++;
+          offset[1] = k;
+          if ( binsLength[1][i] != 0)
+            histoIdX = vcl_floor( (itOff.GetPixel(offsetOff)[i]-m_MiniOff[i]) / binsLength[1][i] );
+          else
+            histoIdX = 0;
+          if ( binsLength[0][i] !=0 )
+            histoIdY = vcl_floor( (it.GetPixel(offset)[i]-m_Mini[i]) / binsLength[0][i] );
+          else
+            histoIdY = 0;
+          histo[histoIdX][histoIdY]++;
+
+        }
+      }
+      for (unsigned r = 0; r<binsLength.size(); r++)
+      {
+        for (unsigned s = 0; s<binsLength[r].size(); s++)
+        {
+          double p = binsLength[r][s] * areaInv;
+          if (p != 0)
+            outPix[i] += static_cast<OutputPixelType>(p * vcl_log(p));
+        }
+      }
+
+    }
+
+    //std::cout<<"operator FIN"<<std::endl;
+    return outPix;
+
+  }
+
+private:
+  OffsetType m_Offset;
+  DoubleVectorType m_Mini;
+  DoubleVectorType m_MiniOff;
+  DoubleVectorType m_Maxi;
+  DoubleVectorType m_MaxiOff;
+};
+
+
+
+
+} // namespace Functor
 } // namespace otb
 
 #endif

Code/SpatialReasoning/otbPolygonListToRCC8GraphFilter.h

@@ -85,7 +85,7 @@ public:
   itkSetMacro(Optimisation,bool);
   itkBooleanMacro(UseInverted);
   itkSetMacro(UseInverted,bool);
-  
+
   void SetSegmentationRanges(SegmentationRangesType ranges)
   {
     m_SegmentationRanges = ranges;

Code/SpatialReasoning/otbPolygonListToRCC8GraphFilter.txx

@@ -342,10 +342,10 @@ PolygonListToRCC8GraphFilter<TPolygonList, TOutputGraph>
             // Add the edge to the graph.
             otbMsgDevMacro(<<"Adding edge: "<<vIt1.GetIndex()<<" -> "<<vIt2.GetIndex()<<": "<<value);
             m_EdgesPerThread[threadId][EdgePairType(vIt1.GetIndex(),vIt2.GetIndex())]=value;
-	    if(m_UseInverted)
-	      {
-	      m_EdgesPerThread[threadId][EdgePairType(vIt2.GetIndex(),vIt1.GetIndex())]=invert[value];
-	      }
+            if (m_UseInverted)
+            {
+              m_EdgesPerThread[threadId][EdgePairType(vIt2.GetIndex(),vIt1.GetIndex())]=invert[value];
+            }
           }
         }
         progress.CompletedPixel();