otbSarSensorModel.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 otbSarSensorModel_h
#define otbSarSensorModel_h
 
#include "otbLagrangianOrbitInterpolator.h"
#include "otbImageMetadata.h"
#include "otbSARMetadata.h"
#include "otbGeocentricTransform.h"
 
#include "itkPoint.h"
#include <string>
#include <tuple>
 
namespace otb
{
 
class SarSensorModel
{
public:
 
  /*-------------------------------[ Typedefs ]--------------------------------*/
  using Point2DType  = itk::Point<double, 2>;
  using Point3DType  = itk::Point<double, 3>;
 
  using Vector3DType = itk::Point<double, 3>;
 
  using TimeType     = MetaData::TimePoint;
  using DurationType = MetaData::Duration;
 
  using OrbitIterator = std::vector<Orbit>::const_iterator;
 
  /*-------------------------------[ Special functions ]-----------------------*/
  SarSensorModel(
      std::string          productType,
      SARParam             sarParam,
      Projection::GCPParam gcps,
      unsigned int polynomial_degree = 8);
 
  explicit SarSensorModel(const ImageMetadata & imd, unsigned int polynomial_degree = 8);
  virtual ~SarSensorModel() = default;
 
  SarSensorModel(const SarSensorModel&) = delete; // non construction-copyable
  SarSensorModel& operator=(const SarSensorModel&) = delete; // non copyable
 
  /*-------------------------------[ Result types ]----------------------------*/
  struct ZeroDopplerInfo
  {
    TimeType     azimuthTime;
    // double       rangeTime;
    Point3DType  sensorPos;
    Vector3DType sensorVel;
  };
 
  struct LineSampleYZ
  {
    Point2DType col_row;
    Point2DType yz;
  };
 
  /*-------------------------------[ Doppler related functions ]---------------*/
  void WorldToLineSample(const Point3DType& inGeoPoint,
                         Point2DType& outLineSample) const;
 
 
  void WorldToLineSampleYZ(const Point3DType& inGeoPoint, Point2DType& cr, Point2DType& yz) const;
 
  LineSampleYZ Doppler0ToLineSampleYZ(
      Point3DType const& ecefGround, ZeroDopplerInfo const& zdi, double rangeTime) const;
 
  double CalculateRangeTime(
      Point3DType const& ecefGround, Point3DType const& sensorPos) const;
 
  bool WorldToSatPositionAndVelocity(const Point3DType& inGeoPoint, Point3DType& satellitePosition, Point3DType& satelliteVelocity) const;
 
  bool LineToSatPositionAndVelocity(double line, Point3DType& satellitePosition, Point3DType& satelliteVelocity) const;
 
  bool WorldToAzimuthRangeTime(
      const Point3DType& inGeoPoint,
      TimeType & azimuthTime,
      double & rangeTime,
      Point3DType& sensorPos,
      Vector3DType& sensorVel) const;
 
  void LineSampleHeightToWorld(const Point2DType& imPt,
                               double heightAboveEllipsoid,
                               Point3DType& worldPt) const;
 
  void LineSampleToWorld(const Point2DType& imPt,
                         Point3DType& worldPt) const;
 
  TimeType ZeroDopplerTimeLookup(Point3DType const& ecefGround) const;
 
  std::tuple<TimeType, OrbitIterator, OrbitIterator>
    ZeroDopplerTimeLookupInternal(Point3DType const& ecefGround) const;
 
  ZeroDopplerInfo ZeroDopplerLookup(Point3DType const& inEcefPoint) const;
 
 
  /*-------------------------------[ Burst related functions ]-----------------*/
  bool Deburst(std::vector<std::pair<unsigned long, unsigned long>>& lines,
               std::pair<unsigned long, unsigned long>& samples,
               bool onlyValidSample = false);
 
 
  bool BurstExtraction(const unsigned int burst_index, std::pair<unsigned long,unsigned long> & lines,
      std::pair<unsigned long,unsigned long> & samples, bool allPixels = false);
 
   bool DeburstAndConcatenate(std::vector<std::pair<unsigned long,unsigned long> >& linesBursts,
            std::vector<std::pair<unsigned long,unsigned long> >& samplesBursts,
            unsigned int & linesOffset, unsigned int first_burstInd,
            bool inputWithInvalidPixels=false);
 
  bool Overlap(std::pair<unsigned long, unsigned long>& linesUp, std::pair<unsigned long, unsigned long>& linesLow,
               std::pair<unsigned long, unsigned long>& samplesUp, std::pair<unsigned long, unsigned long>& samplesLow, unsigned int burstIndUp,
               bool inputWithInvalidPixels = false);
 
   void UpdateImageMetadata(ImageMetadata & imd);
 
  static void DeburstLineToImageLine(const std::vector<std::pair<unsigned long,unsigned long> >& lines,
                                              unsigned long deburstLine,
                                              unsigned long & imageLine);
 
  static bool ImageLineToDeburstLine(const std::vector<std::pair<unsigned long,unsigned long> >& lines,
                              unsigned long imageLine,
                              unsigned long & deburstLine);
 
 
private:
  void OptimizeTimeOffsetsFromGcps();
 
  OrbitIterator searchLagrangianNeighbourhood(TimeType azimuthTime) const;
 
  std::pair<Point3DType, Vector3DType> interpolateSensorPosVel(TimeType azimuthTime) const;
 
  std::pair<Point3DType, Vector3DType> interpolateSensorPosVel(
      TimeType  azimuthTime,
      OrbitIterator itrecord1) const;
 
  double AzimuthTimeToLine(const TimeType & azimuthTime) const;
 
  double SlantRangeToGroundRange(double slantRange,
                                 const TimeType & azimuthTime) const;
 
 
  double ApplyCoordinateConversion(double in,
                                 const TimeType& azimuthTime,
                                 const std::vector<CoordinateConversionRecord> & records) const;
 
  const GCP & findClosestGCP(const Point2DType& imPt, const Projection::GCPParam & gcpParam) const;
 
  Point3DType projToSurface(const GCP & gcp,
                            const Point2DType & imPt,
                            std::function<double(double, double)> heightFunction) const;
 
  TimeType LineToAzimuthTime(double line) const;
 
  itk::Point<double, 3> EcefToWorld(const itk::Point<double, 3> & ecefPoint) const;
 
  itk::Point<double, 3> WorldToEcef(const itk::Point<double, 3> & worldPoint) const;
 
  std::string m_ProductType;
  Projection::GCPParam m_GCP;
  SARParam m_SarParam;
 
  TimeType m_FirstLineTime;
  TimeType m_LastLineTime;
 
  DurationType m_AzimuthTimeOffset;
  double m_RangeTimeOffset; // Offset in seconds
 
  // True if the input product is a ground product
  bool m_IsGrd;
 
  // Let's use a single precision for Lagrangian interpolation that is decided
  // once, when the SarSensorModel is instantiated.
  LagrangianOrbitInterpolator m_OrbitInterpolator;
  unsigned int                m_polynomial_degree;
 
  otb::GeocentricTransform<otb::TransformDirection::INVERSE, double>::Pointer m_EcefToWorldTransform;
  otb::GeocentricTransform<otb::TransformDirection::FORWARD, double>::Pointer m_WorldToEcefTransform;
};
 
}
 
#endif