Combination.h

#pragma once

typedef enum {
    COMBICRIT_MORE_REL_RES,
    COMBICRIT_SMOOTHING_DEFECT
    } CombiCrit;

class Combination
{
    private:
        const   size_t nSize;
        size_t      sysSize;
        FlagVector  combination;
        ContourDataSPtr closedContourData;

        int         nCombined;
        bool        bValid;
        double      arcLength, residual, maxDist;
        double      criteria[5];
        cv::Mat     approxCoords;
    public:
        //der hier vermutlich weg:
                Combination             (const size_t nSize_);
        //ist speziell, andererseits wird es immer so laufen, dass er sinnvoll ist.
                Combination             (const FlagVector&  combination, double arcLength);
                ~Combination            ();
        bool    isEqual                 (const Combination &other) const;
        void    setValid                ()                      { bValid = true; }
        void    setInvalid              ()                      { bValid = false; }
        bool    isValid                 () const                { return bValid; }
        bool    isCombined              (size_t idx) const      { return idx < nSize && combination [idx]; }
        void    setCombined             (size_t idx)            { combination [idx] = true; }
        void    clearCombined           (size_t idx)            { combination [idx] = false; }
        int     getCombinedCounter      () const                { return nCombined; }
        void    setArcLength            (double val)            { arcLength = val; }
        void    setResidual             (double val)            { residual = val; }
        void    setSysSize              (size_t val)            { sysSize = val; }
        void    setMaxDistance          (double val)            { maxDist = val; }
        void    setCriteria             (double val, int idx)   { criteria[idx] = val; }
        double  getArcLength            () const                { return arcLength; }
        double  getResidual             () const                { return residual; }
        size_t  getSysSize              () const                { return sysSize; }
        double  getResidualPerArc       () const                { return arcLength > 0 ? residual / arcLength : 1; }
        double  getRelResidual          () const                { return sysSize   > 0 ? residual / sysSize: 1;}
        double  getMaxDistance          () const                { return maxDist; }
        double  getCriteria             ( int idx) const        { return    criteria[idx]; }
        void    getApproxCoords         (cv::Mat &mat) const    { mat = approxCoords; }
        void    setApproxCoords         (cv::Mat &mat)          { approxCoords = mat; }
        FlagVector& getCombinationVector()                      { return combination; }
        int countUsed       () ;
        ContourDataSPtr getClosedContour () { return closedContourData; };
        int     setClosedContour        (const DoubleContourSPtr cont_, const  cv::Mat &cart_c_);

    };
    
typedef std::shared_ptr<Combination> CombinationSPtr;

void combination2ClosedContour    (DoubleContour& closedContour, /*const*/ Combination& combi, const ContourDataVector  contDatas); 


bool compareMinRelResidual (CombinationSPtr combiSysA, CombinationSPtr combiSysB) ;
bool compareMinMaxDistance (CombinationSPtr combiSysA, CombinationSPtr combiSysB) ;
bool compareCriteria1 (CombinationSPtr combiSysA, CombinationSPtr combiSysB) ;
bool compareCriteria2 (CombinationSPtr combiSysA, CombinationSPtr combiSysB) ;
bool compareApproxCoordsNorm (CombinationSPtr combiSysA, CombinationSPtr combiSysB) ;