distance.hpp

#ifndef SRC_DISTANCE_DISTANCE_HPP_
#define SRC_DISTANCE_DISTANCE_HPP_
 
#include <utility>
#include <memory>
 
#include "common/style.hpp"
#include "common/pipeline/stages.hpp"
#include "common/spatial/attitude-utils.hpp"
#include "common/spatial/camera.hpp"
 
namespace found {
 
class DistanceDeterminationAlgorithm : public FunctionStage<Points, PositionVector> {
 public:
    // Constructs this
    DistanceDeterminationAlgorithm() = default;
    // Destroys this
    virtual ~DistanceDeterminationAlgorithm() {}
};
 
class SphericalDistanceDeterminationAlgorithm : public DistanceDeterminationAlgorithm {
 public:
    SphericalDistanceDeterminationAlgorithm(decimal radius, Camera &&cam) : cam_(cam), radius_(radius) {}
    ~SphericalDistanceDeterminationAlgorithm() {}
 
    PositionVector Run(const Points &p) override;
 
 protected:
    Vec3 getCenter(Vec3* spats);
 
    PreciseDecimal getRadius(Vec3* spats, Vec3 center);
 
    PreciseDecimal getDistance(PreciseDecimal r, PreciseDecimal c);
 
    Camera cam_;
 
    decimal radius_;
};
 
class IterativeSphericalDistanceDeterminationAlgorithm : public SphericalDistanceDeterminationAlgorithm {
 public:
    IterativeSphericalDistanceDeterminationAlgorithm(decimal radius,
                                                     Camera &&cam,
                                                     size_t minimumIterations,
                                                     decimal distanceRatio,
                                                     decimal discriminatorRatio,
                                                     int pdfOrder,
                                                     int radiusLossOrder);
    ~IterativeSphericalDistanceDeterminationAlgorithm() = default;
 
    PositionVector Run(const Points &p) override;
 
 private:
    decimal GenerateLoss(PositionVector &position,
                         decimal targetDistanceSq,
                         decimal targetRadiusSq,
                         std::unique_ptr<Vec3[]> &projectedPoints,
                         size_t size);
 
    void Shuffle(size_t size, size_t n, std::unique_ptr<size_t[]> &indicies);
 
    inline uint64_t Pow(uint64_t base, uint64_t power) {
        uint64_t result = 1;
        while (power > 0) {
           if (power % 2 == 1)
                 result *= base;
           base *= base;
           power /= 2;
        }
        return result;
    }
 
    size_t minimumIterations_;
    decimal distanceRatioSq_;
    decimal discriminatorRatio_;
    uint64_t pdfOrder_;
    uint64_t radiusLossOrder_;
};
 
class EllipticDistanceDeterminationAlgorithm : public DistanceDeterminationAlgorithm {
 public:
    explicit EllipticDistanceDeterminationAlgorithm(PositionVector radius);
    ~EllipticDistanceDeterminationAlgorithm();
 
    PositionVector Run(const Points &p) override;
 private:
    // Fields specific to this algorithm, and helper methods
};
 
}  // namespace found
 
#endif  // SRC_DISTANCE_DISTANCE_HPP_