ContextSensitiveValidator.h

#pragma once

enum PointPairIndex
{
    oben,
    nasal,
    temporal,
    unten
};

int faceIdxToEyeIdx(const int faceIdx, const LateralSide side);

class ContextSensitiveValidator //machen ersma keinen Prozessor davon,
    //denn es soll moeglich sein, Mengen von Konturen zu bewerten und nicht die
    //2 ausgewählten.
    //Notfalls wrappen wir mit einem: public Analyser<FrontHeadModel>
{
private:
    Rating& ratingR;
    Rating& ratingL;
    CombiSystemsVector& combiStructsR;
    CombiSystemsVector& combiStructsL;
    const ContourDataVector& contDatasR;
    const ContourDataVector& contDatasL;
    MarkVector& boxPtsR;
    MarkVector& boxPtsL;
    cv::Vec2d ptOnSymmAxisO;
    cv::Vec2d ptOnSymmAxisU;

    LateralSideSet result; // Sinn? Wird z.Zt. anscheinend nirgends ausgewertet...
    FrontHeadModel *lpHeadModel;
    int     compareToKnownPoints(Combination &combi, MarkVector& boxPts, const ContourDataVector& contData, const LateralSide side);
#ifdef _TESTEN
    void    applyOutVec(ContourVector &testValidated, ContourVecVec &testCombinedContours,
                        std::vector<CombinationSPtr> combiStructs, MarkVector& boxesPts, const std::vector< bool> out)
    const;
#else
    void    applyOutVec(std::vector< CombinationSPtr>& combiStructs, MarkVector& boxesPts,  const std::vector< bool> out) const;
#endif
    int     removeImplausiblePoints(std::vector< bool>& out,
                MarkVector& boxesPts, const CombiSystemsVector& combiStructs,
                const ContourDataVector& contDatas, const LateralSide side);
    bool    mirrorBadPts(
                MarkVector::iterator ptsR,
                MarkVector::iterator ptsL,
                const int badPtsIdx, const LateralSide goodSide) const;
    double  distancesLR(
                std::vector<double>& dists,
                std::vector<double>& angleMeasure,
                const MarkVector::const_iterator ptsR,
                const MarkVector::const_iterator ptsL) const;
    double  distanceLR(
                const MarkVector::const_iterator  ptsR,
                const MarkVector::const_iterator  ptsL) const;
    double  calcSplineDistance(cv::Mat& rightContSpline, cv::Mat& leftContSpline);
    int     findBestOfBadOnes(
                cv::Vec2i& mappingIdx,
                //irgendwann: std::vector<int>& badPtsIdx,
                int&  badPtsIdx, const LateralSide goodSide,
                const MarkVector& boxesPtsR,
                const MarkVector& boxesPtsL) const;
    /*soll die Kombinationen paaren, deren Fassungspunkte plausibel nahe beieinander liegen:*/
    void    pairCombis(std::vector<cv::Vec2i>& mappingIdx,  const MarkVector& boxesPtsR,
                       const MarkVector& boxesPtsL);
public:
    /*Besser waere, falls ma wer n Prozessor von machen moechte, und um die Bilder konsistent zu halten:*/
    ContextSensitiveValidator(
                FrontHeadModel *lpHeadModel,
                MarkVector& boxPtsR,
                MarkVector& boxPtsL,
                Rating& ratingR,
                Rating& ratingL,
                CombiSystemsVector& combiStructsR,
                CombiSystemsVector& combiStructsL,
                const ContourDataVector& contDatasR,
                const ContourDataVector& contDatasL);
#ifdef _TESTEN
    virtual void operator()(ContourVector &testValidatedR, ContourVecVec &testCombinedContoursR,
                            ContourVector &testValidatedL, ContourVecVec &testCombinedContoursL);
#else
    virtual void operator()();
#endif
    /*        Vergleichsoperator f. Paare u. Kriterium
    */
    double  pairCrit(const cv::Vec2i& pair) const;
    bool    operator()(const cv::Vec2i& paiAr, const cv::Vec2i& pairB);
    const LateralSideSet& getResult() const
    {
        return result;
    }
};