aspect.h

Go to the documentation of this file.

#ifndef ASPECT_H
#define ASPECT_H

namespace vr {

template <int n> struct FramePoint {
    cv::Vec<double, n> point;
    StatusInfo statusInfo;
};

template <int n> struct Frame {
    FramePoint<n> bottom;
    FramePoint<n> nasal;
    FramePoint<n> top;
    FramePoint<n> temporal;
};

template <int n> class FrameSideView 
{
public:
    cv::Vec<double, n> top;
    cv::Vec<double, n> temporal;
    cv::Vec<double, n> bottom;
};

template <int n> struct ProgressiveCorridor
{
    cv::Vec<double, n> top;
    cv::Vec<double, n> bottom;
};

template <int n> struct FrontGeneral
{
    Frame<n>                frame[LATERAL_SIDE];
    ProgressiveCorridor<n>  progCorridor[LATERAL_SIDE];
    cv::Vec<double, n>      pupil[LATERAL_SIDE];
};

template <int n> class FrontMarks
{
public:
    cv::Vec<double, n> m_R;
    cv::Vec<double, n> m_L;
    cv::Vec<double, n> m_M;
    //  (Fassungsscheibenwinkel engl. "face form angle")
    struct FaceFormAngle {
        cv::Vec<double, n> mark;
        cv::Vec<double, n> ring;
        FaceFormAngle& operator= (const FaceFormAngle& ffa)
        {
            mark = ffa.mark;
            ring = ffa.ring;
            return *this;
        }
    } ffa[LATERAL_SIDE];
};

template <int n> struct Front1Cam : public FrontGeneral<n>, public FrontMarks<n> 
{ 
};

typedef Front1Cam<2> FrontPic2D;
typedef Front1Cam<3> FrontPic3D;

struct FrontB : public FrontGeneral<3>
{
    cv::Vec3d K[LATERAL_SIDE];
    cv::Vec3d Null_nrect_P[LATERAL_SIDE];
    cv::Vec3d Null_rect_P[LATERAL_SIDE];
    // erc = eye rotation center, Augendrehpunkt
    cv::Vec3d erc[LATERAL_SIDE];
};

struct Marks
{
    cv::Vec3d M_R;
    cv::Vec3d M_L;
    cv::Vec3d M_M;
};

struct Front3D : FrontB, Marks 
{
};

template <int n> class SidePic 
{
public:
    // Vektoren enthalten die Koordinaten auf der Bildebene
    cv::Vec<double, n> m_O;
    cv::Vec<double, n> m_U;
    //cv::Vec<double, n> ffaRing;
    FrameSideView<n> frame;
    cv::Vec<double, n> pupil;
    cv::Vec<double, n> cornealVertex; //Hornhautscheitel
};

typedef SidePic<2> SidePic2D;
typedef SidePic<3> SidePic3D;

    
struct Side3D {
    cv::Vec3d M_O;
    cv::Vec3d M_U;
    FrameSideView<3> frame;
    cv::Vec3d pupil;
};


struct SideB {
    FrameSideView<3> frame;
    cv::Vec3d pupil;
};


class Aspect {
public:
    ExposureArrangement exposureArrangement;
    cv::Vec3d O_B;
    Aspect(const PhotoParams& photoValues);
    virtual ~Aspect() {};
    cv::Vec3d imagePoint2dTo3d(const cv::Vec2d& point2D) const;
    cv::Vec2d imagePoint3dTo2d(const cv::Vec3d& point3D) const;
    cv::Vec3d transformToB(const cv::Vec3d& point) const;
    cv::Vec3d transformFromB(const cv::Vec3d& point) const;
    const cv::Matx33d& getRotationMatrixBToCam3d() const;
    vr::Line getViewRay(const cv::Vec2d& point) const;
    vr::Line getViewRay(const cv::Vec3d& point) const;
protected:
    cv::Matx33d cameraMatrix;
    cv::Matx33d R_;
    cv::Matx33d _2dTo3d;
    cv::Matx33d _3dTo2d;
    virtual cv::Matx33d get2dTo3dMatrix(const PhotoParams& photoValues) = 0;
};

static const double sign[LATERAL_SIDE] = {+1.0, -1.0};

class SideAspect : public Aspect {
public:
    SidePic2D im2D;
    SidePic3D im3D;
    Side3D S;
    SideB B;
    LateralSide side_;
    SideAspect(const PhotoParams& photoValues, const LateralSide side);
    virtual ~SideAspect() {};
    void computeRotationMatrix();
    void computeO_B();
    void transformSToB();
    void transform2Dto3D();
    void printTo(std::ofstream& rFile) const;
protected:
    cv::Matx33d get2dTo3dMatrix(const PhotoParams& photoValues);
private:
    double getRotationAngle() const;
};

class FrontAspect : public Aspect {
public:
    FrontPic2D im2D; //Bildkoords
    FrontPic3D im3D; //deren Koords im System F auf der Mattscheibe/Bildebene
    Front3D&   F;   //Rekonstruktion im System F
    FrontB     B;
    double approximateDistance;

    FrontAspect(Front3D& FIn,    //Rekonstruktion im System F
        const PhotoParams& frontValues);
    virtual ~FrontAspect() {};
    cv::Vec3d compute3D(const cv::Vec3d& p, double z);
    void compute3D(const LateralSide halfFace, const SideAspect& side);
    void transform2Dto3D(const LateralSide halfFace);
    Line transformFToB(const Line& line) const;
    void transformFToB(LateralSide d);
    void transformFToB(const bool isRightAvailable, const bool isLeftAvailable);
    int calcSys_B(const RealConstants& real, double* residuum);
    int calcSys_BfromExtern(const RealConstants& real, double* residuum, 
        const cv::Vec2d& m_R, const cv::Vec2d& m_L, const cv::Vec2d& m_M);
        
    cv::Vec2d XClampToXIm(const cv::Vec3d& XClamp) const;
    cv::Vec3d XImToXClamp(const cv::Point2d& XIm) const;
    
    double getComputedDistance() const { return computedDistance_; };
    
    void printTo(std::ofstream& rFile) const;
protected:
    cv::Matx33d get2dTo3dMatrix(const PhotoParams& photoValues);
private:
    double computedDistance_;
    void getSys_B(std::vector<float>& null_B, std::vector<float>& axis_B) const;
    void computeSpringStrutPosition(LateralSide side);
};

} // namespace vr

cv::Vec3d getCol(const cv::Matx33d& m, int i);


#endif // ASPECT_H