otbDEMToImageGenerator.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 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 otbDEMToImageGenerator_h
#define otbDEMToImageGenerator_h
 
#include <stdio.h>
#include <string>
 
#include "itkImageSource.h"
#include "otbImage.h"
#include "otbDEMHandler.h"
#include "itkImageRegionIteratorWithIndex.h"
#include "otbGenericRSTransform.h"
 
namespace otb
{
template <class TDEMImage>
class ITK_EXPORT DEMToImageGenerator : public itk::ImageSource<TDEMImage>
{
public:
  typedef TDEMImage                        DEMImageType;
  typedef typename DEMImageType::Pointer   DEMImagePointerType;
  typedef typename DEMImageType::PixelType PixelType;
 
  typedef DEMToImageGenerator            Self;
  typedef itk::ImageSource<DEMImageType> Superclass;
  typedef itk::SmartPointer<Self>        Pointer;
  typedef itk::SmartPointer<const Self>  ConstPointer;
  typedef DEMImageType                   OutputImageType;
 
  typedef typename Superclass::Pointer                    OutputImagePointer;
  typedef typename OutputImageType::SpacingType           SpacingType;
  typedef typename OutputImageType::SizeType              SizeType;
  typedef typename OutputImageType::PointType             PointType;
  typedef typename OutputImageType::IndexType             IndexType;
  typedef typename Superclass::OutputImageRegionType      OutputImageRegionType;
  typedef itk::ImageRegionIteratorWithIndex<DEMImageType> ImageIteratorType;
 
  typedef otb::DEMHandler DEMHandlerType;
 
  typedef GenericRSTransform<>                     GenericRSTransformType;
  typedef typename GenericRSTransformType::Pointer GenericRSTransformPointerType;
 
 
  itkNewMacro(Self);
 
  itkTypeMacro(DEMToImageGenerator, ImageSource);
 
  itkSetMacro(OutputOrigin, PointType);
  itkGetConstReferenceMacro(OutputOrigin, PointType);
 
  itkSetMacro(OutputSize, SizeType);
  itkGetConstReferenceMacro(OutputSize, SizeType);
 
  itkSetMacro(OutputSpacing, SpacingType);
  itkGetConstReferenceMacro(OutputSpacing, SpacingType);
 
  itkSetObjectMacro(Transform, GenericRSTransformType);
  itkGetConstObjectMacro(Transform, GenericRSTransformType);
 
  itkSetMacro(AboveEllipsoid, bool);
  itkGetMacro(AboveEllipsoid, bool);
  itkBooleanMacro(AboveEllipsoid);
 
  void InstantiateTransform();
 
  void SetInputProjectionRef(const std::string& ref)
  {
    m_Transform->SetOutputProjectionRef(ref);
    this->Modified();
  }
 
  std::string GetInputProjectionRef() const
  {
    return m_Transform->GetOutputProjectionRef();
  }
 
  void SetOutputProjectionRef(const std::string& ref)
  {
    m_Transform->SetInputProjectionRef(ref);
    this->Modified();
  }
 
  std::string GetOutputProjectionRef() const
  {
    return m_Transform->GetInputProjectionRef();
  }
 
  const ImageMetadata* GetInputImageMetadata() const
  {
    return m_Transform->GetOutputImageMetadata();
  }
 
  void SetInputImageMetadata(const ImageMetadata* imd)
  {
    m_Transform->SetOutputImageMetadata(imd);
    this->Modified();
  }
 
  const ImageMetadata* GetOutputImageMetadata() const
  {
    return m_Transform->GetInputImageMetadata();
  }
  void SetOutputImageMetadata(const ImageMetadata* imd)
  {
    m_Transform->SetInputImageMetadata(imd);
    this->Modified();
  }
 
  template <class TImageType>
  void SetOutputParametersFromImage(const TImageType* image)
  {
    this->SetOutputOrigin(image->GetOrigin());
    this->SetOutputSpacing(image->GetSignedSpacing());
    // this->SetOutputStartIndex ( image->GetLargestPossibleRegion().GetIndex() );
    this->SetOutputSize(image->GetLargestPossibleRegion().GetSize());
    this->SetOutputProjectionRef(image->GetProjectionRef());
    this->SetOutputImageMetadata(&(image->GetImageMetadata()));
 
    InstantiateTransform();
  }
 
protected:
  DEMToImageGenerator();
  ~DEMToImageGenerator() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
  void BeforeThreadedGenerateData() override;
  void DynamicThreadedGenerateData(const OutputImageRegionType& outputRegionForThread) override;
  void GenerateOutputInformation() override;
 
  PointType               m_OutputOrigin{0.0};
  SpacingType             m_OutputSpacing{0.0};
  SizeType                m_OutputSize{0,0};
  PixelType               m_DefaultUnknownValue;
  bool                    m_AboveEllipsoid;
 
private:
  DEMToImageGenerator(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  GenericRSTransformPointerType m_Transform;
};
 
} // namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbDEMToImageGenerator.hxx"
#endif
 
#endif