CombinationsValidator.h

#pragma once


class CombinationsValidator
    {
    private:

        ContourVector           &validatedContours_;
        const ContourVector     &contours_;
        const RoiRect           &rRoi_;
        const CCITransformer    *lpTransform_;

/*      int         getVerticalMaxValue         (int fact, Contour &contour);
        int         getVerticalMinValue         (int fact, Contour &contour);
*/
        //meins:
        double  imCenter[2];//des Orig-bilds, also das Bild der Kam-Null, aequivalent: z-Achse.
        double  focalF;
        double  pixelSize;
 //??       const   size_t nrOfRoisRight;
     /*Kamera-Null im Buegelsystem:*/
        double  nullCamB[3];
        double  approxGlassCenter[3];  //Kam1-Koords  
        double  approxGlassCenterB[3];
        double  approxGlassRad;
 
        bool    getMinMaxLengthAng( std::vector<double>&  min,
                                std::vector<double>&    max,
                                std::vector<double>&  length,  const cv::Mat  angle);
        std::vector<std::vector< bool> >    combinations;
        std::vector<double>  relResiduals;
        //alt: std::vector< double>                residuals;
 //       std::vector<Mat>  coordsInSplineSpace;
        std::vector<double>  maxDists;
       std::vector<cv::Mat>  coordsInSplineSpace;
       //alt: std::vector<std::vector< double> >  appCoeffs;

//Vektor von Zeigern auf je eine! Kontur
        std::vector< cv::Vec3d >** alignedContoursVec;

//Vektor von Zeigern auf je eine! Kontur
        std::vector< cv::Vec3d >*   interpolatedContours;
//#endif
 
/*Reserve:
        int         cutStraightParts    (   std::vector< std::vector< cv::Vec3d >* >& contourPieces, const std::vector< cv::Vec3d >&  contour);
        int         cutBackForth        (   std::vector< std::vector< cv::Vec3d >*>& cutContours, const std::vector< cv::Vec3d >&  contour);
*/

        int         approxPol          (cv::Mat& coeffs,       const  std::vector< cv::Vec3d >&  halfContour);

        int         alignToClampSys     ( std::vector< cv::Vec3d >**& alignedContours
                                        , const ContourVector& contours);

        void        contour3dToCMat(        cv::Mat& xy, const std::vector<cv::Vec3d >* cont ) const;
        void        contourMToContour3d(    std::vector<cv::Vec3d >& cont , const cv::Mat* xy ) const;
        int         evalInterpolation   (    std::vector< cv::Vec3d >&  interpContour_B
                                            , const double interval[2],    const cv::Vec3d  polCoeffs);
                                          
        int         interpolationToIm   (Contour& interpContourIm, std::vector< cv::Vec3d > const interpContour_B);
                                             
       
        int         filterHorizAndVerts(    std::vector<bool>& markVec
                                        , const size_t nrAligned
                                        , std::vector< cv::Vec3d >*&  alignedContours);
        size_t getMax(std::vector< cv::Vec3d >* vec, const size_t i) const;
        std::vector< cv::Point >    F__R;
        //std::vector< cv::Point >    F__L;
        bool        constructorSubstitute ();
        void        validateApproximations();

    public:
                    CombinationsValidator       (ContourVector &validatedContours, const ContourVector &contours, const RoiRect &rRoi, const CCITransformer *lpTransform);
                    ~CombinationsValidator      ();

        void    operator        ()();

    };