otbMulti3DMapToDEMFilter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef otbMulti3DMapToDEMFilter_h
#define otbMulti3DMapToDEMFilter_h
 
#include "itkImageToImageFilter.h"
#include "otbImageToGenericRSOutputParameters.h"
#include "itkImageRegionIteratorWithIndex.h"
#include "itkImageRegionConstIterator.h"
#include "otbVectorImage.h"
#include "otbImage.h"
#include "itkImageRegionSplitter.h"
#include "otbObjectList.h"
#include <string>
 
namespace otb
{
 
namespace CellFusionMode
{
enum CellFusionMode
{
  MIN  = 0,
  MAX  = 1,
  MEAN = 2,
  ACC  = 3 // return accumulator for debug purpose
};
}
 
 
template <class T3DImage = otb::VectorImage<double, 2>, class TMaskImage = otb::Image<unsigned char>, class TOutputDEMImage = otb::Image<double>>
class ITK_EXPORT Multi3DMapToDEMFilter : public itk::ImageToImageFilter<T3DImage, TOutputDEMImage>
{
public:
  typedef Multi3DMapToDEMFilter Self;
  typedef itk::ImageToImageFilter<T3DImage, TOutputDEMImage> Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(Multi3DMapToDEMFilter, ImageToImageFilter);
 
  typedef T3DImage                 InputMapType;
  typedef TOutputDEMImage          OutputImageType;
  typedef TMaskImage               MaskImageType;
  typedef otb::Image<unsigned int> AccumulatorImageType;
 
  typedef typename OutputImageType::RegionType  RegionType;
  typedef typename OutputImageType::PixelType   DEMPixelType;
  typedef typename OutputImageType::PointType   OriginType;
  typedef typename OutputImageType::SpacingType SpacingType;
  typedef typename OutputImageType::SizeType    SizeType;
  typedef typename OutputImageType::IndexType   IndexType;
 
  typedef typename AccumulatorImageType::PixelType AccumulatorPixelType;
 
  typedef typename InputMapType::PixelType         MapPixelType;
  typedef typename InputMapType::InternalPixelType InputInternalPixelType;
  // 3D RS transform
  // TODO: Allow tuning precision (i.e. double or float)
  typedef double PrecisionType;
  typedef otb::GenericRSTransform<PrecisionType, 3, 3> RSTransformType;
 
  typedef otb::ImageToGenericRSOutputParameters<OutputImageType> OutputParametersEstimatorType;
 
  // 3D points
  typedef typename RSTransformType::InputPointType TDPointType;
 
  // 2D Transform
  typedef otb::GenericRSTransform<> RSTransform2DType;
 
  typedef std::map<unsigned int, itk::ImageRegionConstIterator<InputMapType>> MapIteratorList;
 
  typedef std::map<unsigned int, itk::ImageRegionConstIterator<MaskImageType>> MaskIteratorList;
 
 
  typedef double                               ValueType;
  typedef itk::VariableLengthVector<ValueType> MeasurementType;
 
  typedef itk::ImageRegionSplitter<2>   SplitterType;
  typedef otb::ObjectList<SplitterType> SplitterListType;
 
  void SetNumberOf3DMaps(unsigned int nb);
 
  unsigned int GetNumberOf3DMaps();
 
  void Set3DMapInput(unsigned int index, const T3DImage* hmap);
 
  void SetMaskInput(unsigned int index, const TMaskImage* mask);
 
  const T3DImage* Get3DMapInput(unsigned int index) const;
  const TMaskImage* GetMaskInput(unsigned int index) const;
 
  const TOutputDEMImage* GetDEMOutput() const;
  TOutputDEMImage*       GetDEMOutput();
 
  itkSetMacro(DEMGridStep, double);
  itkGetConstReferenceMacro(DEMGridStep, double);
 
  itkSetMacro(CellFusionMode, int);
  itkGetConstReferenceMacro(CellFusionMode, int);
 
  itkSetMacro(NoDataValue, DEMPixelType);
  itkGetConstReferenceMacro(NoDataValue, DEMPixelType);
 
  void SetOutputParametersFrom3DMap(int index = -1)
  {
    if (static_cast<unsigned int>((2 * (index + 1))) > this->GetNumberOfInputs())
    {
      itkExceptionMacro(<< "input at position " << index << " is unavailable");
    }
    m_OutputParametersFrom3DMap = index;
  }
 
 
  itkSetMacro(OutputOrigin, OriginType);
  itkGetConstReferenceMacro(OutputOrigin, OriginType);
 
  itkSetMacro(OutputStartIndex, IndexType);
  itkGetConstReferenceMacro(OutputStartIndex, IndexType);
 
  itkSetMacro(OutputSize, SizeType);
  itkGetConstReferenceMacro(OutputSize, SizeType);
 
  itkSetMacro(OutputSpacing, SpacingType);
  itkGetConstReferenceMacro(OutputSpacing, SpacingType);
 
  itkSetMacro(ProjectionRef, std::string);
  itkGetConstReferenceMacro(ProjectionRef, std::string);
 
  itkGetConstReferenceMacro(OutputParametersFrom3DMap, int);
 
 
  itkSetMacro(ElevationMin, double);
  itkGetConstReferenceMacro(ElevationMin, double);
 
  itkSetMacro(ElevationMax, double);
  itkGetConstReferenceMacro(ElevationMax, double);
 
 
  itkSetMacro(Margin, SizeType);
  itkGetConstReferenceMacro(Margin, SizeType);
 
 
protected:
  Multi3DMapToDEMFilter();
 
  ~Multi3DMapToDEMFilter() override;
 
  void GenerateOutputInformation() override;
 
  void GenerateInputRequestedRegion() override;
 
  void BeforeThreadedGenerateData() override;
 
  void ThreadedGenerateData(const RegionType& outputRegionForThread, itk::ThreadIdType threadId) override;
 
  void AfterThreadedGenerateData() override;
 
  void VerifyInputInformation() override
  {
  }
 
 
private:
  void SetOutputParametersFromImage();
 
  Multi3DMapToDEMFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  RSTransformType::Pointer m_ReferenceToGroundTransform;
 
  std::vector<RSTransformType::Pointer> m_MapToGroundTransform;
 
  std::vector<MeasurementType> m_MapMinVal;
  std::vector<MeasurementType> m_MapMaxVal;
  double m_DEMGridStep;
 
  std::vector<typename OutputImageType::Pointer> m_TempDEMRegions;
 
  std::vector<typename AccumulatorImageType::Pointer> m_TempDEMAccumulatorRegions;
 
 
  std::vector<unsigned int> m_NumberOfSplit; // number of split for each map
  // std::vector<int> m_ThreadProcessed; //
  SplitterListType::Pointer m_MapSplitterList;
 
  DEMPixelType m_NoDataValue;
  int          m_CellFusionMode;
  std::string  m_ProjectionRef;
 
  double m_ElevationMin;
 
  double m_ElevationMax;
 
 
  SizeType    m_OutputSize{0,0};
  IndexType   m_OutputStartIndex;
  SpacingType m_OutputSpacing{0.0};
  OriginType  m_OutputOrigin{0.0};
 
  SizeType m_Margin;
 
  int  m_OutputParametersFrom3DMap;
  bool m_IsGeographic;
 
  RSTransform2DType::Pointer m_GroundTransform;
};
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbMulti3DMapToDEMFilter.hxx"
#endif
 
#endif