OrbitView.h

#pragma once
 
#include "forward.h"
 
#include <isce3/core/Common.h>
#include <isce3/core/Linspace.h>
#include <isce3/core/Orbit.h>
#include <isce3/core/Vector.h>
#include <isce3/error/ErrorCode.h>
 
namespace isce3 { namespace cuda { namespace core {

class OrbitView {
public:
 
    OrbitView() = default;

    OrbitView(const Orbit &);

    CUDA_DEV
    isce3::core::OrbitInterpMethod interpMethod() const { return _interp_method; }

    CUDA_DEV
    double startTime() const { return _time[0]; }

    CUDA_DEV
    double midTime() const { return startTime() + 0.5 * (size() - 1) * spacing(); }

    CUDA_DEV
    double endTime() const { return _time[size()-1]; }

    CUDA_DEV
    double spacing() const { return _time.spacing(); }

    CUDA_DEV
    int size() const { return _time.size(); }

    CUDA_DEV
    const isce3::core::Linspace<double> & time() const { return _time; }

    CUDA_DEV
    const isce3::core::Vec3 * position() const { return _position; }

    CUDA_DEV
    const isce3::core::Vec3 * velocity() const { return _velocity; }

    CUDA_DEV
    double time(int idx) const { return _time[idx]; }

    CUDA_DEV
    const isce3::core::Vec3 & position(int idx) const { return _position[idx]; }

    CUDA_DEV
    const isce3::core::Vec3 & velocity(int idx) const { return _velocity[idx]; }

    CUDA_DEV
    isce3::error::ErrorCode
    interpolate(isce3::core::Vec3 * position,
                isce3::core::Vec3 * velocity,
                double t,
                isce3::core::OrbitInterpBorderMode border_mode = isce3::core::OrbitInterpBorderMode::Error) const;
 
private:
    const isce3::core::Linspace<double> _time;
    const isce3::core::Vec3 * _position;
    const isce3::core::Vec3 * _velocity;
    const isce3::core::OrbitInterpMethod _interp_method = isce3::core::OrbitInterpMethod::Hermite;
};
 
}}}
 
#define ISCE_CUDA_CORE_ORBITVIEW_ICC
#include "OrbitView.icc"
#undef ISCE_CUDA_CORE_ORBITVIEW_ICC