vectorize.hpp

#ifndef SRC_DISTANCE_VECTORIZE_HPP_
#define SRC_DISTANCE_VECTORIZE_HPP_
 
#include "common/spatial/attitude-utils.hpp"
#include "common/style.hpp"
#include "common/pipeline/stages.hpp"
 
namespace found {
 
class VectorGenerationAlgorithm : public FunctionStage<PositionVector, PositionVector> {
 public:
    // Constructs this
    VectorGenerationAlgorithm() = default;
    // Destroys this
    virtual ~VectorGenerationAlgorithm() {}
};
 
class LOSTVectorGenerationAlgorithm : public VectorGenerationAlgorithm {
 public:
    explicit LOSTVectorGenerationAlgorithm(Quaternion relativeOrientation, Quaternion referenceOrientation)
        : orientation(relativeOrientation * referenceOrientation) {}
    // TODO: I feel like we should be taking the conjugate of the above multiplication here, to mirror the blow
    // constructor, because relativeOrientation == orientation * referenceOrientation^-1, but it works out for
    // some reason. I'm not really sure why though, but the test cases all pass and don't when you attempt to
    // conjugate this.
 
    explicit LOSTVectorGenerationAlgorithm(Quaternion orientation)
    : orientation(orientation.Conjugate()) {}
 
    // Destroys this
    ~LOSTVectorGenerationAlgorithm() = default;
 
    PositionVector Run(const PositionVector &x_E) override;
 
 private:
    // Fields specific to this algorithm go here, and helper methods
 
    Quaternion orientation;
};
 
class FeatureDetectionVectorGenerationAlgorithm : public VectorGenerationAlgorithm {
 public:
    FeatureDetectionVectorGenerationAlgorithm(/*Params to initialze fields for this object*/);
 
    ~FeatureDetectionVectorGenerationAlgorithm();
 
    PositionVector Run(const PositionVector &x_E) override;
 private:
    // Fields specific to this algorithm go here, and helper methods
};
 
}  // namespace found
 
#endif  // SRC_DISTANCE_VECTORIZE_HPP_