otbSpot5SensorModel.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 otbSpot5SensorModel_h
#define otbSpot5SensorModel_h
 
#include "otbImageMetadata.h"
#include "otbSpot5Metadata.h"
#include "otbGeocentricTransform.h"
#include "otbBilinearProjection.h"
#include "otbPolygon.h"
 
 
#include "itkPoint.h"
#include <itkMatrix.h>
#include "itkVector.h"
#include <itkVersor.h>
 
namespace otb
{
 
class Spot5SensorModel
{
 
public:
 
 
  using Point2DType = itk::Point<double, 2>;
  using Point3DType = itk::Point<double, 3>;
  using MatrixType = itk::Matrix<double, 3, 3>;
  using Vector3DType = itk::Vector<double, 3>;
  using PolygonType = otb::Polygon<>;
  using ContinuousIndexType = PolygonType::ContinuousIndexType;
  using TimeType = MetaData::TimePoint;
  using DurationType = MetaData::Duration;
 
  Spot5SensorModel(const std::string & productType, const Spot5Param & Spot5Param);
 
  Spot5SensorModel(const ImageMetadata & imd);
  virtual ~Spot5SensorModel() = default;
 
  Spot5SensorModel(const Spot5SensorModel&) = delete; // non construction-copyable
  Spot5SensorModel& operator=(const Spot5SensorModel&) = delete; // non copyable
 
 
  Point2DType WorldToLineSample(const Point3DType& inGeoPoint) const;
 
  Point3DType LineSampleHeightToWorld(Point2DType imPt,
                                      double heightAboveEllipsoid) const;
 
  Point3DType LineSampleToWorld(Point2DType imPt) const;
 
  Ephemeris ImagingRay(Point2DType imPt) const;
 
  Point3DType NearestIntersection(const Ephemeris& imRay, double offset) const;
 
  Point3DType IntersectRay(const Ephemeris& imRay) const;
 
  Point3DType GetBilinearInterpolation(const double& time,
                                       const std::vector<Point3DType>& V,
                                       const std::vector<double>& T) const;
 
  Point3DType GetLagrangeInterpolation(const double& time,
                                       const std::vector<Point3DType>& V,
                                       const std::vector<double>& T) const;
 
  Point3DType GetPositionEcf(double time) const;
 
  Point3DType GetVelocityEcf(double time) const;
 
  void GetPixelLookAngleXY(unsigned int line, double& psiX, double& psiY) const;
 
  Point3DType GetAttitude(double time) const;
 
  MatrixType ComputeSatToOrbRotation(double t) const;
 
 
  void UpdateImageMetadata(ImageMetadata & imd);
 
 
protected:
 
private:
 
  void InitBilinearTransform();
 
  itk::Point<double, 3> EcefToWorld(const itk::Point<double, 3> & ecefPoint) const;
 
 
  itk::Point<double, 3> WorldToEcef(const itk::Point<double, 3> & worldPoint) const;
 
  ContinuousIndexType Point2DToIndex(const itk::Point<double, 2> point) const;
 
  ContinuousIndexType Point3DToIndex(const itk::Point<double, 3> point) const;
 
 
  virtual bool insideImage(const itk::Point<double, 2> point, double epsilon) const
  {
      return (point[0] >= -epsilon) &&
      (point[0] <= (m_Spot5Param.ImageSize[0]+epsilon-1)) &&
      (point[1] >= -epsilon) &&
      (point[1] <= (m_Spot5Param.ImageSize[1]+epsilon-1));
  }
 
  std::string m_ProductType;
  Spot5Param m_Spot5Param;
 
  // Speed of light 
  static constexpr double C = 299792458;
 
  // Bilinear transform
  BilinearProjection::Pointer m_BilinearProj;
 
  // Image and ground polygon
  PolygonType::Pointer m_ImageRect; 
  PolygonType::Pointer m_GroundRect;
 
  otb::GeocentricTransform<otb::TransformDirection::INVERSE, double>::Pointer m_EcefToWorldTransform;
  otb::GeocentricTransform<otb::TransformDirection::FORWARD, double>::Pointer m_WorldToEcefTransform;
};
 
}
 
#endif