Calibration.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// -----------------------------------------------------------------------------
#ifndef Calibration_H_
#define Calibration_H_
// -----------------------------------------------------------------------------
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <ostream>
//--------------------------------------------------------------------------
namespace uniset
{
// -----------------------------------------------------------------------------
class Calibration
{
    public:
        Calibration();
        Calibration( const std::string& name, const std::string& confile = "calibration.xml", size_t reserv = 50 );
        Calibration( xmlNode* node, size_t reserv = 50 );
        ~Calibration();

        typedef float TypeOfValue;

        static const TypeOfValue ValueOutOfRange;

        static const long outOfRange;

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

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

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

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

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

        inline long getLeftRaw() const noexcept
        {
            return leftRaw;
        }
        inline long getRightRaw() const noexcept
        {
            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( size_t sz );

        inline size_t getCacheSize() const
        {
            return cache.size();
        }

        void setCacheResortCycle( size_t n );
        inline size_t getCacheResotrCycle() const noexcept
        {
            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() noexcept;
                Part( const Point& pleft, const Point& pright ) noexcept;
                ~Part() {};

                bool check( const Point& p ) const noexcept;

                bool checkX( const TypeOfValue& x ) const noexcept;

                bool checkY( const TypeOfValue& y ) const noexcept;

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

                inline Point leftPoint() const noexcept
                {
                    return p_left;
                }
                inline Point rightPoint() const noexcept
                {
                    return p_right;
                }
                inline TypeOfValue getK() const noexcept
                {
                    return k;    
                }
                inline TypeOfValue left_x() const noexcept
                {
                    return p_left.x;
                }
                inline TypeOfValue left_y() const noexcept
                {
                    return p_left.y;
                }
                inline TypeOfValue right_x() const noexcept
                {
                    return p_right.x;
                }
                inline TypeOfValue right_y() const noexcept
                {
                    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
        size_t szCache;
        struct CacheInfo
        {
            CacheInfo() noexcept: val(0), raw(outOfRange), cnt(0) {}
            CacheInfo( const long r, const long v ) noexcept: val(v), raw(r), cnt(0) {}

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

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

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

                return cnt > r.cnt;
            }
        };

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