features.h

Go to the documentation of this file.

#ifndef FEATURES_H
#define FEATURES_H

namespace vr
{

typedef std::vector<cv::Rect> Rects;

typedef StatusInfo FeatureStatus;

const StatusInfo fsIndeterminate = todo;    
const StatusInfo fsNegative     = fail;     
const StatusInfo fsGuessed      = guessed;  
const StatusInfo fsPositive     = good;     
const StatusInfo fsChanged      = changed;  

class Feature;

class FeatureContainer
{
friend class Feature;
protected:
    double scaleFactor_;
    FeatureContainer(double scaleFactor = 1.0);
    virtual ~FeatureContainer() {};
    virtual void centerChanged(Feature& feature) = 0;
    void getScaledImage(const cv::Mat& src, cv::Mat& dst);
public:
    double getScaleFactor() const { return scaleFactor_; };
    double getScaleFactor(ExposureArrangement arrangement) const {
        switch (arrangement) {
            case iPad_mini_3_zoom3_2:
                return 2.0;
                break;
            case iPad_mini_3_zoom4_2:
                return 2.1;
                break;
            case iPad_mini_4_zoom4_2:
                return 2.1;
                break;
            case iPad_4_front:
            case iPad_Air_front:
            case iPad_mini_3_front:
                return 1.0;
                break;
            default:
                return 1.0;
        }
    };
};



class Feature
{
friend class FeatureContainer;
    FeatureContainer* container_;
protected:
    FeatureStatus status_;
    virtual ~Feature() {};
    virtual void _setCenter(const cv::Point2f& center) = 0;
    virtual void addOffset(const cv::Point& offset) = 0;
    inline double getScaleFactor() const { return container_ ? container_->scaleFactor_ : 1.0; };

    virtual cv::Point2f getScaledCenter() const = 0;
    void setScaledCenter(const cv::Point2f& center, bool notifyContainer = true);
    inline void setContainer(FeatureContainer* container) { container_ = container; };
public:
    Feature();
    inline bool found() const { return status_ == fsPositive; };
    inline bool usable() const { return (status_ == fsPositive) || (status_ == fsGuessed); };
    bool isChanged() const { return status_ == fsChanged; };

    cv::Point2f getCenter() const { return getScaledCenter() * getScaleFactor(); };
    void setCenter(const cv::Point2f& center) { setScaledCenter(center * (1.0 / getScaleFactor()), true); };
    inline void reset() { status_ = fsIndeterminate; };
    inline FeatureStatus getStatus() const { return status_; };
    inline void setStatus(const FeatureStatus status) { status_ = status; };
};

class CircularFeature : public Feature
{
    friend class FrontalFixedMarksEvaluator;
    friend class FrontFeatures;
    friend class SideFeatures;

protected:
    cv::Point2f center_;
    float radius_;
    void _setCenter(const cv::Point2f& center) { center_ = center; };
    void addOffset(const cv::Point& offset) {
        cv::Point2f offs = offset;
        center_ += offs;
    };

    cv::Point2f getScaledCenter() const { return center_; };
    inline float getScaledRadius() const { return radius_; };
    inline void setScaledRadius(const float radius) { radius_ = radius; };
    inline void setScaledData(const cv::Point2f& center, const float radius,
        const FeatureStatus status, bool notifyContainer = true)
    {
        setScaledCenter(center, notifyContainer);
        radius_ = radius;
        status_ = status;
    }
public:
    CircularFeature();
    CircularFeature(const cv::Point2f& center, const float radius);

    inline float getRadius() const { return radius_ * getScaleFactor(); };
    inline void setData(const cv::Point2f& center, const float radius,
        const FeatureStatus status)
    {
        setScaledData(center * (1.0 / getScaleFactor()), radius / getScaleFactor(), status, true);
    }
};

class Mark : public CircularFeature
{
    MarkOrientation orientation_;
public:
    Mark();
    Mark(const cv::Point2f& center, const float radius = 0.0f,
        const MarkOrientation orientation = moInvalid);

    inline void setScaledData(const MarkImageData& data,
        const FeatureStatus status, bool notifyContainer = true)
    {
        CircularFeature::setScaledData(data.center, data.radius, status, notifyContainer);
        orientation_ = data.orientation;
    }

    MarkOrientation getOrientation() const { return orientation_; };
    inline void setOrientation(const MarkOrientation orientation) { orientation_ = orientation; };

    inline MarkImageData getData() {
        MarkImageData data;
        data.center = getCenter();
        data.radius = getRadius();
        data.orientation = getOrientation();
        return data;
    }

    inline void setData(const MarkImageData& data, const FeatureStatus status) {
        setScaledData(data, status, true);
    }
};

inline const cv::Rect scaledRect(const cv::Rect& rect, double scaleFactor) {
    return cv::Rect(rect.tl() * scaleFactor, rect.br() * scaleFactor);
}

class AreaFeature : public Feature
{
    friend class FrontFeatures;

    cv::Rect area_;
protected:
    void _setCenter(const cv::Point2f& center);
    void addOffset(const cv::Point& offset) { area_ = area_ + offset; };
    cv::Point2f getScaledCenter() const { return 0.5f * (area_.tl() + area_.br()); };
    inline const cv::Rect& getScaledArea() const { return area_; };
    inline void setScaledArea(const cv::Rect& area) { area_ = area; };
public:
    AreaFeature();
    inline const cv::Rect getArea() const { return scaledRect(area_, getScaleFactor()); };
//    inline void setArea(const cv::Rect& area) { area_ = area / getScaleFactor(); };
};

} // namespace  vr

#endif