executors.hpp

#ifndef SRC_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_
#define SRC_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_
 
#include <memory>
 
#include "common/pipeline/pipelines.hpp"
#include "command-line/parsing/options.hpp"
#include "common/style.hpp"
 
#include "calibrate/calibrate.hpp"
 
#include "distance/edge.hpp"
#include "distance/distance.hpp"
#include "distance/vectorize.hpp"
#include "distance/edge-filters.hpp"
 
#include "orbit/orbit.hpp"
 
namespace found {
 
class PipelineExecutor {
 public:
    virtual ~PipelineExecutor() = default;
    virtual void ExecutePipeline() = 0;
    virtual void OutputResults() = 0;
};
 
class CalibrationPipelineExecutor : public PipelineExecutor {
 public:
    explicit CalibrationPipelineExecutor(CalibrationOptions &&options,
                                         std::unique_ptr<CalibrationAlgorithm> calibrationAlgorithm);
 
    void ExecutePipeline() override;
    void OutputResults() override;
 
 private:
    const CalibrationOptions options_;
    CalibrationPipeline pipeline_;
};
 
class DistancePipelineExecutor : public PipelineExecutor {
 public:
    ~DistancePipelineExecutor();
 
    explicit DistancePipelineExecutor(DistanceOptions &&options,
                                      std::unique_ptr<EdgeDetectionAlgorithm> edgeDetectionAlgorithm,
                                      std::unique_ptr<DistanceDeterminationAlgorithm> distanceAlgorithm,
                                      std::unique_ptr<VectorGenerationAlgorithm> vectorizationAlgorithm);
 
    explicit DistancePipelineExecutor(DistanceOptions &&options,
                                      std::unique_ptr<EdgeDetectionAlgorithm> edgeDetectionAlgorithm,
                                      std::unique_ptr<EdgeFilteringAlgorithms> filters,
                                      std::unique_ptr<DistanceDeterminationAlgorithm> distanceAlgorithm,
                                      std::unique_ptr<VectorGenerationAlgorithm> vectorizationAlgorithm);
 
    void ExecutePipeline() override;
    void OutputResults() override;
 
 private:
    const DistanceOptions options_;
    DistancePipeline pipeline_;
};
 
class OrbitPipelineExecutor : public PipelineExecutor {
 public:
    explicit OrbitPipelineExecutor(OrbitOptions &&options,
                                   std::unique_ptr<OrbitPropagationAlgorithm> orbitPropagationAlgorithm);
 
    void ExecutePipeline() override;
    void OutputResults() override;
 
 private:
    const OrbitOptions options_;
    OrbitPipeline pipeline_;
};
 
}  // namespace found
 
#endif  // SRC_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_