mark_evaluators.h

#ifndef VR_MARK_EVALUATORS_H
#define VR_MARK_EVALUATORS_H

namespace vr {

class MarkEvaluator
{
protected:
    MarkLocator* locator_;
    cv::Point2f offs_;
public:
    MarkEvaluator() : locator_(0), offs_() {}
    bool process(const cv::Mat& image, const int radiusMin, const int radiusMax,
        cv::Rect roi = noRect);
    virtual ~MarkEvaluator() = 0;
    virtual bool good() = 0;
    inline virtual int minCandidates() { return 1; };
};

inline MarkEvaluator::~MarkEvaluator() { }


class SingleMarkEvaluator : public MarkEvaluator
{
    Mark& mark_;
public:
    SingleMarkEvaluator(Mark& mark, MarkOrientation orientation) : MarkEvaluator(),
        mark_(mark) { mark.setOrientation(orientation); }
    bool good();
};

class FrontalMainMarksEvaluator : public MarkEvaluator
{
protected:
    Mark& right_;
    Mark& left_;
    float tiltAngleMaxTan_;
    bool checkMainMarkPairing(const MarkImageData& p, const MarkImageData& q);
public:
    FrontalMainMarksEvaluator(
        Mark& mainMarkR,
        Mark& mainMarkL);
    ~FrontalMainMarksEvaluator() {};
    bool good();
    inline int minCandidates() { return 2; };
};


class SideMarksEvaluator : public MarkEvaluator
{
    Mark& top_;
    Mark& bottom_;
    float pixelsPerMm_;
    LateralSide side_;
    bool checkPairing(
        const MarkImageData& p,
        const MarkImageData& q,
        const float angle,
        const float inclination);
    bool checkPairing(const MarkImageData& p, const MarkImageData& q);
public:
    SideMarksEvaluator(
        Mark& topMark,
        Mark& bottomMark,
        const float pixelsPerMm) : MarkEvaluator(),
        top_(topMark),
        bottom_(bottomMark),
        pixelsPerMm_(pixelsPerMm),
        side_() {}
    ~SideMarksEvaluator() {};
    bool good();
    inline int minCandidates() { return 2; };
    inline LateralSide getSide() { return side_; };
};

}

#endif // VR_MARK_EVALUATORS_H