interfaces.h

#ifndef INTERFACES_HEADER_
#define INTERFACES_HEADER_

/* Forwards for interfaces */
struct IRoot;
struct IQuality2SE;
struct IColorTransformer;
struct IShapeTransformer;
struct ISquareEncoder;
struct ISquareRanges;
struct ISquareDomains;
struct IStdEncPredictor;
struct IIntCodec;

namespace MTypes {
    typedef double Real; 
    typedef float SReal; 
    
    typedef MatrixSlice<SReal> SMatrix;         
    typedef SMatrix::Const CSMatrix;            
    typedef std::vector<SMatrix> MatrixList;    

    enum DecodeAct { Clear, Iterate };          
                                                // \todo name clash, etc.

    struct PlaneBlock; // declared and described later in the file
    
    typedef SummedMatrix<Real,SReal> SummedPixels;
}
namespace NOSPACE {
    using namespace std;
    using namespace MTypes;
}



struct IRoot: public Interface<IRoot> {
    enum Mode {
        Clear,  
        Encode, 
        Decode  
    };

    static const Uint16 Magic= 65535-4063 
    , SettingsMagic= Magic^12345; 

    virtual Mode getMode() =0;
    virtual QImage toImage() =0;

    virtual bool encode
        ( const QImage &toEncode, const UpdateInfo &updateInfo=UpdateInfo::none ) =0;
    virtual void decodeAct( DecodeAct action, int count=1 ) =0;

    virtual bool toStream(std::ostream &file) =0;
    virtual bool fromStream(std::istream &file,int zoom=0) =0;

    int toFile(const char *fileName) { 
        std::ofstream file( fileName, ios_base::binary|ios_base::trunc|ios_base::out );
        if ( !toStream(file) )
            return 0;
        else
            return file.tellp();
    }
    bool fromFile(const char *fileName,int zoom=0) {
        std::ifstream file( fileName, ios_base::binary|ios_base::in );
        return fromStream(file,zoom);
    }
    
    bool allSettingsToFile(const char *fileName);
    bool allSettingsFromFile(const char *fileName);
}; // IRoot interface




struct IQuality2SE: public Interface<IQuality2SE> {
    virtual float rangeSE(float quality,int pixelCount) =0;
    void regularRangeErrors(float quality,int levelEnd,float *squareErrors);
};




struct IColorTransformer: public Interface<IColorTransformer> {
    struct PlaneSettings;
    
    struct Plane {
        mutable SMatrix pixels; 
        const PlaneSettings *settings; 
    };
    
    typedef std::vector<Plane> PlaneList;

    virtual PlaneList image2planes(const QImage &toEncode,const PlaneSettings &prototype) =0;
    virtual QImage planes2image() =0;

    virtual void writeData(std::ostream &file) =0;
    virtual PlaneList readData( std::istream &file, const PlaneSettings &prototype ) =0;
}; // IColorTransformer interface

struct IColorTransformer::PlaneSettings {
    int width           
    , height            
    , domainCountLog2   
    , zoom;             
    SReal quality;      
    IQuality2SE *moduleQ2SE;        
    const UpdateInfo &updateInfo;   
    
    PlaneSettings( int width_, int height_, int domainCountLog2_, int zoom_
    , SReal quality_=numeric_limits<SReal>::quiet_NaN()
    , IQuality2SE *moduleQ2SE_=0, const UpdateInfo &updateInfo_=UpdateInfo::none )
        : width(width_), height(height_)
        , domainCountLog2(domainCountLog2_), zoom(zoom_)
        , quality(quality_), moduleQ2SE(moduleQ2SE_), updateInfo(updateInfo_) {}
}; // PlaneSettings struct




struct IShapeTransformer: public Interface<IShapeTransformer> {
    typedef IColorTransformer::PlaneList PlaneList;

    virtual int createJobs(const PlaneList &planes) =0;
    virtual int jobCount() =0;

    virtual void jobEncode(int jobIndex) =0;
    virtual void jobDecodeAct( int jobIndex, DecodeAct action, int count=1 ) =0;

    virtual void writeSettings(std::ostream &file) =0;
    virtual void readSettings(std::istream &file) =0;

    virtual int phaseCount() =0;
    virtual void writeJobs(std::ostream &file,int phaseBegin,int phaseEnd) =0;
    virtual void readJobs(std::istream &file,int phaseBegin,int phaseEnd) =0;
    
    void writeJobs(std::ostream &file,int phaseBegin=0)
        { writeJobs( file, phaseBegin, phaseCount() ); }
    void readJobs(std::istream &file,int phaseBegin=0)
        { readJobs( file, phaseBegin, phaseCount() ); }
}; // IShapeTransformer interface




namespace MTypes {
    struct PlaneBlock: public SummedPixels {
        typedef IColorTransformer::PlaneSettings PlaneSettings;
        
        const PlaneSettings *settings; 
        ISquareRanges  *ranges; 
        ISquareDomains *domains;
        ISquareEncoder *encoder;
    
        bool isReady() const
            { return this && ranges && domains && encoder && pixels.isValid(); }
    }; // PlaneBlock struct
}


struct ISquareRanges: public Interface<ISquareRanges> {
    struct RangeNode;
    typedef std::vector<RangeNode*> RangeList;

    virtual void encode(const PlaneBlock &toEncode) =0;
    virtual const RangeList& getRangeList() const =0;

    virtual void writeSettings(std::ostream &file) =0;
    virtual void readSettings(std::istream &file) =0;

    virtual void writeData(std::ostream &file) =0;
    virtual void readData_buildRanges( std::istream &file, const PlaneBlock &block ) =0;
}; // ISquareRanges interface

struct ISquareRanges::RangeNode: public Block {
    struct EncoderData {
        float bestSE; 
    };

    mutable EncoderData *encoderData;
    int level;

    bool isRegular() const 
        { return width()==powers[level] && height()==powers[level]; }
protected:
    RangeNode(const Block &block,int level_)
    : Block(block), encoderData(0), level(level_) {}
    
    ~RangeNode()
        { delete encoderData; }
}; // ISquareRanges::RangeNode struct




struct ISquareDomains: public Interface<ISquareDomains> {
    struct Pool;
    typedef std::vector<Pool> PoolList;

    virtual void initPools(const PlaneBlock &planeBlock) =0;
    virtual void fillPixelsInPools(PlaneBlock &planeBlock) =0;

    virtual const PoolList& getPools() const =0;
    virtual std::vector<short> getLevelDensities(int level,int stdDomCountLog2) =0;

    virtual void writeSettings(std::ostream &file) =0;
    virtual void readSettings(std::istream &file) =0;

    virtual void writeData(std::ostream &file) =0;
    virtual void readData(std::istream &file) =0;
}; // ISquareDomains interface

struct ISquareDomains::Pool: public SummedPixels {
    char type           
    , level;            
    float contrFactor;  
    
    Pool(short width_,short height_,char type_,char level_,float cFactor,short zoom)
    : type(type_), level(level_), contrFactor(cFactor)
        { setSize( lShift(width_,zoom), lShift(height_,zoom) ); }
};




struct ISquareEncoder: public Interface<ISquareEncoder> {
    typedef IColorTransformer::Plane Plane;
    typedef ISquareRanges::RangeNode RangeNode;

    struct LevelPoolInfo {
        int indexBegin  
        , density;      
    };
    typedef std::vector< std::vector<LevelPoolInfo> > LevelPoolInfos;

    virtual void initialize( IRoot::Mode mode, PlaneBlock &planeBlock ) =0;
    virtual float findBestSE(const RangeNode &range,bool allowHigherSE=false) =0;
    virtual void finishEncoding() =0;
    virtual void decodeAct( DecodeAct action, int count=1 ) =0;

    virtual void writeSettings(std::ostream &file) =0;
    virtual void readSettings(std::istream &file) =0;

    virtual int phaseCount() const =0;
    virtual void writeData(std::ostream &file,int phase) =0;
    virtual void readData(std::istream &file,int phase) =0;
}; // ISquareEncoder interface




struct IStdEncPredictor: public Interface<IStdEncPredictor> {
    struct Prediction {
        explicit Prediction( int domainID_=-1, char rotation_=-1 )
        : domainID(domainID_), rotation(rotation_) {}

        int domainID;   
        char rotation;  
    };
    typedef std::vector<Prediction> Predictions;

    struct IOneRangePredictor {
        virtual ~IOneRangePredictor() {}
        virtual Predictions& getChunk(float maxPredictedSE,Predictions &store) =0;
    };

    struct NewPredictorData;

    virtual IOneRangePredictor* newPredictor(const NewPredictorData &data) =0;
    virtual void cleanUp() =0;
}; // IStdEncPredictor interface

struct IStdEncPredictor::NewPredictorData {
    const ISquareRanges::RangeNode *rangeBlock; 
    const SummedPixels *rangePixels;            
    const ISquareDomains::PoolList *pools;      
    const ISquareEncoder::LevelPoolInfos::value_type *poolInfos;

    bool allowRotations 
    , quantError        
    , allowInversion    
    , isRegular;        

    Real maxLinCoeff2   
    , bigScaleCoeff;    

    Real rSum   
    , r2Sum     
    , pixCount  
    , rnDev2    
    , rnDev     
    , qrAvg     
    , qrDev     
    , qrDev2;   
    #ifndef NDEBUG
    NewPredictorData()
    : rangeBlock(0), rangePixels(), pools(0), poolInfos(0) {}
    #endif
}; // NewPredictorData struct




struct IIntCodec: public Interface<IIntCodec> {
    virtual void setPossibilities(int possib) =0;
    virtual void encode(std::vector<int> &data,std::ostream &file) =0;
    virtual void decode(std::istream &file,int count,std::vector<int> &data) =0;

    virtual void writeSettings(std::ostream &file) =0;
    virtual void readSettings(std::istream &file) =0;
};


#endif // INTERFACES_HEADER_

---