MeasuringHead.h

Go to the documentation of this file.

#pragma once

class MeasuringLogger;
class MeasuringMachine;

class MeasuringHead
    {
    friend class MeasuringMachine;
    protected:
        MeasuringMachine&   machine_;
        std::string         imageFileName, resultImageFileName;
        StatusInfo          imageStatusInfo, resultImageStatusInfo;

        cv::Mat             cameraMatrix_, distCoeffs_;
        int                 calibSize_[2];

        HeadModel&          headModel_;
        ClampModel&         clampModel_;

        TransformModel      transModel;
        StatusGroup         processorsStatus;
        std::vector<Processable*>   pictureProcessors;
        MeasuringLogger     *lpLogger;

        void                undistortImage                  (const ExposureArrangement exposureArrangement, cv::Mat &org, cv::Mat &cor);
        void                prepareIPad_2_zoom4             (cv::Mat &org, cv::Mat &cor);
        void                prepareScale                    (cv::Mat &org, cv::Mat &cor, double fHorz= 1., double fVert = 1.);

        void                inverseTransformClampModel      ();
        void                transformClampModel             ();

        virtual void        createPictureProcessors         () = 0;
        virtual bool        isProfile                       () const = 0;
        void                resetProcessors                 ();
        void                deleteProcessors                ();
        std::string         getLogName                      ();
        bool                isPointStatus                   (size_t idx, StatusValue status)    { return headModel_.isPointStatus ((int)idx, status); }
        void                setPointStatus                  (size_t idx, StatusValue status)    { headModel_.setPointStatus ((int)idx, status, St_Clear); }
        void                clearPointStatus                (size_t idx, StatusValue status)    { headModel_.clearPointStatus ((int)idx, status); }
        bool                mainMarksValid                  ()  { return headModel_.isMarkValid (markOR) && headModel_.isMarkValid (markOL) && headModel_.isMarkUseable (markOM); }

        bool                ImageAnalysisDone               () const;
        
        void                markDataToClamp                 (const MarkImageData &markData, SolidPoint &pt);
        void                clampDataToMark                 (const SolidPoint &pt, MarkImageData &markData);
//beide Funktionen muessen Kopien / Teilkopien machen:
        void                setPhotoParams                  (const PhotoParams& photoValues);
        void                getPhotoParams                  ( PhotoParams& vals);
        void                correctImage                (const ExposureArrangement exposureArrangement);


    public:
                            MeasuringHead                   (MeasuringMachine& machine, HeadModel& headModel, ClampModel& clampModel);
                            ~MeasuringHead                  ();
        void                setImageValues                  (const std::string& fileName, const StatusInfo statusInfo);
        void                setOpticalAxis                  (const double axis [2]);
        void                getOpticalAxis                  (double axis [2]);
        StatusInfo          getImageStatusInfo              () const;
        void                setResultValues                 (const std::string& fileName, const StatusInfo statusInfo);
        StatusInfo          getResultStatusInfo             () const;
        void                setPercentageMarkMargins        (const int margins [4]);
        void                setTransformation               (const int imageSize [2], const int cutOffset [2], const double pivot[2], const double angle);
        void                getTransformation               (int imageSize [2], int cutOffset [2], double pivot[2], double &angle);

        void                setMeasuringLogger              (MeasuringLogger *lpLogger)         { this->lpLogger = lpLogger; }

        double              getPlanarNorm                   (int markIdxA, int markIdxB)        { return clampModel_.getPlanarNorm (markIdxA, markIdxB); }

        bool                isPointValid                    (const size_t idx)                  { return isPointStatus (idx, St_Valid); }
        void                setPointValid                   (const size_t idx)                  { setPointStatus (idx, St_Valid); }
        void                setPointInValid                 (const size_t idx)                  { clearPointStatus (idx, St_Valid); }
    
        virtual void        postAnalyse                     () = 0;

        virtual void        analyseImage                    ();
        bool                readImageFile                   (const ExposureArrangement exposureArrangement);
        virtual void        handleCorrection                (const ExposureArrangement exposureArrangement);
        TransformModel&     getTransModel                   ()  { return transModel; }
    };


class FrontMeasuringHead : public MeasuringHead
    {
    friend class MeasuringMachine;
    private:
        FrontHeadModel      frontHeadModel_;
        double              bevelsOfTheLens [2];
        double              glassThickness;

        void                setBevelsOfTheLens              (const double distances[2]);
        void                getBevelsOfTheLens              (double distances[2])   const;
        void                setGlassThickness               (const double glassThickness);
        double              getGlassThickness               ();
        void                deduceValuesFromFrame           ();//calculateBevelsOfTheLens       ();

    protected:
        virtual void        createPictureProcessors ();
        virtual bool        isProfile                       () const { return false; };
        void                getRealConstants                (RealConstants& real);
        void                setEngineRealConstants          (const RealConstants& real);
    public:
                            FrontMeasuringHead              (MeasuringMachine& machine, ClampModel& clampModel);
        //bool              isCoordinateFound               (const size_t idx);
        virtual void        postAnalyse                     ();
        const vr::FrontFeaturesSPtr& getFeatures            () const { return frontHeadModel_.getFrontFeatures(); };
    };

class SideMeasuringHead : public MeasuringHead
    {
    protected:
        SideHeadModel       sideHeadModel_;
        FrontMeasuringHead& frontHead_;
        virtual void        createPictureProcessors         ();
        virtual bool        isProfile                       () const { return true; };
    public:
                            SideMeasuringHead               (MeasuringMachine& machine, LateralSide side, ClampModel& clampModel, FrontMeasuringHead& frontHead);
        void                analyseImage                    ();
        void                postAnalyse                     ();
        void                calculateSideBox                (double fScale, double vertIris, double frameThickness);
        void                handleCorrection                (const ExposureArrangement exposureArrangement);

    };