OTB  9.0.0
Orfeo Toolbox
otbDisparityTranslateFilter.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 otbDisparityTranslateFilter_hxx
22 #define otbDisparityTranslateFilter_hxx
23 
24 #include "otbDisparityTranslateFilter.h"
25 
26 #include "itkImageRegionIteratorWithIndex.h"
27 #include "itkImageRegionIterator.h"
28 #include "otbNoDataHelper.h"
29 
30 namespace otb
31 {
32 
33 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
34 DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::DisparityTranslateFilter()
35  : m_NoDataValue(-32768)
36 {
37  // Set the number of inputs (1 moving image by default -> 3 inputs)
38  this->SetNumberOfRequiredInputs(6);
39  this->SetNumberOfRequiredInputs(1);
40 
41  // Set the outputs
42  this->SetNumberOfRequiredOutputs(2);
43  this->SetNthOutput(0, TDisparityImage::New());
44  this->SetNthOutput(1, TDisparityImage::New());
45 }
46 
47 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
48 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetHorizontalDisparityMapInput(const TDisparityImage* hmap)
49 {
50  // Process object is not const-correct so the const casting is required.
51  this->SetNthInput(0, const_cast<TDisparityImage*>(hmap));
52 }
53 
54 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
55 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetVerticalDisparityMapInput(const TDisparityImage* vmap)
56 {
57  // Process object is not const-correct so the const casting is required.
58  this->SetNthInput(1, const_cast<TDisparityImage*>(vmap));
59 }
60 
61 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
62 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetInverseEpipolarLeftGrid(const TGridImage* lgrid)
63 {
64  // Process object is not const-correct so the const casting is required.
65  this->SetNthInput(2, const_cast<TGridImage*>(lgrid));
66 }
67 
68 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
69 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetDirectEpipolarRightGrid(const TGridImage* rgrid)
70 {
71  // Process object is not const-correct so the const casting is required.
72  this->SetNthInput(3, const_cast<TGridImage*>(rgrid));
73 }
74 
75 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
76 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetDisparityMaskInput(const TMaskImage* mask)
77 {
78  // Process object is not const-correct so the const casting is required.
79  this->SetNthInput(4, const_cast<TMaskImage*>(mask));
80 }
81 
82 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
83 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::SetLeftSensorImageInput(const TSensorImage* left)
84 {
85  // Process object is not const-correct so the const casting is required.
86  this->SetNthInput(5, const_cast<TSensorImage*>(left));
87 }
88 
89 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
90 const TDisparityImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetHorizontalDisparityMapInput() const
91 {
92  if (this->GetNumberOfInputs() < 1)
93  {
94  return nullptr;
95  }
96  return static_cast<const TDisparityImage*>(this->itk::ProcessObject::GetInput(0));
97 }
98 
99 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
100 const TDisparityImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetVerticalDisparityMapInput() const
101 {
102  if (this->GetNumberOfInputs() < 2)
103  {
104  return nullptr;
105  }
106  return static_cast<const TDisparityImage*>(this->itk::ProcessObject::GetInput(1));
107 }
108 
109 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
110 const TGridImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetInverseEpipolarLeftGrid() const
111 {
112  if (this->GetNumberOfInputs() < 3)
113  {
114  return nullptr;
115  }
116  return static_cast<const TGridImage*>(this->itk::ProcessObject::GetInput(2));
117 }
118 
119 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
120 const TGridImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetDirectEpipolarRightGrid() const
121 {
122  if (this->GetNumberOfInputs() < 4)
123  {
124  return nullptr;
125  }
126  return static_cast<const TGridImage*>(this->itk::ProcessObject::GetInput(3));
127 }
128 
129 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
130 const TMaskImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetDisparityMaskInput() const
131 {
132  if (this->GetNumberOfInputs() < 5)
133  {
134  return nullptr;
135  }
136  return static_cast<const TMaskImage*>(this->itk::ProcessObject::GetInput(4));
137 }
138 
139 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
140 const TSensorImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetLeftSensorImageInput() const
141 {
142  if (this->GetNumberOfInputs() < 6)
143  {
144  return nullptr;
145  }
146  return static_cast<const TSensorImage*>(this->itk::ProcessObject::GetInput(5));
147 }
148 
149 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
150 TDisparityImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetHorizontalDisparityMapOutput()
151 {
152  if (this->GetNumberOfOutputs() < 1)
153  {
154  return nullptr;
155  }
156  return static_cast<TDisparityImage*>(this->itk::ProcessObject::GetOutput(0));
157 }
158 
159 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
160 TDisparityImage* DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GetVerticalDisparityMapOutput()
161 {
162  if (this->GetNumberOfOutputs() < 2)
163  {
164  return nullptr;
165  }
166  return static_cast<TDisparityImage*>(this->itk::ProcessObject::GetOutput(1));
167 }
168 
169 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
170 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GenerateOutputInformation()
171 {
172  // this->Superclass::GenerateOutputInformation();
173 
174  TDisparityImage* horizOut = this->GetHorizontalDisparityMapOutput();
175  TDisparityImage* vertiOut = this->GetVerticalDisparityMapOutput();
176 
177  const TSensorImage* leftIn = this->GetLeftSensorImageInput();
178 
179  horizOut->CopyInformation(leftIn);
180  vertiOut->CopyInformation(leftIn);
181 
182  // Set the NoData value
183  std::vector<bool> noDataValueAvailable = {true};
184  std::vector<double> noDataValue = {m_NoDataValue};
185 
186  WriteNoDataFlags(noDataValueAvailable, noDataValue, horizOut->GetImageMetadata());
187  WriteNoDataFlags(noDataValueAvailable, noDataValue, vertiOut->GetImageMetadata());
188 }
189 
190 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
191 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::GenerateInputRequestedRegion()
192 {
193  this->Superclass::GenerateInputRequestedRegion();
194 
195  TGridImage* leftGrid = const_cast<TGridImage*>(this->GetInverseEpipolarLeftGrid());
196  TGridImage* rightGrid = const_cast<TGridImage*>(this->GetDirectEpipolarRightGrid());
197 
198  leftGrid->SetRequestedRegionToLargestPossibleRegion();
199  rightGrid->SetRequestedRegionToLargestPossibleRegion();
200 
201  leftGrid->UpdateOutputData();
202  rightGrid->UpdateOutputData();
203 
204  TSensorImage* leftIn = const_cast<TSensorImage*>(this->GetLeftSensorImageInput());
205  RegionType emptyRegion = leftIn->GetLargestPossibleRegion();
206  emptyRegion.SetSize(0, 0);
207  emptyRegion.SetSize(1, 0);
208  leftIn->SetRequestedRegion(emptyRegion);
209 
210  TDisparityImage* horizOut = this->GetHorizontalDisparityMapOutput();
211 
212  TDisparityImage* horizIn = const_cast<TDisparityImage*>(this->GetHorizontalDisparityMapInput());
213  TDisparityImage* vertiIn = const_cast<TDisparityImage*>(this->GetVerticalDisparityMapInput());
214 
215  TMaskImage* maskIn = const_cast<TMaskImage*>(this->GetDisparityMaskInput());
216 
217  RegionType requested = this->GetHorizontalDisparityMapOutput()->GetRequestedRegion();
218  RegionType inputlargest = this->GetHorizontalDisparityMapInput()->GetLargestPossibleRegion();
219  RegionType inputRequested;
220  GridRegionType gridLargest = leftGrid->GetLargestPossibleRegion();
221 
222  IndexType minIndex, maxIndex;
223  // -Wmaybe-uninitialized
224  minIndex.Fill(itk::NumericTraits<IndexValueType>::Zero);
225  maxIndex.Fill(itk::NumericTraits<IndexValueType>::Zero);
226 
227  IndexType corners[4];
228  for (int i = 0; i < 4; i++)
229  corners[i].Fill(itk::NumericTraits<IndexValueType>::Zero);
230 
231  corners[0] = requested.GetIndex();
232  corners[1] = requested.GetIndex();
233  corners[1][0] += static_cast<IndexValueType>(requested.GetSize()[0]) - 1;
234  corners[2] = requested.GetIndex();
235  corners[2][1] += static_cast<IndexValueType>(requested.GetSize()[1]) - 1;
236  corners[3] = requested.GetIndex();
237  corners[3][0] += static_cast<IndexValueType>(requested.GetSize()[0]) - 1;
238  corners[3][1] += static_cast<IndexValueType>(requested.GetSize()[1]) - 1;
239  for (unsigned int k = 0; k < 4; ++k)
240  {
241  PointType pointSensor;
242  horizOut->TransformIndexToPhysicalPoint(corners[k], pointSensor);
243  itk::ContinuousIndex<double, 2> indexGrid;
244  leftGrid->TransformPhysicalPointToContinuousIndex(pointSensor, indexGrid);
245  IndexType ul;
246  ul[0] = static_cast<long>(std::floor(indexGrid[0]));
247  ul[1] = static_cast<long>(std::floor(indexGrid[1]));
248  if (ul[0] < gridLargest.GetIndex()[0])
249  ul[0] = gridLargest.GetIndex()[0];
250  if (ul[1] < gridLargest.GetIndex()[1])
251  ul[1] = gridLargest.GetIndex()[1];
252  if (ul[0] > static_cast<IndexValueType>(gridLargest.GetIndex()[0] + gridLargest.GetSize()[0] - 2))
253  ul[0] = (gridLargest.GetIndex()[0] + gridLargest.GetSize()[0] - 2);
254  if (ul[1] > static_cast<IndexValueType>(gridLargest.GetIndex()[1] + gridLargest.GetSize()[1] - 2))
255  ul[1] = (gridLargest.GetIndex()[1] + gridLargest.GetSize()[1] - 2);
256 
257  IndexType ur = ul;
258  ur[0] += 1;
259  IndexType ll = ul;
260  ll[1] += 1;
261  IndexType lr = ul;
262  lr[0] += 1;
263  lr[1] += 1;
264 
265  double rx = indexGrid[0] - static_cast<double>(ul[0]);
266  double ry = indexGrid[1] - static_cast<double>(ul[1]);
267  PointType pointEpi = pointSensor;
268 
269  pointEpi[0] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[0] + rx * leftGrid->GetPixel(ur)[0]) +
270  ry * ((1. - rx) * leftGrid->GetPixel(ll)[0] + rx * leftGrid->GetPixel(lr)[0]);
271  pointEpi[1] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[1] + rx * leftGrid->GetPixel(ur)[1]) +
272  ry * ((1. - rx) * leftGrid->GetPixel(ll)[1] + rx * leftGrid->GetPixel(lr)[1]);
273  itk::ContinuousIndex<double, 2> indexEpi;
274 
275  horizIn->TransformPhysicalPointToContinuousIndex(pointEpi, indexEpi);
276  if (k == 0)
277  {
278  minIndex[0] = static_cast<long>(std::floor(indexEpi[0]));
279  minIndex[1] = static_cast<long>(std::floor(indexEpi[1]));
280  maxIndex[0] = static_cast<long>(std::ceil(indexEpi[0]));
281  maxIndex[1] = static_cast<long>(std::ceil(indexEpi[1]));
282  }
283  else
284  {
285  if (minIndex[0] > static_cast<long>(std::floor(indexEpi[0])))
286  minIndex[0] = static_cast<long>(std::floor(indexEpi[0]));
287  if (minIndex[1] > static_cast<long>(std::floor(indexEpi[1])))
288  minIndex[1] = static_cast<long>(std::floor(indexEpi[1]));
289  if (maxIndex[0] < static_cast<long>(std::ceil(indexEpi[0])))
290  maxIndex[0] = static_cast<long>(std::ceil(indexEpi[0]));
291  if (maxIndex[1] < static_cast<long>(std::ceil(indexEpi[1])))
292  maxIndex[1] = static_cast<long>(std::ceil(indexEpi[1]));
293  }
294  }
295 
296  inputRequested.SetIndex(minIndex);
297  inputRequested.SetSize(0, static_cast<unsigned long>(maxIndex[0] - minIndex[0]));
298  inputRequested.SetSize(1, static_cast<unsigned long>(maxIndex[1] - minIndex[1]));
299 
300  if (!inputRequested.Crop(inputlargest))
301  {
302  inputRequested.SetSize(0, 0);
303  inputRequested.SetSize(1, 0);
304  inputRequested.SetIndex(inputlargest.GetIndex());
305  }
306 
307  horizIn->SetRequestedRegion(inputRequested);
308  if (vertiIn)
309  vertiIn->SetRequestedRegion(inputRequested);
310  if (maskIn)
311  maskIn->SetRequestedRegion(inputRequested);
312 }
313 
314 template <class TDisparityImage, class TGridImage, class TSensorImage, class TMaskImage>
315 void DisparityTranslateFilter<TDisparityImage, TGridImage, TSensorImage, TMaskImage>::ThreadedGenerateData(const RegionType& outputRegionForThread,
316  itk::ThreadIdType itkNotUsed(threadId))
317 {
318  const TGridImage* leftGrid = this->GetInverseEpipolarLeftGrid();
319  const TGridImage* rightGrid = this->GetDirectEpipolarRightGrid();
320 
321  TDisparityImage* horizOut = this->GetHorizontalDisparityMapOutput();
322  TDisparityImage* vertiOut = this->GetVerticalDisparityMapOutput();
323 
324  const TDisparityImage* horizIn = this->GetHorizontalDisparityMapInput();
325  const TDisparityImage* vertiIn = this->GetVerticalDisparityMapInput();
326 
327  const TMaskImage* maskIn = this->GetDisparityMaskInput();
328 
329  GridRegionType leftLargest = leftGrid->GetLargestPossibleRegion();
330  GridRegionType rightLargest = rightGrid->GetLargestPossibleRegion();
331  RegionType buffered = horizIn->GetBufferedRegion();
332 
333  const bool emptyInputRegion = buffered.GetNumberOfPixels() == 0;
334 
335  typedef itk::ImageRegionIteratorWithIndex<TDisparityImage> DispIterator;
336  DispIterator horizIter(horizOut, outputRegionForThread);
337  DispIterator vertiIter(vertiOut, outputRegionForThread);
338 
339  horizIter.GoToBegin();
340  vertiIter.GoToBegin();
341 
342  while (!horizIter.IsAtEnd() && !vertiIter.IsAtEnd())
343  {
344 
345  if (!emptyInputRegion)
346  {
347  PointType pointSensor;
348  horizOut->TransformIndexToPhysicalPoint(horizIter.GetIndex(), pointSensor);
349 
350  itk::ContinuousIndex<double, 2> indexGrid;
351  leftGrid->TransformPhysicalPointToContinuousIndex(pointSensor, indexGrid);
352 
353  // Interpolate in left grid
354  IndexType ul;
355  ul[0] = static_cast<long>(std::floor(indexGrid[0]));
356  ul[1] = static_cast<long>(std::floor(indexGrid[1]));
357  if (ul[0] < leftLargest.GetIndex()[0])
358  ul[0] = leftLargest.GetIndex()[0];
359  if (ul[1] < leftLargest.GetIndex()[1])
360  ul[1] = leftLargest.GetIndex()[1];
361  if (ul[0] > static_cast<IndexValueType>(leftLargest.GetIndex()[0] + leftLargest.GetSize()[0] - 2))
362  ul[0] = (leftLargest.GetIndex()[0] + leftLargest.GetSize()[0] - 2);
363  if (ul[1] > static_cast<IndexValueType>(leftLargest.GetIndex()[1] + leftLargest.GetSize()[1] - 2))
364  ul[1] = (leftLargest.GetIndex()[1] + leftLargest.GetSize()[1] - 2);
365 
366  IndexType ur = ul;
367  ur[0] += 1;
368  IndexType ll = ul;
369  ll[1] += 1;
370  IndexType lr = ul;
371  lr[0] += 1;
372  lr[1] += 1;
373 
374  double rx = indexGrid[0] - static_cast<double>(ul[0]);
375  double ry = indexGrid[1] - static_cast<double>(ul[1]);
376  PointType pointEpi = pointSensor;
377 
378  pointEpi[0] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[0] + rx * leftGrid->GetPixel(ur)[0]) +
379  ry * ((1. - rx) * leftGrid->GetPixel(ll)[0] + rx * leftGrid->GetPixel(lr)[0]);
380  pointEpi[1] += (1. - ry) * ((1. - rx) * leftGrid->GetPixel(ul)[1] + rx * leftGrid->GetPixel(ur)[1]) +
381  ry * ((1. - rx) * leftGrid->GetPixel(ll)[1] + rx * leftGrid->GetPixel(lr)[1]);
382 
383  itk::ContinuousIndex<double, 2> indexEpi;
384  horizIn->TransformPhysicalPointToContinuousIndex(pointEpi, indexEpi);
385 
386  // Interpolate in disparity map
387  ul[0] = static_cast<long>(std::floor(indexEpi[0]));
388  ul[1] = static_cast<long>(std::floor(indexEpi[1]));
389  if (ul[0] < buffered.GetIndex()[0])
390  ul[0] = buffered.GetIndex()[0];
391  if (ul[1] < buffered.GetIndex()[1])
392  ul[1] = buffered.GetIndex()[1];
393  if (ul[0] > static_cast<IndexValueType>(buffered.GetIndex()[0] + buffered.GetSize()[0] - 2))
394  ul[0] = (buffered.GetIndex()[0] + buffered.GetSize()[0] - 2);
395  if (ul[1] > static_cast<IndexValueType>(buffered.GetIndex()[1] + buffered.GetSize()[1] - 2))
396  ul[1] = (buffered.GetIndex()[1] + buffered.GetSize()[1] - 2);
397 
398  ur = ul;
399  ur[0] += 1;
400  ll = ul;
401  ll[1] += 1;
402  lr = ul;
403  lr[0] += 1;
404  lr[1] += 1;
405 
406  // check if all corners are valid
407  if (!maskIn || (maskIn && maskIn->GetPixel(ul) > 0 && maskIn->GetPixel(ur) > 0 && maskIn->GetPixel(ll) > 0 && maskIn->GetPixel(lr) > 0))
408  {
409  rx = indexEpi[0] - static_cast<double>(ul[0]);
410  ry = indexEpi[1] - static_cast<double>(ul[1]);
411 
412  itk::ContinuousIndex<double, 2> indexRight(indexEpi);
413 
414  indexRight[0] += (1. - ry) * ((1. - rx) * horizIn->GetPixel(ul) + rx * horizIn->GetPixel(ur)) +
415  ry * ((1. - rx) * horizIn->GetPixel(ll) + rx * horizIn->GetPixel(lr));
416  if (vertiIn)
417  {
418  indexRight[1] += (1. - ry) * ((1. - rx) * vertiIn->GetPixel(ul) + rx * vertiIn->GetPixel(ur)) +
419  ry * ((1. - rx) * vertiIn->GetPixel(ll) + rx * vertiIn->GetPixel(lr));
420  }
421 
422  PointType pointRight;
423  horizIn->TransformContinuousIndexToPhysicalPoint(indexRight, pointRight);
424 
425  itk::ContinuousIndex<double, 2> indexGridRight;
426  rightGrid->TransformPhysicalPointToContinuousIndex(pointRight, indexGridRight);
427 
428  // Interpolate in right grid
429  ul[0] = static_cast<long>(std::floor(indexGridRight[0]));
430  ul[1] = static_cast<long>(std::floor(indexGridRight[1]));
431  if (ul[0] < rightLargest.GetIndex()[0])
432  ul[0] = rightLargest.GetIndex()[0];
433  if (ul[1] < rightLargest.GetIndex()[1])
434  ul[1] = rightLargest.GetIndex()[1];
435  if (ul[0] > static_cast<IndexValueType>(rightLargest.GetIndex()[0] + rightLargest.GetSize()[0] - 2))
436  ul[0] = (rightLargest.GetIndex()[0] + rightLargest.GetSize()[0] - 2);
437  if (ul[1] > static_cast<IndexValueType>(rightLargest.GetIndex()[1] + rightLargest.GetSize()[1] - 2))
438  ul[1] = (rightLargest.GetIndex()[1] + rightLargest.GetSize()[1] - 2);
439 
440  ur = ul;
441  ur[0] += 1;
442  ll = ul;
443  ll[1] += 1;
444  lr = ul;
445  lr[0] += 1;
446  lr[1] += 1;
447 
448  rx = indexGridRight[0] - static_cast<double>(ul[0]);
449  ry = indexGridRight[1] - static_cast<double>(ul[1]);
450 
451  PointType pointSensorRight = pointRight;
452 
453  pointSensorRight[0] += (1. - ry) * ((1. - rx) * rightGrid->GetPixel(ul)[0] + rx * rightGrid->GetPixel(ur)[0]) +
454  ry * ((1. - rx) * rightGrid->GetPixel(ll)[0] + rx * rightGrid->GetPixel(lr)[0]);
455  pointSensorRight[1] += (1. - ry) * ((1. - rx) * rightGrid->GetPixel(ul)[1] + rx * rightGrid->GetPixel(ur)[1]) +
456  ry * ((1. - rx) * rightGrid->GetPixel(ll)[1] + rx * rightGrid->GetPixel(lr)[1]);
457 
458  horizIter.Set(pointSensorRight[0] - pointSensor[0]);
459  vertiIter.Set(pointSensorRight[1] - pointSensor[1]);
460  }
461  else
462  {
463  horizIter.Set(m_NoDataValue);
464  vertiIter.Set(m_NoDataValue);
465  }
466  }
467  else
468  {
469  horizIter.Set(m_NoDataValue);
470  vertiIter.Set(m_NoDataValue);
471  }
472  ++horizIter;
473  ++vertiIter;
474  }
475 }
476 }
477 
478 #endif
otb::DisparityTranslateFilter::SetLeftSensorImageInput
void SetLeftSensorImageInput(const TSensorImage *left)
Definition: otbDisparityTranslateFilter.hxx:83
otb::DisparityTranslateFilter::GetDisparityMaskInput
const TMaskImage * GetDisparityMaskInput() const
Definition: otbDisparityTranslateFilter.hxx:130
otb::DisparityTranslateFilter::GridRegionType
GridType::RegionType GridRegionType
Definition: otbDisparityTranslateFilter.h:77
otb::DisparityTranslateFilter::RegionType
DispMapType::RegionType RegionType
Definition: otbDisparityTranslateFilter.h:70
otb::DisparityTranslateFilter::GetHorizontalDisparityMapInput
const TDisparityImage * GetHorizontalDisparityMapInput() const
Definition: otbDisparityTranslateFilter.hxx:90
otb::DisparityTranslateFilter::IndexValueType
DispMapType::IndexValueType IndexValueType
Definition: otbDisparityTranslateFilter.h:75
otb::WriteNoDataFlags
void OTBMetadata_EXPORT WriteNoDataFlags(const std::vector< bool > &flags, const std::vector< double > &values, ImageMetadata &imd)
otb::DisparityTranslateFilter::DisparityTranslateFilter
DisparityTranslateFilter()
Definition: otbDisparityTranslateFilter.hxx:34
otb::DisparityTranslateFilter::GenerateInputRequestedRegion
void GenerateInputRequestedRegion() override
Definition: otbDisparityTranslateFilter.hxx:191
otb
The "otb" namespace contains all Orfeo Toolbox (OTB) classes.
Definition: otbJoinContainer.h:32
otb::DisparityTranslateFilter::IndexType
DispMapType::IndexType IndexType
Definition: otbDisparityTranslateFilter.h:72
otb::DisparityTranslateFilter::GetVerticalDisparityMapInput
const TDisparityImage * GetVerticalDisparityMapInput() const
Definition: otbDisparityTranslateFilter.hxx:100
otb::DisparityTranslateFilter::SetVerticalDisparityMapInput
void SetVerticalDisparityMapInput(const TDisparityImage *vmap)
Definition: otbDisparityTranslateFilter.hxx:55
otb::DisparityTranslateFilter::GetDirectEpipolarRightGrid
const TGridImage * GetDirectEpipolarRightGrid() const
Definition: otbDisparityTranslateFilter.hxx:120
otb::DisparityTranslateFilter::GenerateOutputInformation
void GenerateOutputInformation() override
Definition: otbDisparityTranslateFilter.hxx:170
otbDisparityTranslateFilter.h
otbNoDataHelper.h
otb::DisparityTranslateFilter::ThreadedGenerateData
void ThreadedGenerateData(const RegionType &outputRegionForThread, itk::ThreadIdType threadId) override
Definition: otbDisparityTranslateFilter.hxx:315
otb::DisparityTranslateFilter::SetDisparityMaskInput
void SetDisparityMaskInput(const TMaskImage *mask)
Definition: otbDisparityTranslateFilter.hxx:76
otb::DisparityTranslateFilter::SetInverseEpipolarLeftGrid
void SetInverseEpipolarLeftGrid(const TGridImage *lgrid)
Definition: otbDisparityTranslateFilter.hxx:62
otb::DisparityTranslateFilter::SetDirectEpipolarRightGrid
void SetDirectEpipolarRightGrid(const TGridImage *rgrid)
Definition: otbDisparityTranslateFilter.hxx:69
otb::DisparityTranslateFilter::GetInverseEpipolarLeftGrid
const TGridImage * GetInverseEpipolarLeftGrid() const
Definition: otbDisparityTranslateFilter.hxx:110
otb::DisparityTranslateFilter::GetLeftSensorImageInput
const TSensorImage * GetLeftSensorImageInput() const
Definition: otbDisparityTranslateFilter.hxx:140
otb::DisparityTranslateFilter::GetHorizontalDisparityMapOutput
TDisparityImage * GetHorizontalDisparityMapOutput()
Definition: otbDisparityTranslateFilter.hxx:150
otb::DisparityTranslateFilter::PointType
DispMapType::PointType PointType
Definition: otbDisparityTranslateFilter.h:74
otb::DisparityTranslateFilter::SetHorizontalDisparityMapInput
void SetHorizontalDisparityMapInput(const TDisparityImage *hmap)
Definition: otbDisparityTranslateFilter.hxx:48
otb::DisparityTranslateFilter::GetVerticalDisparityMapOutput
TDisparityImage * GetVerticalDisparityMapOutput()
Definition: otbDisparityTranslateFilter.hxx:160
Generated at Wed Feb 28 2024 15:21:49 for OTB with   doxygen 1.8.17