STYLE: remove trailing whitespace/tab from Applications

Applications/CartographicDBValidation/otbDSFuzzyModelEstimation.cxx

@@ -125,7 +125,7 @@ private:
     SetDocLimitations("None.");
     SetDocAuthors("OTB-Team");
     SetDocSeeAlso(" ");
-  
+
     AddDocTag(Tags::FeatureExtraction);
 
     AddParameter(ParameterType_InputVectorData, "psin", "Input Positive Vector Data");

Applications/CartographicDBValidation/otbVectorDataDSValidation.cxx

@@ -68,7 +68,7 @@ private:
     SetDocLimitations("None.");
     SetDocAuthors("OTB-Team");
     SetDocSeeAlso("http://en.wikipedia.org/wiki/Dempster-Shafer_theory");
-   
+
     AddDocTag(Tags::FeatureExtraction);
 
 
@@ -102,7 +102,7 @@ private:
     SetDocExampleParameterValue("belsup", "cdbTvComputePolylineFeatureFromImage_LI_NOBUIL_gt.shp");
     SetDocExampleParameterValue("descmod", "DSFuzzyModel.xml");
     SetDocExampleParameterValue("out", "VectorDataDSValidation.shp");
-    
+
   }
 
   void DoUpdateParameters()

Applications/Classification/otbClassificationMapRegularization.cxx

@@ -43,7 +43,7 @@ public:
 
   /** Filters typedef */
   typedef UInt16ImageType IOLabelImageType;
-  
+
   // Neighborhood majority voting filter type
   typedef otb::NeighborhoodMajorityVotingImageFilter<IOLabelImageType> NeighborhoodMajorityVotingFilterType;
 
@@ -98,7 +98,7 @@ private:
     AddParameter(ParameterType_Int, "ip.undecidedlabel", "Label for the Undecided class");
     SetParameterDescription("ip.undecidedlabel", "Label for the Undecided class. By default, 'ip.undecidedlabel = 0'.");
     SetDefaultParameterInt("ip.undecidedlabel", 0.0);
-    
+
 
     AddRAMParameter();
 
@@ -115,29 +115,29 @@ private:
   {
     // Nothing to do here : all parameters are independent
   }
-  
+
   void DoExecute()
   {
     // Majority Voting
     m_NeighMajVotingFilter = NeighborhoodMajorityVotingFilterType::New();
-    
+
     // Load input labeled image to regularize
     UInt16ImageType::Pointer inImage = GetParameterUInt16Image("io.in");
-    
+
     // Neighborhood majority voting filter settings
     RadiusType rad;
     rad[0] = GetParameterInt("ip.radius");
     rad[1] = GetParameterInt("ip.radius");
-    
+
     StructuringType seBall;
     seBall.SetRadius(rad);
     seBall.CreateStructuringElement();
     m_NeighMajVotingFilter->SetKernel(seBall);
-    
+
     m_NeighMajVotingFilter->SetInput(inImage);
     m_NeighMajVotingFilter->SetLabelForNoDataPixels(GetParameterInt("ip.nodatalabel"));
     m_NeighMajVotingFilter->SetLabelForUndecidedPixels(GetParameterInt("ip.undecidedlabel"));
-    
+
     // Set to Undecided label if NOT unique Majority Voting
     if (IsParameterEnabled("ip.suvbool"))
       {
@@ -148,10 +148,10 @@ private:
       {
       m_NeighMajVotingFilter->SetKeepOriginalLabelBool(true);
       }
-    
+
     /** REGULARIZATION OF CLASSIFICATION */
     SetParameterOutputImage<IOLabelImageType>("io.out", m_NeighMajVotingFilter->GetOutput());
-  
+
   }// END DoExecute()
 
 

Applications/Classification/otbComputeConfusionMatrix.cxx

@@ -99,20 +99,20 @@ private:
 
   AddParameter(ParameterType_OutputFilename, "out", "Matrix output");
   SetParameterDescription("out", "Filename to store the output matrix (csv format)");
-  
+
   AddParameter(ParameterType_Choice,"ref","Ground truth");
   SetParameterDescription("ref","Choice of ground truth format");
-  
+
   AddChoice("ref.raster","Ground truth as a raster image");
-  
+
   AddChoice("ref.vector","Ground truth as a vector data file");
-  
+
   AddParameter(ParameterType_InputImage,"ref.raster.in","Input reference image");
   SetParameterDescription("ref.raster.in","Input image containing the ground truth labels");
-  
+
   AddParameter(ParameterType_InputFilename,"ref.vector.in","Input reference vector data");
   SetParameterDescription("ref.vector.in", "Input vector data of the ground truth");
-  
+
   AddParameter(ParameterType_String,"ref.vector.field","Field name");
   SetParameterDescription("ref.vector.field","Field name containing the label values");
   SetParameterString("ref.vector.field","Class");
@@ -125,7 +125,7 @@ private:
   SetDefaultParameterInt("nodatalabel",0);
   MandatoryOff("nodatalabel");
   DisableParameter("nodatalabel");
-  
+
   AddRAMParameter();
 
   // Doc example parameter settings

Applications/Classification/otbComputeImagesStatistics.cxx

@@ -51,7 +51,7 @@ private:
     SetDocLimitations("Each image of the set must contain the same bands as the others (i.e. same types, in the same order).");
     SetDocAuthors("OTB-Team");
     SetDocSeeAlso("Documentation of the TrainImagesClassifier application.");
- 
+
     AddDocTag(Tags::Learning);
     AddDocTag(Tags::Analysis);
 

Applications/Classification/otbSOMClassification.cxx

@@ -66,7 +66,7 @@ public:
   typedef otb::SOMImageClassificationFilter
           <FloatVectorImageType, LabeledImageType, SOMMapType> ClassificationFilterType;
 
-  
+
 private:
   void DoInit()
   {
@@ -85,65 +85,65 @@ private:
 
     AddParameter(ParameterType_InputImage,  "in",   "InputImage");
     SetParameterDescription("in", "Input image to classify.");
-    
+
     AddParameter(ParameterType_OutputImage,  "out",   "OutputImage");
     SetParameterDescription("out", "Output classified image (each pixel contains the index of its corresponding vector in the SOM).");
-    
+
     AddParameter(ParameterType_InputImage,  "vm",   "ValidityMask");
     SetParameterDescription("vm", "Validity mask (only pixels corresponding to a mask value greater than 0 will be used for learning)");
     MandatoryOff("vm");
-    
+
     AddParameter(ParameterType_Float, "tp", "TrainingProbability");
     SetParameterDescription("tp", "Probability for a sample to be selected in the training set");
     MandatoryOff("tp");
-    
+
     AddParameter(ParameterType_Int,  "ts",   "TrainingSetSize");
     SetParameterDescription("ts", "Maximum training set size (in pixels)");
     MandatoryOff("ts");
-    
+
     AddParameter(ParameterType_Int,  "sl",   "StreamingLines");
     SetParameterDescription("sl", "Number of lines in each streaming block (used during data sampling)");
     MandatoryOff("sl");
-    
+
     AddParameter(ParameterType_OutputImage, "som", "SOM Map");
     SetParameterDescription("som","Output image containing the Self-Organizing Map");
     MandatoryOff("som");
-    
+
     AddParameter(ParameterType_Int,  "sx",   "SizeX");
     SetParameterDescription("sx", "X size of the SOM map");
     MandatoryOff("sx");
-    
+
     AddParameter(ParameterType_Int,  "sy",   "SizeY");
     SetParameterDescription("sy", "Y size of the SOM map");
     MandatoryOff("sy");
-    
+
     AddParameter(ParameterType_Int,  "nx",   "NeighborhoodX");
     SetParameterDescription("nx", "X size of the initial neighborhood in the SOM map");
     MandatoryOff("nx");
-    
+
     AddParameter(ParameterType_Int,  "ny",   "NeighborhoodY");
     SetParameterDescription("ny", "Y size of the initial neighborhood in the SOM map");
     MandatoryOff("nx");
-    
+
     AddParameter(ParameterType_Int,  "ni",   "NumberIteration");
     SetParameterDescription("ni", "Number of iterations for SOM learning");
     MandatoryOff("ni");
-    
+
     AddParameter(ParameterType_Float,  "bi",   "BetaInit");
     SetParameterDescription("bi", "Initial learning coefficient");
     MandatoryOff("bi");
-    
+
     AddParameter(ParameterType_Float,  "bf",   "BetaFinal");
     SetParameterDescription("bf", "Final learning coefficient");
     MandatoryOff("bf");
-    
+
     AddParameter(ParameterType_Float,  "iv",   "InitialValue");
     SetParameterDescription("iv", "Maximum initial neuron weight");
     MandatoryOff("iv");
-    
+
     AddRAMParameter();
     // TODO : replace StreamingLines by RAM param ?
-    
+
     AddRANDParameter();
     // Default parameters
     SetDefaultParameterFloat("tp", 1.0);
@@ -155,7 +155,7 @@ private:
     SetDefaultParameterFloat("bi", 1.0);
     SetDefaultParameterFloat("bf", 0.1);
     SetDefaultParameterFloat("iv", 0.0);
-    
+
     // Doc example parameter settings
     SetDocExampleParameterValue("in", "QB_1_ortho.tif");
     SetDocExampleParameterValue("out","SOMClassification.tif");
@@ -171,18 +171,18 @@ private:
     SetDocExampleParameterValue("bf", "0.1");
     SetDocExampleParameterValue("iv", "0");
   }
-  
+
   void DoUpdateParameters()
   {
     // Nothing to do
   }
-  
+
   void DoExecute()
   {
     // initiating random number generation
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer
         randomGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::GetInstance();
-    
+
     FloatVectorImageType::Pointer input = GetParameterImage("in");
     LabeledImageType::Pointer mask;
     m_UseMask = false;
@@ -196,14 +196,14 @@ private:
         }
       m_UseMask = true;
     }
-    
+
     /*******************************************/
     /*           Sampling data                 */
     /*******************************************/
     otbAppLogINFO("-- SAMPLING DATA --");
-    
+
     RegionType largestRegion = input->GetLargestPossibleRegion();
-    
+
     // Setting up local streaming capabilities
     SplitterType::Pointer splitter = SplitterType::New();
     unsigned int numberOfStreamDivisions;
@@ -223,9 +223,9 @@ private:
                                           otb::SET_BUFFER_MEMORY_SIZE,
                                           0, 1048576*GetParameterInt("ram"), 0);
     }
-    
+
     otbAppLogINFO("The images will be streamed into "<<numberOfStreamDivisions<<" parts.");
-    
+
     // Training sample lists
     ListSampleType::Pointer sampleList = ListSampleType::New();
     sampleList->SetMeasurementVectorSize(input->GetNumberOfComponentsPerPixel());
@@ -240,45 +240,45 @@ private:
     {
       nbsamples = largestRegion.GetNumberOfPixels();
     }
-    
+
     // Sample dimension and max dimension
     unsigned int sampleSize = input->GetNumberOfComponentsPerPixel();
     unsigned int totalSamples = 0;
     otbAppLogINFO("The following sample size will be used: "<<sampleSize);
-    
+
     // local streaming variables
     unsigned int piece = 0;
     RegionType streamingRegion;
-    
+
     // create a random permutation to explore
     itk::RandomPermutation randPerm(numberOfStreamDivisions);
     unsigned int index = 0;
-    
+
     // TODO : maybe change the approach: at the moment, the sampling process is able to pick a sample twice or more
     while (totalSamples < nbsamples)
     {
       unsigned int localNbSamples=0;
-    
+
       piece = randPerm[index];
       streamingRegion = splitter->GetSplit(piece, numberOfStreamDivisions, largestRegion);
       //otbAppLogINFO("Processing region: "<<streamingRegion);
-      
+
       input->SetRequestedRegion(streamingRegion);
       input->PropagateRequestedRegion();
       input->UpdateOutputData();
-      
+
       IteratorType it(input, streamingRegion);
       it.GoToBegin();
-      
+
       if (m_UseMask)
       {
         mask->SetRequestedRegion(streamingRegion);
         mask->PropagateRequestedRegion();
         mask->UpdateOutputData();
-        
+
         LabeledIteratorType maskIt(mask, streamingRegion);
         maskIt.GoToBegin();
-        
+
         // Loop on the image and the mask
         while ( !it.IsAtEnd()
             && !maskIt.IsAtEnd()
@@ -338,17 +338,17 @@ private:
         if (index == numberOfStreamDivisions) index = 0;
       }
     }
-    
+
     otbAppLogINFO("The final training set contains "<<totalSamples<<" samples.");
- 
+
 
       /*******************************************/
       /*           Learning                      */
       /*******************************************/
       otbAppLogINFO("-- LEARNING --");
-      
+
       EstimatorType::Pointer estimator = EstimatorType::New();
-      
+
       estimator->SetListSample(sampleList);
       EstimatorType::SizeType size;
       size[0]=GetParameterInt("sx");
@@ -362,29 +362,29 @@ private:
       estimator->SetBetaInit(GetParameterFloat("bi"));
       estimator->SetBetaEnd(GetParameterFloat("bf"));
       estimator->SetMaxWeight(GetParameterFloat("iv"));
-      
+
     AddProcess(estimator,"Learning");
     estimator->Update();
-  
+
     m_SOMMap = estimator->GetOutput();
     if (HasValue("som"))
       {
       otbAppLogINFO("-- Using Leaning image --");
       SetParameterOutputImage<DoubleVectorImageType>("som", m_SOMMap);
       }
-    
+
     /*******************************************/
     /*           Classification                */
     /*******************************************/
     otbAppLogINFO("-- CLASSIFICATION --");
-    
+
     m_Classifier = ClassificationFilterType::New();
     m_Classifier->SetInput(input);
     m_Classifier->SetMap(m_SOMMap);
     if (m_UseMask) m_Classifier->SetInputMask(mask);
-    
+
     AddProcess(m_Classifier,"Classification");
-    
+
     SetParameterOutputImage<LabeledImageType>("out", m_Classifier->GetOutput());
   }
 

Applications/DisparityMap/otbBlockMatching.cxx

@@ -234,18 +234,18 @@ private:
 
     AddChoice("bm.subpixel.dichotomy", "Dichotomy");
     SetParameterDescription("bm.subpixel.dichotomy", "Dichotomic search");
-    
+
     AddParameter(ParameterType_Int,"bm.step", "Computation step");
     SetParameterDescription("bm.step", "Location step between computed disparities");
     SetDefaultParameterInt("bm.step",1);
     SetMinimumParameterIntValue("bm.step",1);
     MandatoryOff("bm.step");
-    
+
     AddParameter(ParameterType_Int,"bm.startx","X start index");
     SetParameterDescription("bm.startx","X start index of the subsampled grid (wrt the input image grid)");
     SetDefaultParameterInt("bm.startx",0);
     MandatoryOff("bm.startx");
-    
+
     AddParameter(ParameterType_Int,"bm.starty","Y start index");
     SetParameterDescription("bm.starty","Y start index of the subsampled grid (wrt the input image grid)");
     SetDefaultParameterInt("bm.starty",0);
@@ -367,7 +367,7 @@ private:
     int          minvdisp = GetParameterInt("bm.minvd");
     int          maxvdisp = GetParameterInt("bm.maxvd");
     unsigned int step     = GetParameterInt("bm.step");
-    
+
     FloatImageType::IndexType gridIndex;
     gridIndex[0] = GetParameterInt("bm.startx");
     gridIndex[1] = GetParameterInt("bm.starty");

Applications/DisparityMap/otbFineRegistration.cxx

@@ -126,95 +126,95 @@ private:
 
     AddParameter(ParameterType_InputImage,  "ref",   "Reference Image");
     SetParameterDescription( "ref", "The reference image." );
-    
+
     AddParameter(ParameterType_InputImage,  "sec",   "Secondary Image");
     SetParameterDescription( "sec", "The secondary image." );
-    
+
     AddParameter(ParameterType_OutputImage,  "out",   "Output Image");
     SetParameterDescription( "out", "The output image." );
-    
+
     AddParameter(ParameterType_Int,  "erx",   "Exploration Radius X");
     SetParameterDescription( "erx", "The exploration radius along x (in pixels)" );
     SetMinimumParameterIntValue("erx", 0);
-    
+
     AddParameter(ParameterType_Int,  "ery",   "Exploration Radius Y");
     SetParameterDescription( "ery", "The exploration radius along y (in pixels)" );
     SetMinimumParameterIntValue("ery", 0);
-    
+
     AddParameter(ParameterType_Int,  "mrx",   "Metric Radius X");
     SetParameterDescription( "mrx", "Radius along x (in pixels) of the metric computation window" );
     SetMinimumParameterIntValue("mrx", 0);
-    
+
     AddParameter(ParameterType_Int,  "mry",   "Metric Radius Y");
     SetParameterDescription( "mry", "Radius along y (in pixels) of the metric computation window" );
     SetMinimumParameterIntValue("mry", 0);
-    
+
     AddParameter(ParameterType_InputImage,  "w",   "Image To Warp");
     SetParameterDescription( "w", "The image to warp after disparity estimation is completed" );
     MandatoryOff("w");
-    
+
     AddParameter(ParameterType_OutputImage,  "wo",   "Output Warped Image");
     SetParameterDescription( "wo", "The output warped image" );
     MandatoryOff("wo");
-    
+
     AddParameter(ParameterType_Float,  "cox",   "Coarse Offset X");
     SetParameterDescription( "cox", "Coarse offset along x (in physical space) between the two images" );
     SetDefaultParameterFloat("cox", 0.0);
     MandatoryOff("cox");
-    
+
     AddParameter(ParameterType_Float,  "coy",   "Coarse Offset Y");
     SetParameterDescription( "coy", "Coarse offset along y (in physical space) between the two images" );
     SetDefaultParameterFloat("coy", 0.0);
     MandatoryOff("coy");
-    
+
     AddParameter(ParameterType_Float,  "ssrx",   "Sub-Sampling Rate X");
     SetParameterDescription( "ssrx", "Generates a result at a coarser resolution with a given sub-sampling rate along X" );
     SetDefaultParameterFloat("ssrx", 1.0);
     SetMinimumParameterFloatValue("ssrx", 1.0);
     MandatoryOff("ssrx");
-    
+
     AddParameter(ParameterType_Float,  "ssry",   "Sub-Sampling Rate Y");
     SetParameterDescription( "ssry", "Generates a result at a coarser resolution with a given sub-sampling rate along Y" );
     SetDefaultParameterFloat("ssry", 1.0);
     SetMinimumParameterFloatValue("ssry", 1.0);
     MandatoryOff("ssry");
-    
+
     AddParameter(ParameterType_Float,  "rgsx",   "Reference Gaussian Smoothing X");
     SetParameterDescription( "rgsx", "Performs a gaussian smoothing of the reference image. Parameter is gaussian sigma (in pixels) in X direction." );
     MandatoryOff("rgsx");
-    
+
     AddParameter(ParameterType_Float,  "rgsy",   "Reference Gaussian Smoothing Y");
     SetParameterDescription( "rgsy", "Performs a gaussian smoothing of the reference image. Parameter is gaussian sigma (in pixels) in Y direction." );
     MandatoryOff("rgsy");
-    
+
     AddParameter(ParameterType_Float,  "sgsx",   "Secondary Gaussian Smoothing X");
     SetParameterDescription( "sgsx", "Performs a gaussian smoothing of the secondary image. Parameter is gaussian sigma (in pixels) in X direction." );
     MandatoryOff("sgsx");
-    
+
     AddParameter(ParameterType_Float,  "sgsy",   "Secondary Gaussian Smoothing Y");
     SetParameterDescription( "sgsy", "Performs a gaussian smoothing of the secondary image. Parameter is gaussian sigma (in pixels) in Y direction." );
     MandatoryOff("sgsy");
-    
+
     AddParameter(ParameterType_String,  "m",   "Metric");
     SetParameterDescription( "m", "Choose the metric used for block matching. Available metrics are cross-correlation (CC), cross-correlation with subtracted mean (CCSM), mean-square difference (MSD), mean reciprocal square difference (MRSD) and mutual information (MI). Default is cross-correlation" );
     MandatoryOff("m");
-    
+
     AddParameter(ParameterType_Float,  "spa",   "SubPixelAccuracy");
     SetParameterDescription( "spa", "Metric extrema location will be refined up to the given accuracy. Default is 0.01" );
     SetDefaultParameterFloat("spa", 0.01);
     SetMinimumParameterFloatValue("spa", 0.0);
     MandatoryOff("spa");
-    
+
     AddParameter(ParameterType_Float,  "vmlt",   "Validity Mask Lower Threshold");
     SetParameterDescription( "vmlt", "Lower threshold to obtain a validity mask." );
     MandatoryOff("vmlt");
-    
+
     AddParameter(ParameterType_Float,  "vmut",   "Validity Mask Upper Threshold");
     SetParameterDescription( "vmut", "Upper threshold to obtain a validity mask." );
     MandatoryOff("vmut");
-    
+
     AddRAMParameter();
- 
+
     // Doc example parameter settings
     SetDocExampleParameterValue("ref", "StereoFixed.png");
     SetDocExampleParameterValue("sec", "StereoMoving.png");
@@ -234,13 +234,13 @@ private:
   {
     FloatVectorImageType::Pointer refImage = GetParameterImage("ref"); // fixed
     FloatVectorImageType::Pointer secImage = GetParameterImage("sec"); // moved
-    
+
     m_IntensityRef = IntensityFilterType::New();
     m_IntensitySec = IntensityFilterType::New();
-    
+
     m_IntensityRef->SetInput(refImage);
     m_IntensitySec->SetInput(secImage);
-    
+
     // Retrieve main registration parameters
     RegistrationFilterType::SizeType radius, sradius;
     RegistrationFilterType::OffsetType ssrate;
@@ -248,16 +248,16 @@ private:
     sradius[1] = GetParameterInt("ery");
     radius[0] = GetParameterInt("mrx");
     radius[1] = GetParameterInt("mry");
-  
+
     double accuracy = static_cast<double>(GetParameterFloat("spa"));
-    
+
     ssrate[0] = GetParameterFloat("ssrx");
     ssrate[1] = GetParameterFloat("ssry");
-    
+
     RegistrationFilterType::SpacingType initialOffset;
     initialOffset[0] = GetParameterFloat("cox");
     initialOffset[1] = GetParameterFloat("coy");
-  
+
     // Display info
     otbAppLogINFO("Reference image   : "<<GetParameterString("ref"));
     otbAppLogINFO("Secondary image   : "<<GetParameterString("sec"));
@@ -266,14 +266,14 @@ private:
     otbAppLogINFO("Sub-sampling rate : "<<ssrate<<" (pixels)");
     otbAppLogINFO("Coarse offset     : "<<initialOffset<<" (physical unit)");
     otbAppLogINFO("Accuracy          : "<<accuracy<<" (physical unit)");
-    
+
     m_Registration = RegistrationFilterType::New();
     m_Registration->SetRadius(radius);
     m_Registration->SetSearchRadius(sradius);
     m_Registration->SetSubPixelAccuracy(accuracy);
     m_Registration->SetGridStep(ssrate);
     m_Registration->SetInitialOffset(initialOffset);
-  
+
     if(HasValue("rgsx") && HasValue("rgsy"))
       {
       m_RefGaussianFilter = GaussianFilterType::New();
@@ -292,7 +292,7 @@ private:
       otbAppLogINFO("Reference image gaussian smoothing : OFF");
       m_Registration->SetFixedInput(m_IntensityRef->GetOutput());
       }
-  
+
     if(HasValue("sgsx") && HasValue("sgsy"))