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 ) const;
 
            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_
// -----------------------------------------------------------------------------