Calibration.h

#ifndef Calibration_H_
#define Calibration_H_
// -----------------------------------------------------------------------------
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <ostream>
// -----------------------------------------------------------------------------
class Calibration
{
    public:
        Calibration();
        Calibration( const std::string& name, const std::string& confile="calibration.xml" );
        Calibration( xmlNode* node );
        ~Calibration();

        typedef float TypeOfValue;

        static const long outOfRange;

        long getValue( long raw, bool crop_raw=false );

        inline long getMinValue(){ return minVal; }
        inline long getMaxValue(){ return maxVal; }

        inline long getLeftValue(){ return leftVal; }
        inline long getRightValue(){ return rightVal; }

        long getRawValue( long cal, bool range=false );

        inline long getMinRaw(){ return minRaw; }
        inline long getMaxRaw(){ return maxRaw; }

        inline long getLeftRaw(){ return leftRaw; }
        inline long getRightRaw(){ return rightRaw; }

        void build( const std::string& name, const std::string& confile, xmlNode* node=0  );

        inline long tRound( const TypeOfValue& val ) const
        {
            return lround(val);
        }

        void setCacheSize( unsigned int sz );
        inline unsigned int getCacheSize(){ return cache.size(); }

        void setCacheResortCycle( unsigned int n );
        inline unsigned int getCacheResotrCycle(){ return numCacheResort; }
        // ---------------------------------------------------------------

        friend std::ostream& operator<<(std::ostream& os, Calibration& c );
        friend std::ostream& operator<<(std::ostream& os, Calibration* c );

        // ---------------------------------------------------------------
        struct Point
        {
            Point():x(outOfRange),y(outOfRange){}

            Point( TypeOfValue _x, TypeOfValue _y ):
                x(_x),y(_y){}

            TypeOfValue x;
            TypeOfValue y;

            inline bool operator < ( const Point& p ) const
            {
                return ( x < p.x );
            }
        };

        class Part
        {
            public:
                Part();
                Part( const Point& pleft, const Point& pright );
                ~Part(){};

                bool check( const Point& p ) const;

                bool checkX( const TypeOfValue& x ) const;

                bool checkY( const TypeOfValue& y ) const;

                // функции могут вернуть OutOfRange
                TypeOfValue getY( const TypeOfValue& x ) const;         
                TypeOfValue getX( const TypeOfValue& y ) const;        
                TypeOfValue calcY( const TypeOfValue& x ) const;     
                TypeOfValue calcX( const TypeOfValue& y ) const;     
                inline bool operator < ( const Part& p ) const
                {
                    return (p_right < p.p_right);
                }

                inline Point leftPoint() const { return p_left; }
                inline Point rightPoint() const { return p_right; }
                inline TypeOfValue getK() const { return k; }     
                inline TypeOfValue left_x() const { return p_left.x; }
                inline TypeOfValue left_y() const { return p_left.y; }
                inline TypeOfValue right_x() const { return p_right.x; }
                inline TypeOfValue right_y() const { return p_right.y; }

            protected:
                Point p_left;     
                Point p_right;     
                TypeOfValue k;     
        };

        // список надо отсортировать по x!
        typedef std::vector<Part> PartsVec;

    protected:

        long minRaw, maxRaw, minVal, maxVal, rightVal, leftVal, rightRaw, leftRaw;

        void insertToCache( const long raw, const long val );

    private:
        PartsVec pvec;
        std::string myname;

        // Cache
        unsigned int szCache;
        struct CacheInfo
        {
             CacheInfo():val(0),raw(outOfRange),cnt(0){}
             CacheInfo( const long r, const long v ):val(v),raw(r),cnt(0){}

             long val;
             long raw;
             unsigned long cnt; // счётчик обращений

             // сортируем в порядке убывания(!) обращений
             // т.е. наиболее часто используемые (впереди)
             inline bool operator<( const CacheInfo& r ) const
             {
                 if( r.raw == outOfRange )
                    return true;

                 // неинициализированные записи, сдвигаем в конец.
                 if( raw == outOfRange )
                    return false;

                 return cnt > r.cnt;
             }
        };

        typedef std::deque<CacheInfo> ValueCache;
        ValueCache cache;
        unsigned long numCacheResort; // количество обращений, при которых происходит перестроение (сортировка) кэша..
        unsigned long numCallToCache; // текущий счётчик обращений к кэшу
};
// -----------------------------------------------------------------------------
#endif // Calibration_H_
// -----------------------------------------------------------------------------