otbGeometriesProjectionFilter.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 otbGeometriesProjectionFilter_h
#define otbGeometriesProjectionFilter_h
 
#include "otbGeometriesToGeometriesFilter.h"
#include "otbOGRGeometryWrapper.h"
#include "otbImageReference.h"
#include "itkTransform.h"
#include "otbGenericRSTransform.h"
#include "otbImageMetadata.h"
 
#include "OTBProjectionExport.h"
#include <string>
 
class OGRCoordinateTransformation;
 
namespace otb
{
 
namespace internal
{
struct OTBProjection_EXPORT ReprojectTransformationFunctor
{
  typedef OGRGeometry TransformedElementType;
 
  struct ByCopy
  {
    ByCopy(ReprojectTransformationFunctor const& reprojector) : m_Reprojector(reprojector)
    {
    }
    template <typename TGeometry>
    ogr::UniqueGeometryPtr operator()(TGeometry const* in) const;
 
  private:
    ReprojectTransformationFunctor const& m_Reprojector;
  };
 
  struct InPlace
  {
    InPlace(ReprojectTransformationFunctor const& reprojector) : m_Reprojector(reprojector)
    {
    }
    template <typename TGeometry>
    void operator()(TGeometry* inout) const;
 
  private:
    ReprojectTransformationFunctor const& m_Reprojector;
  };
 
 
  ogr::UniqueGeometryPtr operator()(OGRGeometry const* in) const;
  void apply_inplace(OGRGeometry* inout) const;
 
  typedef otb::GenericRSTransform<double, 2, 2> InternalTransformType;
  typedef InternalTransformType::Pointer InternalTransformPointerType;
  void SetOnePointTransformation(InternalTransformPointerType transform);
 
private:
  void do_transform(OGRPoint& g) const;
  // void do_transform(OGRLinearRing         & g) const;
 
  void do_transform(OGRLineString& g) const;
  // void do_transform(OGRCurve              & g) const;
 
  void do_transform(OGRPolygon& g) const;
#if 0
  void do_transform(OGRSurface            & g) const;
  void do_transform(OGRMultiLineString    & g) const;
  void do_transform(OGRMultiPoint         & g) const;
  void do_transform(OGRMultiPolygon       & g) const;
#endif
 
  void do_transform(OGRGeometryCollection& g) const;
 
  InternalTransformPointerType m_Transform;
};
} // internal namespace
 
 
class OTBProjection_EXPORT GeometriesProjectionFilter : public GeometriesToGeometriesFilter
{
public:
 
  typedef GeometriesProjectionFilter    Self;
  typedef GeometriesToGeometriesFilter  Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
 
  itkNewMacro(Self);
 
  itkTypeMacro(GeometriesProjectionFilter, GeometriesToGeometriesFilter);
 
  typedef Superclass::InputGeometriesType InputGeometriesType;
  // typedef Superclass::InputGeometriesPointer  InputGeometriesPointer;
  typedef Superclass::OutputGeometriesType OutputGeometriesType;
  // typedef Superclass::OutputGeometriesPointer OutputGeometriesPointer;
  typedef ogr::ImageReference<double> ImageReference;
 
 
private:
  OGRSpatialReference* DoDefineNewLayerSpatialReference(ogr::Layer const& source) const override;
 
  void DoProcessLayer(ogr::Layer const& source, ogr::Layer& destination) const override;
 
  void DoFinalizeInitialization() override;
 
  void DoDefineNewLayerFields(ogr::Layer const& source, ogr::Layer& dest) const override;
 
protected:
  GeometriesProjectionFilter();
 
  ~GeometriesProjectionFilter() override;
 
  void GenerateOutputInformation(void) override;
 
public:
  void SetInputSpacing(ImageReference::SpacingType const& spacing);
  void SetOutputSpacing(ImageReference::SpacingType const& spacing);
  void SetInputOrigin(ImageReference::OriginType const& origin);
  void SetOutputOrigin(ImageReference::OriginType const& origin);
 
 
  const ImageMetadata* GetInputImageMetadata() const
  {
    return m_InputImageMetadata;
  }
 
  void SetInputImageMetadata(const ImageMetadata* imd)
  {
    m_InputImageMetadata = imd;
    this->Modified();
  }
 
  const ImageMetadata* GetOutputImageMetadata() const
  {
    return m_OutputImageMetadata;
  }
  void SetOutputImageMetadata(const ImageMetadata* imd)
    {
      m_OutputImageMetadata = imd;
      this->Modified();
    }
 
  itkSetStringMacro(OutputProjectionRef);
  itkGetStringMacro(OutputProjectionRef);
 
 
private:
  typedef internal::ReprojectTransformationFunctor          TransformationFunctorType;
  typedef TransformationFunctorType::TransformedElementType TransformedElementType;
  typedef TransformationFunctorDispatcher<TransformationFunctorType, TransformedElementType, FieldCopyTransformation> TransformationFunctorDispatcherType;
 
  TransformationFunctorDispatcherType m_TransformationFunctor;
 
  typedef TransformationFunctorType::InternalTransformType        InternalTransformType;
  typedef TransformationFunctorType::InternalTransformPointerType InternalTransformPointerType;
 
  InternalTransformPointerType m_Transform;
 
  ImageReference m_InputImageReference;
  ImageReference m_OutputImageReference;
 
  std::string      m_OutputProjectionRef; // in WKT format!
  const ImageMetadata*   m_InputImageMetadata = nullptr;
  const ImageMetadata*   m_OutputImageMetadata = nullptr;
};
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbGeometriesProjectionFilter.hxx"
#endif
 
#endif // otbGeometriesProjectionFilter_h