MeasuringAttachment.h

Go to the documentation of this file.

#ifndef MEASURING_ATTACHMENT_H
#define MEASURING_ATTACHMENT_H

namespace vr
{
namespace measuringattachment
{
typedef enum
{
    INVALID = -1,
    ADULT,
    CHILD,
    CONFIGURATION
} Configuration;

static const struct {
        cv::Vec3d topLeft, bottomLeft, bottomRight, topRight;
} beam = {
            {7.5,  67.5, 0.0},
            {-7.5, 67.5, 0.0},
            {-7.5,-67.5, 0.0},
            { 7.5,-67.5, 0.0}
};

} // namespace measuringattachment

namespace matt = vr::measuringattachment;

class ConfigurationDiscriminator
{
public:
    ConfigurationDiscriminator(const cv::Mat& grayScaleImage,
        const CoordinateTransformation& t,
        const LateralSide side);
    ConfigurationDiscriminator(const cv::Mat& grayScaleImage,
        float pixelsPerMm,
        cv::Point2f& nullPos,
        cv::Point2f& markPos);
    ~ConfigurationDiscriminator();
    matt::Configuration computeResult() const;
private:
    float contrast (cv::Point2d const& point) const;

    cv::Mat const& grayScaleImage_;
    cv::Point2f nullPos_;
    cv::Point2f adultPos_;
    cv::Point2f childPos_;
    float pixelsPerMm_;
};

class SpringStrut
{
public:
    static const double contactFaceAxisDistance;
    static const double CHILD_POS_MM;
    static const double ADULT_POS_MM;
    SpringStrut() : xFfaRef_(std::numeric_limits<double>::quiet_NaN()), side_(RIGHT) {};
    SpringStrut(const LateralSide side);
    bool computeFfaMark(const Line& viewRay);
    void computeFfaRing(const Line& viewRay);
    Line getAxis() const;
    const cv::Vec3d& getLineMark();
    const cv::Vec3d& getUpperSideMark();
    double getFaceFormAngle() const;
    cv::Vec3d getFaceFormAngleRefPoint() const;
    cv::Vec3d getFaceFormAngleMark() const;
    cv::Vec3d getFaceFormAngleMark(double x, double angleDeg) const;
    double getFaceFormAngleRefX() const;
    cv::Rect getFfaRoi(const CoordinateTransformation& ct) const;
    cv::Vec3d transformFromB(const cv::Vec3d& point) const;
    cv::Vec3d transformToB(const cv::Vec3d& point) const;
    void reset();
private:
    static const double ffaMarkAxisDistance; // mm
    static const double xFfaRef;   // mm
    static const double ffaMarkContactFaceDistance;

    // Basisvektoren in B
    cv::Vec3d x, y, z;
    cv::Matx33d rotationMatrixToB;
    cv::Matx33d rotationMatrixFromB;
    cv::Matx33d rotationMatrixToB_inv;
    cv::Vec3d origin[measuringattachment::CONFIGURATION];
    cv::Vec3d ffaMark_; // Federstreben-Koordinaten!
    cv::Vec3d ffaRef_;
    double xFfaRef_;
    LateralSide side_;
};

class MeasuringAttachment
{
public:
    friend class SpringStrut;
    static const cv::Vec3d null;
    static const cv::Vec3d down;
    // Koordinaten der drei Hauptmarken im Buegelsystem.
    static const cv::Vec3d mainMarkR;
    static const cv::Vec3d mainMarkL;
    static const cv::Vec3d peakMark;
    static const double mainMarkDistance;
    static const double mainMarkPeakMarkDistance;
    static const Plane framePlane;
    static const double inclination;
    static const cv::Point3f guessedPupils[LATERAL_SIDE];

    static MeasuringAttachment& instance();
    SpringStrut& getSpringStrut(LateralSide side);
    const cv::Vec3d& getUpperSideMark(LateralSide side);
    static void computeConfiguration(const cv::Mat& image, const CoordinateTransformation& t);
    static measuringattachment::Configuration getConfiguration();
    static void setConfiguration(measuringattachment::Configuration configuration);
    static void getTransformation(const cv::Matx33d& cameraMatrix,
        cv::Point2f& right,
        cv::Point2f& left,
        cv::Point2f& peak,
        cv::Vec3d& rvec,
        cv::Vec3d& tvec,
        cv::InputArray distortionCoeffs = noDistortionCoeffs);
    static void getTransformation(CoordinateTransformation& t,
        cv::Point2f& right,
        cv::Point2f& left,
        cv::Point2f& peak);
    static cv::Vec3d getFramePlaneIntersection(const Line& line);
    static cv::Point2f getGuessedPupil(const LateralSide side,
        const CoordinateTransformation& ct);
    void reset() { getSpringStrut(_R).reset(); getSpringStrut(_L).reset(); };
private:
    MeasuringAttachment();
    static measuringattachment::Configuration configuration_;
    SpringStrut springStrut_[LATERAL_SIDE];
    static const std::vector<cv::Point3f> mainMarks;
    static measuringattachment::Configuration validConfiguration();
};

} // namespace vr

namespace matt = vr::measuringattachment;
typedef vr::MeasuringAttachment MAtt;

#endif // MEASURING_ATTACHMENT_H