OTB  9.0.0
Orfeo Toolbox
otbScalarImageToAdvancedTexturesFilter.hxx
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
3  *
4  * This file is part of Orfeo Toolbox
5  *
6  * https://www.orfeo-toolbox.org/
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 
21 #ifndef otbScalarImageToAdvancedTexturesFilter_hxx
22 #define otbScalarImageToAdvancedTexturesFilter_hxx
23 
24 #include "otbScalarImageToAdvancedTexturesFilter.h"
25 #include "itkImageRegionIteratorWithIndex.h"
26 #include "itkConstNeighborhoodIterator.h"
27 #include "itkImageRegionIterator.h"
28 #include "itkProgressReporter.h"
29 #include "itkNumericTraits.h"
30 #include <algorithm>
31 
32 namespace otb
33 {
34 template <class TInputImage, class TOutputImage>
35 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::ScalarImageToAdvancedTexturesFilter()
36  : m_Radius(),
37  m_Offset(),
38  m_NeighborhoodRadius(),
39  m_NumberOfBinsPerAxis(8),
40  m_InputImageMinimum(0),
41  m_InputImageMaximum(255),
42  m_SubsampleFactor(),
43  m_SubsampleOffset()
44 {
45  // There are 10 outputs corresponding to the 9 textures indices
46  this->SetNumberOfRequiredOutputs(10);
47 
48  // Create the 10 outputs
49  this->SetNthOutput(0, OutputImageType::New());
50  this->SetNthOutput(1, OutputImageType::New());
51  this->SetNthOutput(2, OutputImageType::New());
52  this->SetNthOutput(3, OutputImageType::New());
53  this->SetNthOutput(4, OutputImageType::New());
54  this->SetNthOutput(5, OutputImageType::New());
55  this->SetNthOutput(6, OutputImageType::New());
56  this->SetNthOutput(7, OutputImageType::New());
57  this->SetNthOutput(8, OutputImageType::New());
58  this->SetNthOutput(9, OutputImageType::New());
59 
60  this->m_SubsampleFactor.Fill(1);
61  this->m_SubsampleOffset.Fill(0);
62 }
63 
64 template <class TInputImage, class TOutputImage>
65 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::~ScalarImageToAdvancedTexturesFilter()
66 {
67 }
68 template <class TInputImage, class TOutputImage>
69 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
70 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetMeanOutput()
71 {
72  if (this->GetNumberOfOutputs() < 1)
73  {
74  return nullptr;
75  }
76  return static_cast<OutputImageType*>(this->GetOutput(0));
77 }
78 
79 template <class TInputImage, class TOutputImage>
80 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
81 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetVarianceOutput()
82 {
83  if (this->GetNumberOfOutputs() < 2)
84  {
85  return nullptr;
86  }
87  return static_cast<OutputImageType*>(this->GetOutput(1));
88 }
89 
90 template <class TInputImage, class TOutputImage>
91 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
92 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetDissimilarityOutput()
93 {
94  if (this->GetNumberOfOutputs() < 3)
95  {
96  return nullptr;
97  }
98  return static_cast<OutputImageType*>(this->GetOutput(2));
99 }
100 
101 template <class TInputImage, class TOutputImage>
102 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
103 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetSumAverageOutput()
104 {
105  if (this->GetNumberOfOutputs() < 4)
106  {
107  return nullptr;
108  }
109  return static_cast<OutputImageType*>(this->GetOutput(3));
110 }
111 
112 template <class TInputImage, class TOutputImage>
113 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
114 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetSumVarianceOutput()
115 {
116  if (this->GetNumberOfOutputs() < 5)
117  {
118  return nullptr;
119  }
120  return static_cast<OutputImageType*>(this->GetOutput(4));
121 }
122 
123 template <class TInputImage, class TOutputImage>
124 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
125 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetSumEntropyOutput()
126 {
127  if (this->GetNumberOfOutputs() < 6)
128  {
129  return nullptr;
130  }
131  return static_cast<OutputImageType*>(this->GetOutput(5));
132 }
133 
134 template <class TInputImage, class TOutputImage>
135 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
136 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetDifferenceEntropyOutput()
137 {
138  if (this->GetNumberOfOutputs() < 7)
139  {
140  return nullptr;
141  }
142  return static_cast<OutputImageType*>(this->GetOutput(6));
143 }
144 
145 template <class TInputImage, class TOutputImage>
146 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
147 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetDifferenceVarianceOutput()
148 {
149  if (this->GetNumberOfOutputs() < 8)
150  {
151  return nullptr;
152  }
153  return static_cast<OutputImageType*>(this->GetOutput(7));
154 }
155 
156 template <class TInputImage, class TOutputImage>
157 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
158 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetIC1Output()
159 {
160  if (this->GetNumberOfOutputs() < 9)
161  {
162  return nullptr;
163  }
164  return static_cast<OutputImageType*>(this->GetOutput(8));
165 }
166 
167 template <class TInputImage, class TOutputImage>
168 typename ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::OutputImageType*
169 ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GetIC2Output()
170 {
171  if (this->GetNumberOfOutputs() < 10)
172  {
173  return nullptr;
174  }
175  return static_cast<OutputImageType*>(this->GetOutput(9));
176 }
177 
178 template <class TInputImage, class TOutputImage>
179 void ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GenerateOutputInformation()
180 {
181  // First, call superclass implementation
182  Superclass::GenerateOutputInformation();
183 
184  // Compute output size, origin & spacing
185  InputRegionType inputRegion = this->GetInput()->GetLargestPossibleRegion();
186  OutputRegionType outputRegion;
187  outputRegion.SetIndex(0, 0);
188  outputRegion.SetIndex(1, 0);
189  outputRegion.SetSize(0, 1 + (inputRegion.GetSize(0) - 1 - m_SubsampleOffset[0]) / m_SubsampleFactor[0]);
190  outputRegion.SetSize(1, 1 + (inputRegion.GetSize(1) - 1 - m_SubsampleOffset[1]) / m_SubsampleFactor[1]);
191 
192  typename OutputImageType::SpacingType outSpacing = this->GetInput()->GetSignedSpacing();
193  outSpacing[0] *= m_SubsampleFactor[0];
194  outSpacing[1] *= m_SubsampleFactor[1];
195 
196  typename OutputImageType::PointType outOrigin;
197  this->GetInput()->TransformIndexToPhysicalPoint(inputRegion.GetIndex() + m_SubsampleOffset, outOrigin);
198 
199  for (unsigned int i = 0; i < this->GetNumberOfOutputs(); i++)
200  {
201  OutputImagePointerType outputPtr = this->GetOutput(i);
202  outputPtr->SetLargestPossibleRegion(outputRegion);
203  outputPtr->SetOrigin(outOrigin);
204  outputPtr->SetSignedSpacing(outSpacing);
205  }
206 }
207 
208 template <class TInputImage, class TOutputImage>
209 void ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::GenerateInputRequestedRegion()
210 {
211  // First, call superclass implementation
212  Superclass::GenerateInputRequestedRegion();
213 
214  // Retrieve the input and output pointers
215  InputImagePointerType inputPtr = const_cast<InputImageType*>(this->GetInput());
216  OutputImagePointerType outputPtr = this->GetOutput();
217 
218  if (!inputPtr || !outputPtr)
219  {
220  return;
221  }
222 
223  // Retrieve the output requested region
224  // We use only the first output since requested regions for all outputs are enforced to be equal
225  // by the default GenerateOutputRequestedRegiont() implementation
226  OutputRegionType outputRequestedRegion = outputPtr->GetRequestedRegion();
227  InputRegionType inputLargest = inputPtr->GetLargestPossibleRegion();
228 
229  typename OutputRegionType::IndexType outputIndex = outputRequestedRegion.GetIndex();
230  typename OutputRegionType::SizeType outputSize = outputRequestedRegion.GetSize();
231  typename InputRegionType::IndexType inputIndex;
232  typename InputRegionType::SizeType inputSize;
233 
234  // Convert index and size to full grid
235  outputIndex[0] = outputIndex[0] * m_SubsampleFactor[0] + m_SubsampleOffset[0] + inputLargest.GetIndex(0);
236  outputIndex[1] = outputIndex[1] * m_SubsampleFactor[1] + m_SubsampleOffset[1] + inputLargest.GetIndex(1);
237  outputSize[0] = 1 + (outputSize[0] - 1) * m_SubsampleFactor[0];
238  outputSize[1] = 1 + (outputSize[1] - 1) * m_SubsampleFactor[1];
239 
240  // First, apply offset
241  for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim)
242  {
243  inputIndex[dim] = std::min(outputIndex[dim], outputIndex[dim] + m_Offset[dim]);
244  inputSize[dim] = std::max(outputIndex[dim] + outputSize[dim], outputIndex[dim] + outputSize[dim] + m_Offset[dim]) - inputIndex[dim];
245  }
246 
247  // Build the input requested region
248  InputRegionType inputRequestedRegion;
249  inputRequestedRegion.SetIndex(inputIndex);
250  inputRequestedRegion.SetSize(inputSize);
251 
252  // Apply the radius
253  inputRequestedRegion.PadByRadius(m_Radius);
254 
255  // Try to apply the requested region to the input image
256  if (inputRequestedRegion.Crop(inputPtr->GetLargestPossibleRegion()))
257  {
258  inputPtr->SetRequestedRegion(inputRequestedRegion);
259  }
260  else
261  {
262  // Build an exception
263  itk::InvalidRequestedRegionError e(__FILE__, __LINE__);
264  e.SetLocation(ITK_LOCATION);
265  e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
266  e.SetDataObject(inputPtr);
267  throw e;
268  }
269 }
270 
271 template <class TInputImage, class TOutputImage>
272 void ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::BeforeThreadedGenerateData()
273 {
274  unsigned int minRadius = 0;
275  for (unsigned int i = 0; i < m_Offset.GetOffsetDimension(); i++)
276  {
277  unsigned int distance = std::abs(m_Offset[i]);
278  if (distance > minRadius)
279  {
280  minRadius = distance;
281  }
282  }
283  m_NeighborhoodRadius.Fill(minRadius);
284 }
285 
286 template <class TInputImage, class TOutputImage>
287 void ScalarImageToAdvancedTexturesFilter<TInputImage, TOutputImage>::ThreadedGenerateData(const OutputRegionType& outputRegionForThread,
288  itk::ThreadIdType threadId)
289 {
290  // Retrieve the input and output pointers
291  InputImagePointerType inputPtr = const_cast<InputImageType*>(this->GetInput());
292  OutputImagePointerType meanPtr = this->GetMeanOutput();
293  OutputImagePointerType variancePtr = this->GetVarianceOutput();
294  OutputImagePointerType dissimilarityPtr = this->GetDissimilarityOutput();
295  OutputImagePointerType sumAveragePtr = this->GetSumAverageOutput();
296  OutputImagePointerType sumVariancePtr = this->GetSumVarianceOutput();
297  OutputImagePointerType sumEntropytPtr = this->GetSumEntropyOutput();
298  OutputImagePointerType differenceEntropyPtr = this->GetDifferenceEntropyOutput();
299  OutputImagePointerType differenceVariancePtr = this->GetDifferenceVarianceOutput();
300  OutputImagePointerType ic1Ptr = this->GetIC1Output();
301  OutputImagePointerType ic2Ptr = this->GetIC2Output();
302 
303  // Build output iterators
304  itk::ImageRegionIteratorWithIndex<OutputImageType> varianceIt(variancePtr, outputRegionForThread);
305  itk::ImageRegionIterator<OutputImageType> meanIt(meanPtr, outputRegionForThread);
306  itk::ImageRegionIterator<OutputImageType> dissimilarityIt(dissimilarityPtr, outputRegionForThread);
307  itk::ImageRegionIterator<OutputImageType> sumAverageIt(sumAveragePtr, outputRegionForThread);
308  itk::ImageRegionIterator<OutputImageType> sumVarianceIt(sumVariancePtr, outputRegionForThread);
309  itk::ImageRegionIterator<OutputImageType> sumEntropytIt(sumEntropytPtr, outputRegionForThread);
310  itk::ImageRegionIterator<OutputImageType> differenceEntropyIt(differenceEntropyPtr, outputRegionForThread);
311  itk::ImageRegionIterator<OutputImageType> differenceVarianceIt(differenceVariancePtr, outputRegionForThread);
312  itk::ImageRegionIterator<OutputImageType> ic1It(ic1Ptr, outputRegionForThread);
313  itk::ImageRegionIterator<OutputImageType> ic2It(ic2Ptr, outputRegionForThread);
314 
315  // Go to begin
316  varianceIt.GoToBegin();
317  meanIt.GoToBegin();
318  dissimilarityIt.GoToBegin();
319  sumAverageIt.GoToBegin();
320  sumVarianceIt.GoToBegin();
321  sumEntropytIt.GoToBegin();
322  differenceEntropyIt.GoToBegin();
323  differenceVarianceIt.GoToBegin();
324  ic1It.GoToBegin();
325  ic2It.GoToBegin();
326 
327  const double log2 = std::log(2.0);
328  const unsigned int histSize = m_NumberOfBinsPerAxis;
329  const long unsigned int twiceHistSize = 2 * m_NumberOfBinsPerAxis;
330 
331  InputRegionType inputLargest = inputPtr->GetLargestPossibleRegion();
332 
333  // Set-up progress reporting
334  itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());
335 
336  // Iterate on outputs to compute textures
337  while (!varianceIt.IsAtEnd() && !meanIt.IsAtEnd() && !dissimilarityIt.IsAtEnd() && !sumAverageIt.IsAtEnd() && !sumVarianceIt.IsAtEnd() &&
338  !sumEntropytIt.IsAtEnd() && !differenceEntropyIt.IsAtEnd() && !differenceVarianceIt.IsAtEnd() && !ic1It.IsAtEnd() && !ic2It.IsAtEnd())
339  {
340  // Compute the region on which co-occurence will be estimated
341  typename InputRegionType::IndexType inputIndex;
342  typename InputRegionType::SizeType inputSize;
343 
344  // Convert index to full grid
345  typename OutputImageType::IndexType outIndex;
346 
347  // First, create an window for neighborhood iterator based on m_Radius
348  // For example, if xradius and yradius is 2. window size is 5x5 (2 * radius + 1).
349  for (unsigned int dim = 0; dim < InputImageType::ImageDimension; ++dim)
350  {
351  outIndex[dim] = varianceIt.GetIndex()[dim] * m_SubsampleFactor[dim] + m_SubsampleOffset[dim] + inputLargest.GetIndex(dim);
352  inputIndex[dim] = outIndex[dim] - m_Radius[dim];
353  inputSize[dim] = 2 * m_Radius[dim] + 1;
354  }
355 
356  // Build the input region
357  InputRegionType inputRegion;
358  inputRegion.SetIndex(inputIndex);
359  inputRegion.SetSize(inputSize);
360  inputRegion.Crop(inputPtr->GetRequestedRegion());
361 
362  CooccurrenceIndexedListPointerType GLCIList = CooccurrenceIndexedListType::New();
363  GLCIList->Initialize(m_NumberOfBinsPerAxis, m_InputImageMinimum, m_InputImageMaximum);
364 
365  typedef itk::ConstNeighborhoodIterator<InputImageType> NeighborhoodIteratorType;
366  NeighborhoodIteratorType neighborIt;
367  neighborIt = NeighborhoodIteratorType(m_NeighborhoodRadius, inputPtr, inputRegion);
368  for (neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt)
369  {
370  const InputPixelType centerPixelIntensity = neighborIt.GetCenterPixel();
371  bool pixelInBounds;
372  const InputPixelType pixelIntensity = neighborIt.GetPixel(m_Offset, pixelInBounds);
373  if (!pixelInBounds)
374  {
375  continue; // don't put a pixel in the co-occurrence list if the value is
376  // out of bounds
377  }
378  GLCIList->AddPixelPair(centerPixelIntensity, pixelIntensity);
379  }
380 
381  PixelValueType m_Mean = itk::NumericTraits<PixelValueType>::Zero;
382  PixelValueType m_Variance = itk::NumericTraits<PixelValueType>::Zero;
383  PixelValueType m_Dissimilarity = itk::NumericTraits<PixelValueType>::Zero;
384  PixelValueType m_SumAverage = itk::NumericTraits<PixelValueType>::Zero;
385  PixelValueType m_SumEntropy = itk::NumericTraits<PixelValueType>::Zero;
386  PixelValueType m_SumVariance = itk::NumericTraits<PixelValueType>::Zero;
387  PixelValueType m_DifferenceEntropy = itk::NumericTraits<PixelValueType>::Zero;
388  PixelValueType m_DifferenceVariance = itk::NumericTraits<PixelValueType>::Zero;
389  PixelValueType m_IC1 = itk::NumericTraits<PixelValueType>::Zero;
390  PixelValueType m_IC2 = itk::NumericTraits<PixelValueType>::Zero;
391 
392  double Entropy = 0;
393 
394  typedef itk::Array<double> DoubleArrayType;
395  DoubleArrayType hx(histSize);
396  DoubleArrayType hy(histSize);
397  DoubleArrayType pdxy(twiceHistSize);
398 
399  for (long unsigned int i = 0; i < histSize; i++)
400  {
401  hx[i] = 0.0;
402  hy[i] = 0.0;
403  pdxy[i] = 0.0;
404  }
405  for (long unsigned int i = histSize; i < twiceHistSize; i++)
406  {
407  pdxy[i] = 0.0;
408  }
409 
410  /* hx.Fill(0.0); hy.Fill(0.0); pdxy.Fill(0.0); */
411  double hxy1 = 0;
412 
413  // get co-occurrence vector and totalfrequency
414  VectorType glcVector = GLCIList->GetVector();
415  double totalFrequency = static_cast<double>(GLCIList->GetTotalFrequency());
416 
417  VectorConstIteratorType constVectorIt;
418  // Normalize the GreyLevelCooccurrenceListType
419  // Compute Mean, Entropy (f12), hx, hy, pdxy
420  constVectorIt = glcVector.begin();
421  while (constVectorIt != glcVector.end())
422  {
423  CooccurrenceIndexType index = (*constVectorIt).first;
424  double frequency = (*constVectorIt).second / totalFrequency;
425  m_Mean += static_cast<double>(index[0]) * frequency;
426  Entropy -= (frequency > 0.0001) ? frequency * std::log(frequency) / log2 : 0.;
427  unsigned int i = index[1];
428  unsigned int j = index[0];
429  hx[j] += frequency;
430  hy[i] += frequency;
431 
432  if (i + j > histSize - 1)
433  {
434  pdxy[i + j] += frequency;
435  }
436  if (i <= j)
437  {
438  pdxy[j - i] += frequency;
439  }
440  ++constVectorIt;
441  }
442 
443  // second pass over normalized co-occurrence list to find variance and pipj.
444  // pipj is needed to calculate f11
445  constVectorIt = glcVector.begin();
446  while (constVectorIt != glcVector.end())
447  {
448  double frequency = (*constVectorIt).second / totalFrequency;
449  CooccurrenceIndexType index = (*constVectorIt).first;
450  unsigned int i = index[1];
451  unsigned int j = index[0];
452  double index0 = static_cast<double>(index[0]);
453  m_Variance += ((index0 - m_Mean) * (index0 - m_Mean)) * frequency;
454  double pipj = hx[j] * hy[i];
455  hxy1 -= (pipj > 0.0001) ? frequency * std::log(pipj) : 0.;
456  ++constVectorIt;
457  }
458 
459  // iterate histSize to compute sumEntropy
460  double PSSquareCumul = 0;
461  for (long unsigned int k = histSize; k < twiceHistSize; k++)
462  {
463  m_SumAverage += k * pdxy[k];
464  m_SumEntropy -= (pdxy[k] > 0.0001) ? pdxy[k] * std::log(pdxy[k]) / log2 : 0;
465  PSSquareCumul += k * k * pdxy[k];
466  }
467  m_SumVariance = PSSquareCumul - m_SumAverage * m_SumAverage;
468 
469  double PDSquareCumul = 0;
470  double PDCumul = 0;
471  double hxCumul = 0;
472  double hyCumul = 0;
473 
474  for (long unsigned int i = 0; i < histSize; ++i)
475  {
476  double pdTmp = pdxy[i];
477  PDCumul += i * pdTmp;
478  m_DifferenceEntropy -= (pdTmp > 0.0001) ? pdTmp * std::log(pdTmp) / log2 : 0;
479  PDSquareCumul += i * i * pdTmp;
480 
481  // comput hxCumul and hyCumul
482  double marginalfreq = hx[i];
483  hxCumul += (marginalfreq > 0.0001) ? std::log(marginalfreq) * marginalfreq : 0;
484 
485  marginalfreq = hy[i];
486  hyCumul += (marginalfreq > 0.0001) ? std::log(marginalfreq) * marginalfreq : 0;
487  }
488  m_DifferenceVariance = PDSquareCumul - PDCumul * PDCumul;
489 
490  /* pipj computed below is totally different from earlier one which was used
491  * to compute hxy1. */
492  double hxy2 = 0;
493  for (unsigned int i = 0; i < histSize; ++i)
494  {
495  for (unsigned int j = 0; j < histSize; ++j)
496  {
497  double pipj = hx[j] * hy[i];
498  hxy2 -= (pipj > 0.0001) ? pipj * std::log(pipj) : 0.;
499  double frequency = GLCIList->GetFrequency(i, j, glcVector) / totalFrequency;
500  m_Dissimilarity += (static_cast<double>(j) - static_cast<double>(i)) * (frequency * frequency);
501  }
502  }
503 
504  // Information measures of correlation 1 & 2
505  m_IC1 = (std::abs(std::max(hxCumul, hyCumul)) > 0.0001) ? (Entropy - hxy1) / (std::max(hxCumul, hyCumul)) : 0;
506  m_IC2 = 1 - std::exp(-2. * std::abs(hxy2 - Entropy));
507  m_IC2 = (m_IC2 >= 0) ? std::sqrt(m_IC2) : 0;
508 
509  // Fill outputs
510  meanIt.Set(m_Mean);
511  varianceIt.Set(m_Variance);
512  dissimilarityIt.Set(m_Dissimilarity);
513  sumAverageIt.Set(m_SumAverage);
514  sumVarianceIt.Set(m_SumVariance);
515  sumEntropytIt.Set(m_SumEntropy);
516  differenceEntropyIt.Set(m_DifferenceEntropy);
517  differenceVarianceIt.Set(m_DifferenceVariance);
518  ic1It.Set(m_IC1);
519  ic2It.Set(m_IC2);
520 
521  // Update progress
522  progress.CompletedPixel();
523 
524  // Increment iterators
525  ++varianceIt;
526  ++meanIt;
527  ++dissimilarityIt;
528  ++sumAverageIt;
529  ++sumVarianceIt;
530  ++sumEntropytIt;
531  ++differenceEntropyIt;
532  ++differenceVarianceIt;
533  ++ic1It;
534  ++ic2It;
535  }
536 }
537 
538 } // End namespace otb
539 
540 #endif
otb::ScalarImageToAdvancedTexturesFilter::GetSumAverageOutput
OutputImageType * GetSumAverageOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:103
otb::ScalarImageToAdvancedTexturesFilter::InputPixelType
InputImageType::PixelType InputPixelType
Definition: otbScalarImageToAdvancedTexturesFilter.h:124
otb::ScalarImageToAdvancedTexturesFilter::GetIC1Output
OutputImageType * GetIC1Output()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:158
otb::ScalarImageToAdvancedTexturesFilter::OutputRegionType
OutputImageType::RegionType OutputRegionType
Definition: otbScalarImageToAdvancedTexturesFilter.h:130
otb::ScalarImageToAdvancedTexturesFilter::OutputImagePointerType
OutputImageType::Pointer OutputImagePointerType
Definition: otbScalarImageToAdvancedTexturesFilter.h:129
otb::ScalarImageToAdvancedTexturesFilter::GenerateInputRequestedRegion
void GenerateInputRequestedRegion() override
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:209
otb::ScalarImageToAdvancedTexturesFilter::BeforeThreadedGenerateData
void BeforeThreadedGenerateData() override
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:272
otb::ScalarImageToAdvancedTexturesFilter::PixelValueType
CooccurrenceIndexedListType::PixelValueType PixelValueType
Definition: otbScalarImageToAdvancedTexturesFilter.h:136
otb
The "otb" namespace contains all Orfeo Toolbox (OTB) classes.
Definition: otbJoinContainer.h:32
otb::ScalarImageToAdvancedTexturesFilter::GetSumVarianceOutput
OutputImageType * GetSumVarianceOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:114
otbScalarImageToAdvancedTexturesFilter.h
otb::ScalarImageToAdvancedTexturesFilter::GenerateOutputInformation
void GenerateOutputInformation() override
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:179
otb::ScalarImageToAdvancedTexturesFilter::ThreadedGenerateData
void ThreadedGenerateData(const OutputRegionType &outputRegion, itk::ThreadIdType threadId) override
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:287
otb::ScalarImageToAdvancedTexturesFilter::GetDifferenceVarianceOutput
OutputImageType * GetDifferenceVarianceOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:147
otb::ScalarImageToAdvancedTexturesFilter::GetDifferenceEntropyOutput
OutputImageType * GetDifferenceEntropyOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:136
otb::ScalarImageToAdvancedTexturesFilter::CooccurrenceIndexType
CooccurrenceIndexedListType::IndexType CooccurrenceIndexType
Definition: otbScalarImageToAdvancedTexturesFilter.h:135
otb::ScalarImageToAdvancedTexturesFilter::VectorConstIteratorType
VectorType::const_iterator VectorConstIteratorType
Definition: otbScalarImageToAdvancedTexturesFilter.h:141
otb::ScalarImageToAdvancedTexturesFilter::GetVarianceOutput
OutputImageType * GetVarianceOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:81
otb::ScalarImageToAdvancedTexturesFilter::m_SubsampleFactor
SizeType m_SubsampleFactor
Definition: otbScalarImageToAdvancedTexturesFilter.h:260
otb::ScalarImageToAdvancedTexturesFilter::CooccurrenceIndexedListPointerType
CooccurrenceIndexedListType::Pointer CooccurrenceIndexedListPointerType
Definition: otbScalarImageToAdvancedTexturesFilter.h:133
otb::ScalarImageToAdvancedTexturesFilter::InputImagePointerType
InputImageType::Pointer InputImagePointerType
Definition: otbScalarImageToAdvancedTexturesFilter.h:123
otb::ScalarImageToAdvancedTexturesFilter::GetIC2Output
OutputImageType * GetIC2Output()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:169
otb::ScalarImageToAdvancedTexturesFilter::m_SubsampleOffset
OffsetType m_SubsampleOffset
Definition: otbScalarImageToAdvancedTexturesFilter.h:263
otb::ScalarImageToAdvancedTexturesFilter::~ScalarImageToAdvancedTexturesFilter
~ScalarImageToAdvancedTexturesFilter() override
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:65
otb::ScalarImageToAdvancedTexturesFilter::OutputImageType
TOutputImage OutputImageType
Definition: otbScalarImageToAdvancedTexturesFilter.h:128
otb::ScalarImageToAdvancedTexturesFilter::GetDissimilarityOutput
OutputImageType * GetDissimilarityOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:92
otb::ScalarImageToAdvancedTexturesFilter::ScalarImageToAdvancedTexturesFilter
ScalarImageToAdvancedTexturesFilter()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:35
otb::ScalarImageToAdvancedTexturesFilter::GetSumEntropyOutput
OutputImageType * GetSumEntropyOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:125
otb::ScalarImageToAdvancedTexturesFilter::VectorType
CooccurrenceIndexedListType::VectorType VectorType
Definition: otbScalarImageToAdvancedTexturesFilter.h:138
otb::ScalarImageToAdvancedTexturesFilter::InputRegionType
InputImageType::RegionType InputRegionType
Definition: otbScalarImageToAdvancedTexturesFilter.h:125
otb::ScalarImageToAdvancedTexturesFilter::InputImageType
TInpuImage InputImageType
Definition: otbScalarImageToAdvancedTexturesFilter.h:119
otb::ScalarImageToAdvancedTexturesFilter::GetMeanOutput
OutputImageType * GetMeanOutput()
Definition: otbScalarImageToAdvancedTexturesFilter.hxx:70
Generated at Wed Feb 28 2024 15:23:43 for OTB with   doxygen 1.8.17