modules/saupePredictor.h

#ifndef SAUPEPREDICTOR_HEADER_
#define SAUPEPREDICTOR_HEADER_

#include "../headers.h"
#include "../kdTree.h"


class MSaupePredictor: public IStdEncPredictor {
    DECLARE_debugModule;

    DECLARE_TypeInfo( MSaupePredictor, "Saupe predictor"
    , "Predictor for standard encoder using multi-dimensional nearest neighbour search"
    , {
        label:  "Prediction chunk size",
        desc:   "The number of predicted domains in a chunk",
        type:   settingInt(1,16,64)
    }, {
        label:  "Max. predicted part",
        desc:   "The maximal part of domains predicted for a range block",
        type:   settingInt(-20,-8,0,IntLog2)
    } )

protected:
    enum Settings { ChunkSize, MaxPredPart };

    Real maxPredCoeff() { return ldexp( Real(1), settingsInt(MaxPredPart) ); }

public:
    typedef float KDReal;       
    typedef KDTree<KDReal> Tree;
protected:
//  Module's data
    std::vector<Tree*> levelTrees; 
    #ifndef NDEBUG // the stats about the domain counts predicted
    long predicted, maxpred;
    #endif

protected:
//  Construction and destruction
    #ifndef NDEBUG
    MSaupePredictor(): predicted(0), maxpred(0) {}
    #endif

    ~MSaupePredictor() { cleanUp(); }

public:
    IOneRangePredictor* newPredictor(const NewPredictorData &data);
    
    void cleanUp() {
        clearContainer(levelTrees);
        levelTrees.clear();
    }

protected:
    int getPredLevel(int /*realLevel*/) const 
        { return 2; }

    Tree* createTree(const NewPredictorData &data);

    static void refineDomain( const SummedPixels &pixMatrix, int x0, int y0
        , bool allowInversion, int realLevel, int predLevel, SReal *pixelResult );
    static void refineRange
        ( const NewPredictorData &data, int predLevel, SReal *pixelResult );


protected:
    class OneRangePredictor: public IOneRangePredictor {
        friend class MSaupePredictor;
        
        struct HeapInfo {
            int index;      
            float bestError;

            HeapInfo(int index_,float bestError_)
            : index(index_), bestError(bestError_) {}

            bool operator<(const HeapInfo &other) const
                { return bestError>other.bestError; }
        };

        class SEnormalizator {
            Real errorAccel; 
        public:
            void initialize(const NewPredictorData &data,int predLevel) {
                int shift= 2 * (predLevel - data.rangeBlock->level);
                errorAccel= ldexp( data.pixCount/data.rnDev2, shift );
                //errorAccel= data.pixCount/data.rnDev2;
            }
            Real normSE(Real error) const {
                Real result= std::ldexp( 1-sqrt(1-error*errorAccel), 1 );
                if ( isNaN(result) )
                    result= numeric_limits<Real>::infinity();
                return result;
            }
        } errorNorm; 
        
        typedef Tree::PointHeap PointHeap;
    protected:
        std::vector<PointHeap*> heaps;  
        std::vector<HeapInfo> infoHeap; 
        KDReal *points; 
        int chunkSize   
        , predsRemain   
        , heapCount;    
        bool firstChunk 
        , allowRotations
        , isRegular;    
    
    DEBUG_ONLY( public: long *predicted; )

    protected:
        OneRangePredictor( const NewPredictorData &data, int chunkSize_
            , const Tree &tree, int maxPredicts );
    public:
        Predictions& getChunk(float maxPredictedSE,Predictions &store);
        ~OneRangePredictor() {
            clearContainer(heaps);
            delete[] points;
        }
    }; // OneRangePredictor class
};

#endif // SAUPEPREDICTOR_HEADER_

---