STYLE

Code/BasicFilters/otbBCOInterpolateImageFunction.h

@@ -49,12 +49,12 @@ namespace otb
  */
 template< class TInputImage, class TCoordRep = double >
 class ITK_EXPORT BCOInterpolateImageFunctionBase :
-  public itk::InterpolateImageFunction<TInputImage,TCoordRep>
+  public itk::InterpolateImageFunction<TInputImage, TCoordRep>
 {
 public:
   /** Standard class typedefs. */
   typedef BCOInterpolateImageFunctionBase                      Self;
-  typedef itk::InterpolateImageFunction<TInputImage,TCoordRep> Superclass;
+  typedef itk::InterpolateImageFunction<TInputImage, TCoordRep> Superclass;
 
   /** Run-time type information (and related methods). */
   itkTypeMacro(BCOInterpolateImageFunctionBase, InterpolateImageFunction);
@@ -131,13 +131,13 @@ class ITK_EXPORT BCOInterpolateImageFunction :
 public:
   /** Standard class typedefs. */
   typedef BCOInterpolateImageFunction                              Self;
-  typedef BCOInterpolateImageFunctionBase<TInputImage,TCoordRep>   Superclass;
+  typedef BCOInterpolateImageFunctionBase<TInputImage, TCoordRep>   Superclass;
   typedef itk::SmartPointer<Self>                                  Pointer;
   typedef itk::SmartPointer<const Self>                            ConstPointer;
 
   itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase);
   itkNewMacro(Self);
-  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
+  itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension);
 
   typedef typename Superclass::OutputType            OutputType;
   typedef typename Superclass::InputImageType        InputImageType;
@@ -163,20 +163,20 @@ private:
 
 
 template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
-class ITK_EXPORT BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep > :
-    public otb::BCOInterpolateImageFunctionBase< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+class ITK_EXPORT BCOInterpolateImageFunction< otb::VectorImage<TPixel, VImageDimension> , TCoordRep > :
+    public otb::BCOInterpolateImageFunctionBase< otb::VectorImage<TPixel, VImageDimension> , TCoordRep >
 {
 public:
   /** Standard class typedefs.*/
   typedef BCOInterpolateImageFunction                              Self;
   typedef BCOInterpolateImageFunctionBase
-      < otb::VectorImage<TPixel,VImageDimension>, TCoordRep >      Superclass;
+      < otb::VectorImage<TPixel, VImageDimension>, TCoordRep >      Superclass;
   typedef itk::SmartPointer<Self>                                  Pointer;
   typedef itk::SmartPointer<const Self>                            ConstPointer;
 
   itkTypeMacro(BCOInterpolateImageFunction, BCOInterpolateImageFunctionBase);
   itkNewMacro(Self);
-  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
+  itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension);
 
   typedef typename Superclass::OutputType            OutputType;
   typedef typename Superclass::InputImageType        InputImageType;

Code/BasicFilters/otbBCOInterpolateImageFunction.txx

@@ -188,16 +188,16 @@ BCOInterpolateImageFunction<TInputImage, TCoordRep>
 }
 
 template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
-void BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+void BCOInterpolateImageFunction< otb::VectorImage<TPixel, VImageDimension> , TCoordRep >
 ::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 }
 
 template < typename TPixel, unsigned int VImageDimension, class TCoordRep >
-typename BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+typename BCOInterpolateImageFunction< otb::VectorImage<TPixel, VImageDimension> , TCoordRep >
 ::OutputType
-BCOInterpolateImageFunction< otb::VectorImage<TPixel,VImageDimension> , TCoordRep >
+BCOInterpolateImageFunction< otb::VectorImage<TPixel, VImageDimension> , TCoordRep >
 ::EvaluateAtContinuousIndex( const ContinuousIndexType & index ) const
 {
   typedef typename itk::NumericTraits<InputPixelType>::ScalarRealType ScalarRealType;

Code/BasicFilters/otbBandMathImageFilter.h

@@ -53,18 +53,18 @@ namespace otb
  * Next step is to set the expression according to the variable
  * names. For example, in the default case with three input images the
  * following expression is valid :
- * "ndvi(b1,b2)*b3"
+ * "ndvi(b1, b2)*b3"
  *
  * As an additional functionality, the filter also granted access to
  * indexes information under special virtual bands named idxX, idxY
- * for the images indexes and idxPhyX,idxPhyY for the physical
+ * for the images indexes and idxPhyX, idxPhyY for the physical
  * indexes.
  * It allows the user to perform, for example a spatial processing
  * aiming to suppress a determined area :
  * "if(sqrt((idxPhyX-105.3)*(idxPhyX-105.3)+
  *          (idxPhyY-207.1)*(idxPhyY-207.1))>100, b1, 0)"
  * This expression replace the physical zone around the point of
- * physical index (105.3;207.1) by a black area
+ * physical index (105.3; 207.1) by a black area
  * This functionality assumes that all the band involved have the same
  * spacing and origin.
  *

Code/BasicFilters/otbComplexToIntensityImageFilter.h

@@ -57,7 +57,7 @@ public:
 template <class TInputImage, class TOutputImage>
 class ITK_EXPORT ComplexToIntensityImageFilter :
     public
-itk::UnaryFunctorImageFilter<TInputImage,TOutputImage,
+itk::UnaryFunctorImageFilter<TInputImage, TOutputImage,
                         Function::ComplexToIntensity<
   typename TInputImage::PixelType,
   typename TOutputImage::PixelType>   >
@@ -66,7 +66,7 @@ public:
   /** Standard class typedefs. */
   typedef ComplexToIntensityImageFilter  Self;
   typedef itk::UnaryFunctorImageFilter<
-    TInputImage,TOutputImage,
+    TInputImage, TOutputImage,
     Function::ComplexToIntensity< typename TInputImage::PixelType,
                               typename TOutputImage::PixelType> >
                                          Superclass;

Code/BasicFilters/otbComplexToVectorImageCastFilter.h

@@ -65,7 +65,7 @@ public:
 template <class TInputImage, class TOutputImage>
 class ITK_EXPORT ComplexToVectorImageCastFilter :
     public
-otb::UnaryFunctorImageFilter<TInputImage,TOutputImage,
+otb::UnaryFunctorImageFilter<TInputImage, TOutputImage,
                         Functor::ComplexToVector<
   typename TInputImage::PixelType,
   typename TOutputImage::PixelType>   >
@@ -74,7 +74,7 @@ public:
   /** Standard class typedefs. */
   typedef ComplexToVectorImageCastFilter  Self;
   typedef otb::UnaryFunctorImageFilter<
-    TInputImage,TOutputImage,
+    TInputImage, TOutputImage,
     Functor::ComplexToVector< typename TInputImage::PixelType,
     typename TOutputImage::PixelType> >                        Superclass;
   typedef itk::SmartPointer<Self>             Pointer;

Code/BasicFilters/otbContinuousMinimumMaximumImageCalculator.h

@@ -37,8 +37,8 @@ namespace otb
    * The continuous extrema is assumed to be at the zero of the first order
    * derivative of this polynom.
    *
-   * If we denote \f$ (x_0,y_0) \f$ the extrema and  \f$ (x_{-1},y_{-1}) \f$ and
-   * \f$ (x_1,y_1) \f$ its neighbor, the second degree polynom verify the
+   * If we denote \f$ (x_0, y_0) \f$ the extrema and  \f$ (x_{-1}, y_{-1}) \f$ and
+   * \f$ (x_1, y_1) \f$ its neighbor, the second degree polynom verify the
    * following equations:
    *
    *

Code/BasicFilters/otbContinuousMinimumMaximumImageCalculator.txx

@@ -219,7 +219,7 @@ ContinuousMinimumMaximumImageCalculator<TInputImage>
     ++it;
     }
 
-  //Solve equations a,b,c
+  //Solve equations a, b, c
 //     y0 = a*x0^2 + b*x0 +c
 //     y1 = a*x1^2 + b*x1 +c
 //     y2 = a*x2^2 + b*x2 +c

Code/BasicFilters/otbFlexibleDistanceWithMissingValue.h

@@ -36,7 +36,7 @@ namespace Statistics {
  *
  * The general formulation is defined as:
  * \f$
-    d(x,y) = \sum_i | x_i^a - y_i^a |^b.
+    d(x, y) = \sum_i | x_i^a - y_i^a |^b.
   \f$
  *
  * The class can be templated over any container that holds data elements, as

Code/BasicFilters/otbFrostImageFilter.h

@@ -32,13 +32,13 @@ namespace otb
  * The output of the filter for pixel p is:
  *      \f$ \hat I_{s}=\sum_{p\in\eta_{p}} m_{p}I_{p} \f$
  *
- * where :   \f$ m_{p}=\frac{KC_{s}^{2}\exp(-KC_{s}^{2}d_{s,p})}{\sum_{p\in\eta_{p}} KC_{s}^{2}\exp(-KC_{s}^{2}d_{s,p})} \f$
- *    and  \f$ d_{s,p}=\sqrt{(i-i_{p})^2+(j-j_{p})^2} \f$
+ * where :   \f$ m_{p}=\frac{KC_{s}^{2}\exp(-KC_{s}^{2}d_{s, p})}{\sum_{p\in\eta_{p}} KC_{s}^{2}\exp(-KC_{s}^{2}d_{s, p})} \f$
+ *    and  \f$ d_{s, p}=\sqrt{(i-i_{p})^2+(j-j_{p})^2} \f$
  *
  * \f$ K \f$     : the decrease coefficient
- * \f$ (i,j)\f$ : the coordinates of the pixel inside the region
+ * \f$ (i, j)\f$ : the coordinates of the pixel inside the region
  * defined by \f$ \eta_{s} \f$
- * \f$ (i_{p},j_{p})\f$ : the coordinates of the pixels belonging to \f$ \eta_{p} \subset \eta_{s} \f$
+ * \f$ (i_{p}, j_{p})\f$ : the coordinates of the pixels belonging to \f$ \eta_{p} \subset \eta_{s} \f$
  * \f$ C_{s}\f$ : the variation coefficient computed over \f$ \eta_{p}\f$
  *
  */

Code/BasicFilters/otbFunctionToImageFilter.txx

@@ -46,7 +46,7 @@ FunctionToImageFilter<TInputImage, TOutputImage, TFunction>
  */
 // template<class TInputImage, class TOutputImage, class TFunction >
 // void
-// FunctionToImageFilter<TInputImage,TOutputImage,TFunction>
+// FunctionToImageFilter<TInputImage, TOutputImage, TFunction>
 // ::SetInput( const TInputImage *image )
 // {
 //   // The ProcessObject is not const-correct so the const_cast is required here

Code/BasicFilters/otbGaborFilterGenerator.h

@@ -46,7 +46,7 @@ namespace otb
  *
  * The formula used to compute these coefficients is as follows:
  *
- * \f$ g(x,y) = \exp\Big(-\pi((a x_\theta)^{2} +(b y_\theta)^{2})\Big) * \cos\big(2\pi(u_0*x + v_0*y)+\phi\big) \f$
+ * \f$ g(x, y) = \exp\Big(-\pi((a x_\theta)^{2} +(b y_\theta)^{2})\Big) * \cos\big(2\pi(u_0*x + v_0*y)+\phi\big) \f$
  *
  * with:
  *

Code/BasicFilters/otbHillShadingFunctor.h

@@ -144,7 +144,7 @@ public:
     const typename IteratorType::OffsetType RIGHTDOWN = {{1, 1}};
     const typename IteratorType::OffsetType RIGHTUP  = {{1, -1}};
     const typename IteratorType::OffsetType LEFTDOWN = {{-1, 1}};
-//    const typename IteratorType::OffsetType CENTER ={{0,0}};
+//    const typename IteratorType::OffsetType CENTER ={{0, 0}};
 
     float xSlope =
       ((makeValid(it.GetPixel(LEFTUP)) + 2 * makeValid(it.GetPixel(LEFT)) + makeValid(it.GetPixel(LEFTDOWN)))

Code/BasicFilters/otbImaginaryImageToComplexImageFilter.h

@@ -51,14 +51,14 @@ public:
     }
   inline TOutput operator()( const TInputImageImaginaryPart & imaginary) const
     {
-    return TOutput(static_cast<OutputValueType>(0.0),static_cast<OutputValueType>(imaginary));
+    return TOutput(static_cast<OutputValueType>(0.0), static_cast<OutputValueType>(imaginary));
     }
 };
 }
 
 template <class TInputImageImaginaryPart, class TOutputImage>
 class ITK_EXPORT ImaginaryImageToComplexImageFilter :
-    public itk::UnaryFunctorImageFilter<TInputImageImaginaryPart,TOutputImage,
+    public itk::UnaryFunctorImageFilter<TInputImageImaginaryPart, TOutputImage,
                         Function::ImaginaryToComplex<
                                   typename TInputImageImaginaryPart::PixelType,
                                   typename TOutputImage::PixelType>   >

Code/BasicFilters/otbImportGeoInformationImageFilter.txx

@@ -89,7 +89,7 @@ ImportGeoInformationImageFilter<TImage, TSourceImage>
 
 // template <class TImage, class TSourceImage>
 // void
-//  ImportGeoInformationImageFilter<TImage,TSourceImage>
+//  ImportGeoInformationImageFilter<TImage, TSourceImage>
 // ::GenerateData(void)
 // {
 //   // Get output and source pointer

Code/BasicFilters/otbInverseLogPolarTransform.h

@@ -25,14 +25,14 @@ namespace otb
 /** \class InverseLogPolarTransform
  * \brief This transform is the back transform of the LogPolarTransform.
  *
- * Given (x,y) the coordinates of a point in cartesian system, the corresponding
+ * Given (x, y) the coordinates of a point in cartesian system, the corresponding
  * log-polar coordinates are :
  * \f$ \rho = 1/2*log((x-xc)^2+(y+yc)^2) \f$
  * \f$ \theta = asin(y-yc)/(\sqrt{(x-xc)^2+(y+yc)^2}) \f$
  *
  * In this implemenatation, theta is expressed in degree, and the result of the asin function
- * is clamped to the [0,360] range. Please note that since the transform of the center has no meaning
- * it is rejected to the point [400,0], which does not belong to this range.  This is done to provide
+ * is clamped to the [0, 360] range. Please note that since the transform of the center has no meaning
+ * it is rejected to the point [400, 0], which does not belong to this range.  This is done to provide
  * a coordinate not likely to belong to a log-polar image buffer.
  *
  * \sa LogPolarTransform

Code/BasicFilters/otbInverseLogPolarTransform.txx

@@ -98,7 +98,7 @@ InverseLogPolarTransform<TScalarType>
     result[0] = (1. / m_Scale[0]) * vcl_asin((point[1] - m_Center[1]) / rho);
     // degree conversion
     result[0] = result[0] * (180. / CONST_PI);
-    // Deplacing the range to [0,90], [270,360]
+    // Deplacing the range to [0, 90], [270, 360]
     result[0] = result[0] > 0. ? result[0] : result[0] + 360.;
     // Avoiding asin indetermination
     if ((point[0] - m_Center[0]) >= 0)
@@ -106,7 +106,7 @@ InverseLogPolarTransform<TScalarType>
       result[0] = result[0] < 90. ? result[0] + 90. : result[0] - 90.;
       }
     result[1] = (1. / m_Scale[1]) * vcl_log(rho);
-    // otbMsgDebugMacro(<<vcl_log(vcl_pow(point[0]-m_Center[0],2)+vcl_pow(point[1]-m_Center[1],2)));
+    // otbMsgDebugMacro(<<vcl_log(vcl_pow(point[0]-m_Center[0], 2)+vcl_pow(point[1]-m_Center[1], 2)));
     }
   else
     {
@@ -134,7 +134,7 @@ InverseLogPolarTransform<TScalarType>
     result[0] = (1 / m_Scale[0]) * vcl_asin((vector[1] - m_Center[1]) / rho);
     // degree conversion
     result[0] = result[0] * (180 / CONST_PI);
-    // Deplacing the range to [0,90], [270,360]
+    // Deplacing the range to [0, 90], [270, 360]
     result[0] = result[0] > 0 ? result[0] : result[0] + 360;
     // Avoiding asin indetermination
     if ((vector[0] - m_Center[0]) >= 0)
@@ -142,7 +142,7 @@ InverseLogPolarTransform<TScalarType>
       result[0] = result[0] < 90 ? result[0] + 90 : result[0] - 90;
       }
     result[1] = (1 / m_Scale[1]) * vcl_log(rho);
-    // otbMsgDebugMacro(<<vcl_log(vcl_pow(vector[0]-m_Center[0],2)+vcl_pow(vector[1]-m_Center[1],2)));
+    // otbMsgDebugMacro(<<vcl_log(vcl_pow(vector[0]-m_Center[0], 2)+vcl_pow(vector[1]-m_Center[1], 2)));
     }
   else
     {
@@ -170,7 +170,7 @@ InverseLogPolarTransform<TScalarType>
     result[0] = (1 / m_Scale[0]) * vcl_asin((vector[1] - m_Center[1]) / rho);
     // degree conversion
     result[0] = result[0] * (180 / CONST_PI);
-    // Deplacing the range to [0,90], [270,360]
+    // Deplacing the range to [0, 90], [270, 360]
     result[0] = result[0] > 0 ? result[0] : result[0] + 360;
     // Avoiding vcl_asin indetermination
     if ((vector[0] - m_Center[0]) >= 0)
@@ -178,7 +178,7 @@ InverseLogPolarTransform<TScalarType>
       result[0] = result[0] < 90 ? result[0] + 90 : result[0] - 90;
       }
     result[1] = (1 / m_Scale[1]) * vcl_log(rho);
-    // otbMsgDebugMacro(<<log(vcl_pow(vector[0]-m_Center[0],2)+vcl_pow(vector[1]-m_Center[1],2)));
+    // otbMsgDebugMacro(<<log(vcl_pow(vector[0]-m_Center[0], 2)+vcl_pow(vector[1]-m_Center[1], 2)));
     }
   else
     {

Code/BasicFilters/otbLogPolarTransform.h

@@ -34,7 +34,7 @@ namespace otb
  * \f$ x-xc=exp(\rho)*cos(\theta) \f$
  * \f$ y-yc=exp(\rho)*sin(\theta) \f$
  *
- * Where (xc,yc) is the center of the log-polar transform in the cartesian space.
+ * Where (xc, yc) is the center of the log-polar transform in the cartesian space.
  * Please note that this center can NOT be represented in log-polar.
  *
  * \sa InverseLogPolarTransform

Code/BasicFilters/otbOverlapSaveConvolutionImageFilter.h

@@ -157,7 +157,7 @@ protected:
    * due to limited thread-safety of FFTW plan creation.
    */
   void GenerateData();
-  // void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,int threadId);
+  // void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId);
 
 private:
   OverlapSaveConvolutionImageFilter(const Self &); //purposely not implemented

Code/BasicFilters/otbOverlapSaveConvolutionImageFilter.txx

@@ -104,7 +104,7 @@ template<class TInputImage, class TOutputImage, class TBoundaryCondition>
 void
 OverlapSaveConvolutionImageFilter<TInputImage, TOutputImage, TBoundaryCondition>
 /* TODO commented out since multi-threading is not supported for the moment
- * ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,int threadId) */
+ * ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId) */
 ::GenerateData()
 {
 #if defined USE_FFTWD

Code/BasicFilters/otbPointSetExtractROI.txx

@@ -108,7 +108,7 @@ PointSetExtractROI<TInputPointSet, TOutputPointSet>
       outPoints->push_back(point);
       // Get & Add the data
       typename InputPointSetType::PixelType  data;
-      inputPointSet->GetPointData(inputPoint.Index(),&data);
+      inputPointSet->GetPointData(inputPoint.Index(), &data);
       outData->push_back(data/*inputData.Value()*/);
       }
     

Code/BasicFilters/otbPointSetFunction.txx

@@ -64,7 +64,7 @@ PointSetFunction<TPointSet,   TOutput>
 //  */
 // template <class TPointSet, class  TOutput >
 // const
-// typename PointSetFunction< TPointSet,TOutput>
+// typename PointSetFunction< TPointSet, TOutput>
 // ::PointSetType *
 // PointSetFunction< TPointSet,   TOutput>
 // ::GetPointSet() const

Code/BasicFilters/otbQuaternaryFunctorImageFilter.h

@@ -34,7 +34,7 @@ namespace otb
  * and the type of the output image.  It is also parameterized by the
  * operation to be applied, using a Functor style.
  *
- * \sa TernaryFunctorImageFilter,BinaryFunctorImageFilter UnaryFunctorImageFilter
+ * \sa TernaryFunctorImageFilter, BinaryFunctorImageFilter UnaryFunctorImageFilter
  *
  * \ingroup IntensityImageFilters Multithreaded
  */

Code/BasicFilters/otbRealAndImaginaryImageToComplexImageFilter.h

@@ -52,7 +52,7 @@ public:
   inline TOutput operator()( const TInputImageRealPart & real,
                              const TInputImageImaginaryPart & imaginary ) const
     {
-    return TOutput(static_cast<OutputValueType>(real),static_cast<OutputValueType>(imaginary));
+    return TOutput(static_cast<OutputValueType>(real), static_cast<OutputValueType>(imaginary));
     }
 };
 }
@@ -60,7 +60,7 @@ public:
 template <class TInputImageRealPart, class TInputImageImaginaryPart, class TOutputImage>
 class ITK_EXPORT RealAndImaginaryImageToComplexImageFilter :
     public itk::BinaryFunctorImageFilter<TInputImageRealPart,
-                        TInputImageImaginaryPart,TOutputImage,
+                        TInputImageImaginaryPart, TOutputImage,
                         Function::RealAndImaginaryToComplex<
                                   typename TInputImageRealPart::PixelType,
                                   typename TInputImageImaginaryPart::PixelType,
@@ -70,7 +70,7 @@ public:
   /** Standard class typedefs. */
   typedef RealAndImaginaryImageToComplexImageFilter  Self;
   typedef itk::BinaryFunctorImageFilter<
-      TInputImageRealPart, TInputImageImaginaryPart,TOutputImage,
+      TInputImageRealPart, TInputImageImaginaryPart, TOutputImage,
       Function::RealAndImaginaryToComplex< typename TInputImageRealPart::PixelType,
                               typename TInputImageImaginaryPart::PixelType,
                               typename TOutputImage::PixelType> >
@@ -95,7 +95,7 @@ public:
 //  itkConceptMacro(InputConvertibleToOutputCheck,
 //    (Concept::Convertible<InputRealPartPixelType, OutputPixelValueType>));
 //  itkConceptMacro(InputConvertibleToOutputCheck,
-//    (Concept::Convertible<InputImaginaryPartPixelType,OutputPixelValueType>));
+//    (Concept::Convertible<InputImaginaryPartPixelType, OutputPixelValueType>));
   /** End concept checking */
 //#endif
 

Code/BasicFilters/otbRealImageToComplexImageFilter.h

@@ -51,14 +51,14 @@ public:
     }
   inline TOutput operator()( const TInputImageRealPart & real) const
     {
-    return TOutput(static_cast<OutputValueType>(real),static_cast<OutputValueType>(0.0));
+    return TOutput(static_cast<OutputValueType>(real), static_cast<OutputValueType>(0.0));
     }
 };
 }
 
 template <class TInputImageRealPart, class TOutputImage>
 class ITK_EXPORT RealImageToComplexImageFilter :
-    public itk::UnaryFunctorImageFilter<TInputImageRealPart,TOutputImage,
+    public itk::UnaryFunctorImageFilter<TInputImageRealPart, TOutputImage,
                         Function::RealToComplex<
                                   typename TInputImageRealPart::PixelType,
                                   typename TOutputImage::PixelType>   >

Code/BasicFilters/otbSpatialObjectToImageDrawingFilter.h

@@ -104,7 +104,7 @@ public:
   itkGetMacro(OutsideValue, ValueType);
 
   /** The origin of the output image. The origin is the geometric
-   * coordinates of the index (0,0,...,0).  It is stored internally
+   * coordinates of the index (0, 0, ..., 0).  It is stored internally
    * as double but may be set from float.
    * \sa GetOrigin() */
   virtual void SetOrigin(const PointType& origin);

Code/BasicFilters/otbStreamingCompareImageFilter.txx

@@ -291,7 +291,7 @@ PersistentCompareImageFilter<TInputImage>
   itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());
 
   RealType  realValue1, realValue2;
-  PixelType value1,value2;
+  PixelType value1, value2;
   
   itk::ImageRegionConstIterator<TInputImage> it1(inputPtr1, outputRegionForThread);
   itk::ImageRegionConstIterator<TInputImage> it2(inputPtr2, outputRegionForThread);

Code/BasicFilters/otbStreamingResampleImageFilter.h

@@ -67,7 +67,7 @@ public:
   itkNewMacro(Self);
 
   /** Run-time type information (and related methods). */
-  itkTypeMacro(StreamingResampleImageFilter,itk::ImageToImageFilter);
+  itkTypeMacro(StreamingResampleImageFilter, itk::ImageToImageFilter);
 
   /** Typedef parameters*/
   typedef TInputImage                InputImageType;
@@ -110,7 +110,7 @@ public:
     m_DeformationFilter->SetTransform(transform);
     this->Modified();
   }
-  otbGetObjectMemberConstMacro(DeformationFilter,Transform,const TransformType*);
+  otbGetObjectMemberConstMacro(DeformationFilter, Transform, const TransformType*);
 
   /** The Deformation field spacing & size */
   void SetDeformationFieldSpacing(const SpacingType & spacing)
@@ -131,19 +131,19 @@ public:
     m_WarpFilter->SetOutputOrigin(origin);
     this->Modified();
   }
-  otbGetObjectMemberConstReferenceMacro(WarpFilter,OutputOrigin,OriginType);
+  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputOrigin, OriginType);
 
   // Output Start index
-  otbSetObjectMemberMacro(WarpFilter,OutputStartIndex,IndexType);
-  otbGetObjectMemberConstReferenceMacro(WarpFilter,OutputStartIndex,IndexType);
+  otbSetObjectMemberMacro(WarpFilter, OutputStartIndex, IndexType);
+  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputStartIndex, IndexType);
 
   // Output Size
-  otbSetObjectMemberMacro(WarpFilter,OutputSize,SizeType);
-  otbGetObjectMemberConstReferenceMacro(WarpFilter,OutputSize,SizeType);
+  otbSetObjectMemberMacro(WarpFilter, OutputSize, SizeType);
+  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSize, SizeType);
 
   // Output Spacing
-  otbSetObjectMemberMacro(WarpFilter,OutputSpacing,SpacingType);
-  otbGetObjectMemberConstReferenceMacro(WarpFilter,OutputSpacing,SpacingType);
+  otbSetObjectMemberMacro(WarpFilter, OutputSpacing, SpacingType);
+  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSpacing, SpacingType);
   
   /** Methods to Set/Get the interpolator */
   void SetInterpolator(InterpolatorType * interpolator)

Code/BasicFilters/otbStreamingResampleImageFilter.txx

@@ -49,7 +49,7 @@ StreamingResampleImageFilter<TInputImage, TOutputImage, TInterpolatorPrecisionTy
   // Set up progress reporting
   typename itk::ProgressAccumulator::Pointer progress = itk::ProgressAccumulator::New();
   progress->SetMiniPipelineFilter(this);
-  progress->RegisterInternalFilter(m_WarpFilter,1.f);
+  progress->RegisterInternalFilter(m_WarpFilter, 1.f);
 
   m_WarpFilter->GraftOutput(this->GetOutput());
   m_WarpFilter->Update();
@@ -103,7 +103,7 @@ StreamingResampleImageFilter<TInputImage, TOutputImage, TInterpolatorPrecisionTy
   // Set up deformation field filter
   SizeType deformationFieldLargestSize;
   
-  for(unsigned int dim = 0; dim < InputImageType::ImageDimension;++dim)
+  for(unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim)
     {
     // vcl_ceil to avoid numerical problems due to division of
     // spacings

Code/BasicFilters/otbVectorRescaleIntensityImageFilter.h

@@ -184,7 +184,7 @@ private:
 /** \class VectorRescaleIntensityImageFilter
  *  \brief This filter performs a rescaling of a vector image on a per band basis.
  *
- * This filter rescales each band to match the [OutputMinimum,OutputMaximum] range.
+ * This filter rescales each band to match the [OutputMinimum, OutputMaximum] range.
  * In order to avoid odd values to alter the intensity extent, one can set a clamp percentage.
  *
  * Values lower than the first quantile of this percentage are set to the OutputMinimum.

Code/BasicFilters/otbWindowedSincInterpolateImageFunctionBase.h

@@ -49,19 +49,19 @@ namespace otb
  *
  * \par
  * In this work, several 'windows' are estimated. In two dimensions, the
- * interpolation at a position (x,y) is given by the following
+ * interpolation at a position (x, y) is given by the following
  * expression:
  *
  * \par
  * \f[
- *   I(x,y) =
+ *   I(x, y) =
  *     \sum_{i = \lfloor x \rfloor + 1 - m}^{\lfloor x \rfloor + m}
  *     \sum_{j = \lfloor y \rfloor + 1 - m}^{\lfloor y \rfloor + m}
- *     I_{i,j} K(x-i) K(y-j),
+ *     I_{i, j} K(x-i) K(y-j),
  * \f]
  *
  * \par
- * where m is the 'radius' of the window, (3,4 are reasonable numbers),
+ * where m is the 'radius' of the window, (3, 4 are reasonable numbers),
  * and K(t) is the kernel function, composed of the sinc function and
  * one of several possible window functions:
  *
@@ -73,7 +73,7 @@ namespace otb
  * \par
  * Several window functions are provided here in the itk::Function
  * namespace. The conclusions of the referenced paper suggest to use the
- * Welch, Cosine, Kaiser, and Lanczos windows for m = 4,5. These are based
+ * Welch, Cosine, Kaiser, and Lanczos windows for m = 4, 5. These are based
  * on error in rotating medical images w.r.t. the linear interpolation
  * method. In some cases the results achieve a 20-fold improvement in
  * accuracy.
@@ -113,7 +113,7 @@ namespace otb
  * window by the kernel weights. The first is done more or less
  * efficiently in \f$ 2 m d \f$ operations (where d is the
  * dimensionality of the image). The second can be done
- * better. Presently, each pixel \f$ I(i,j,k) \f$ is multiplied by the
+ * better. Presently, each pixel \f$ I(i, j, k) \f$ is multiplied by the
  * weights \f$ K(x-i), K(y-j), K(z-k) \f$ and added to the running
  * total. This results in \f$ d (2m)^d \f$ multiplication
  * operations. However, by keeping intermediate sums, it would be

Code/ChangeDetection/otbBinaryFunctorNeighborhoodJoinHistogramImageFilter.h

@@ -116,7 +116,7 @@ public:
   itkSetMacro(Radius, RadiusSizeType);
 
   /** Typedefs for histogram. This should have been defined as
-      Histogram<RealType,2> but a bug in VC++7 produced an internal compiler
+      Histogram<RealType, 2> but a bug in VC++7 produced an internal compiler
       error with such declaration. */
   typedef typename itk::Statistics::Histogram<double, 2> HistogramType;
   typedef typename HistogramType::MeasurementVectorType  MeasurementVectorType;

Code/ChangeDetection/otbJoinHistogramMI.h

@@ -80,7 +80,7 @@ public:
         jointEntropy = -jointEntropy/static_cast<TOutput>(totalFreq) +
           vcl_log(totalFreq);
 
-        return entropyX + entropyY - jointEntropy;*/