ContoursAnalyser.h

#pragma once

#include "Combine.h"
//schon drin: #include "CombiSystemsVector.h"
class ContourFinder;
/*
class ContoursAnalyser : public AnalysisUnit<FrontHeadModel>
    {
    protected:
        void            createAnalyser          ();
    public:
                        ContoursAnalyser        (FrontHeadModel& headModel);
                        ~ContoursAnalyser       ();
    };

*/
class FindAndFilterOperator
    {
    private:
        ContourVector   &contoursOut;
        cv::Mat         mat;
        const RoiRect   &rRoi;
        const ContourFinderPresets &presets;
    public:
                FindAndFilterOperator   (ContourVector &contoursOut_, const RoiRect &rRoi_, const ContourFinderPresets &presets_);
        void    copyMat                 (cv::Mat rMat)  { rMat.copyTo (mat); }
#ifdef _TESTEN
        void    operator                ()(ContourVecVec &foundVec, ContourVecVec &filteredVec) const;
#else
        void    operator                ()() const;
#endif
    };

class FindAndFilterHandler
    {
    private:
        DoubleContourSPtrVector &contoursOut;
        RoiRect &rRoi;
        FrontHeadModel *lpHeadModel;
        cv::Mat rMat;
        void    cutFlatContours         (DoubleContourVector &contoursOut, const DoubleContourVector &contours, const double hwRatio) const;
        void    joinContours            (ContourVector &contoursOut, const ContourVector &contours, const RoiRect &rRoi) const;
    public:
                FindAndFilterHandler    (DoubleContourSPtrVector &contoursOut_, RoiRect &rRoi_, FrontHeadModel *lpHeadModel_);
        bool    prepare                 ();
#ifdef _TESTEN
        void    operator				()(ContourVecVec &foundVec, ContourVecVec &filteredVec, ContourVector &preJoined, ContourVector &joined) const;
#else
        void    operator				()() const;
#endif
    };

class FindAndFilterAnalyser : public Analyser<FrontHeadModel>
    {
    private:
        int result;
//  nur zur visualisierung
        ContourVecVec   rightFoundVec, leftFoundVec;
        ContourVecVec   rightFilteredVec, leftFilteredVec;
    public:
                        FindAndFilterAnalyser   (FrontHeadModel& headModel);
        int             processing              (LogableLogging *lpLogger);
        bool            isQualified             ();
        int             getResult               () const    { return result; }
//  nur zur visualisierung
        ContourVecVec*  getRightFoundContours   ()          { return &rightFoundVec; }
        ContourVecVec*  getLeftFoundContours    ()          { return &leftFoundVec; }
        ContourVecVec*  getRightFilteredContours()          { return &rightFilteredVec; }
        ContourVecVec*  getLeftFilteredContours ()          { return &leftFilteredVec; }
    };

/*Im Wesentlichen Wrapper -> Einsparen?*/
class CombinationHandler
{
private:
    Rating* rating_;
    CombiSystemsVector& combiStructs;
    ContourVector&      validatedOut_;
    ContourDataVector&  contDatas;

    RoiRect             rRoi;
    //eingefuehrt wg. Bild f. Segmentierung:
    FrontHeadModel      *lpHeadModel;
    CciTransformer      *lpTransformer;
    DoubleContourSPtrVector *lpContours;
    int     runSegmentation(  const ContourDataVector&   contDatasIn)  const;
public:
    CombinationHandler (
        Rating* status,
        CombiSystemsVector& combiSystemsIn, 
        ContourVector &validatedOut,
        ContourDataVector& contDatasIn, 
        const LateralSide side,
        FrontHeadModel *lpHeadModel);
        ~CombinationHandler ();
        bool    canOperate  ();
#ifdef _TESTEN
        void    operator    ()(ContourVector &testValidated,  ContourVecVec &testCombinedContours, DoubleContourVector &potContours, DoubleContourVector &cropContours);
#else
        void    operator    ()() const;
#endif
};



class ContoursValidator : public Analyser<FrontHeadModel>
    {
    private:
        int result;
        CombiSystemsVector combiStructsL;
        CombiSystemsVector combiStructsR;
        ContourDataVector contDatasL;
        ContourDataVector contDatasR;

        void setResults(Rating& rating,
                        FrontModelIndex uppermostLensBox, 
                        FrontModelIndex lowestLensBox, 
                        FrontModelIndex leftestLensBox, 
                        FrontModelIndex rightestLensBox,
                        MarkVector& boxPoints,
                        std::vector<int>    outerStati,
                        FrontModelIndex uppermostToOuterLensBox, 
                        FrontModelIndex lowestToOuterLensBox, 
                        FrontModelIndex rightestToOuterLensBox,
                        FrontModelIndex leftestToOuterLensBox, 
                        MarkVector&     outerFramePoints//,
                        );

        void computeCombisApproximation(DoubleContourSPtrVector *lpContours, 
                            const ContourVector& validated, 
                            const CombiSystemsVector& combiStructs); 
                           //, MatrixVector* contSpline);
    public:
                        ContoursValidator       (FrontHeadModel& headModel);
        int             processing              (LogableLogging *lpLogger);
        bool            isQualified             ();
        int             getResult               () const            { return result; }

    };