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 TypeOfValue ValueOutOfRange;

        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;

        inline std::string getName()
        {
            return myname;
        }

    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_
// -----------------------------------------------------------------------------