otbGenericRSTransform.hxx

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 otbGenericRSTransform_hxx
#define otbGenericRSTransform_hxx
 
#include "otbGenericRSTransform.h"
#include "otbMacro.h"
#include "otbRPCForwardTransform.h"
#include "otbRPCInverseTransform.h"
 
#include "otbSpatialReference.h"
 
#include "ogr_spatialref.h"
#include "otbSensorTransformFactory.h"
 
namespace otb
{
 
template <class TScalarType, unsigned int NInputDimensions, unsigned int NOutputDimensions>
GenericRSTransform<TScalarType, NInputDimensions, NOutputDimensions>::GenericRSTransform() : Superclass(0)
{
  m_InputProjectionRef.clear();
  m_OutputProjectionRef.clear();
  m_InputSpacing.Fill(1);
  m_InputOrigin.Fill(0);
  m_OutputSpacing.Fill(1);
  m_OutputOrigin.Fill(0);
 
  m_InputImd          = nullptr;
  m_OutputImd         = nullptr;
  m_Transform         = nullptr;
  m_InputTransform    = nullptr;
  m_OutputTransform   = nullptr;
  m_TransformUpToDate = false;
  m_TransformAccuracy = Projection::UNKNOWN;
}
 
template <class TScalarType, unsigned int NInputDimensions, unsigned int NOutputDimensions>
const typename GenericRSTransform<TScalarType, NInputDimensions, NOutputDimensions>::TransformType*
GenericRSTransform<TScalarType, NInputDimensions, NOutputDimensions>::GetTransform() const
{
  itkDebugMacro("returning MapProjection address " << this->m_Transform);
  if ((!m_TransformUpToDate) || (m_Transform.IsNull()))
  {
    itkExceptionMacro(<< "m_Transform not up-to-date, call InstantiateTransform() first");
  }
 
  return this->m_Transform;
}
 
template <class TScalarType, unsigned int NInputDimensions, unsigned int NOutputDimensions>
void GenericRSTransform<TScalarType, NInputDimensions, NOutputDimensions>::InstantiateTransform(void)
{
  m_Transform = TransformType::New();
 
  if (m_InputProjectionRef.empty() && m_InputImd != nullptr && m_InputImd->HasProjectedGeometry())
  {
    m_InputProjectionRef = m_InputImd->GetProjectionWKT();
  }
 
  otbMsgDevMacro(<< "Information to instantiate transform: ");
  otbMsgDevMacro(<< " * Input Origin: " << m_InputOrigin);
  otbMsgDevMacro(<< " * Input Spacing: " << m_InputSpacing);
  otbMsgDevMacro(<< " * Input metadata: " << ((m_InputImd == nullptr) ? "Empty" : "Full"));
  otbMsgDevMacro(<< " * Input projection: " << m_InputProjectionRef);
  otbMsgDevMacro(<< " * Output metadata: " << ((m_OutputImd == nullptr) ? "Empty" : "Full"));
  otbMsgDevMacro(<< " * Output projection: " << m_OutputProjectionRef);
  otbMsgDevMacro(<< " * Output Origin: " << m_OutputOrigin);
  otbMsgDevMacro(<< " * Output Spacing: " << m_OutputSpacing);
 
  // Make sure that the state is clean:
  m_InputTransform  = nullptr;
  m_OutputTransform = nullptr;
 
  bool inputTransformIsSensor  = false;
  bool inputTransformIsMap     = false;
  bool outputTransformIsSensor = false;
  bool outputTransformIsMap    = false;
 
/*****************************
  // Set the input transformation
 
/*****************************
 
  // First, try to make a geo transform
  if (!m_InputProjectionRef.empty()) // map projection
  {
    typedef otb::GenericMapProjection<TransformDirection::INVERSE, ScalarType, InputSpaceDimension, InputSpaceDimension> InverseMapProjectionType;
    typename InverseMapProjectionType::Pointer mapTransform = InverseMapProjectionType::New();
 
    mapTransform->SetWkt(m_InputProjectionRef);
    if (mapTransform->IsProjectionDefined())
    {
      m_InputTransform    = mapTransform.GetPointer();
      inputTransformIsMap = true;
      otbMsgDevMacro(<< "Input projection set to map transform: " << m_InputTransform);
    }
  }
 
  // If not, try to make a sensor model
  if ((m_InputTransform.IsNull()) && (m_InputImd != nullptr))
  {
    auto sensorModel = otb::SensorTransformFactory::GetInstance().CreateTransform
        <double, InputSpaceDimension, OutputSpaceDimension>(*m_InputImd,TransformDirection::FORWARD);
 
    if (sensorModel != nullptr)
    {
      m_InputTransform       = sensorModel.GetPointer();
      inputTransformIsSensor = true;
      otbMsgDevMacro(<< "Input projection set to RPC model.");
    }
  }
 
/*****************************
  // Set the output transformation