quantizer.h

this is source code for image compression following jpeg2000 staandard

/*---------------------------------------------------------------------------*/
// Image Compression Toolbox v1.2
// written by
// Satish Kumar S
// [e-mail]
//
// Copyright 1999 Satish Kumar S
//
// Permission is granted to use this software for research purposes as
// long as this notice stays attached to this software.
/*---------------------------------------------------------------------------*/
#ifndef _QUANTIZER_H
#define _QUANTIZER_H

class UniformQuant
{
public:
    double minvalue, stepsize, invstepsize;
    int nLevels;
public:
    UniformQuant()
    {
        minvalue = stepsize = invstepsize = 0.0;
        nLevels = 0;
    }
    UniformQuant(double maxv, double minv, int nlev)
    {
        minvalue = minv;
        nLevels = nlev;
        if (nlev==1)            // only a single level??
        {
            stepsize = (maxv - minv);
            invstepsize = 0.0;
        }
        else
        {
            stepsize = (maxv - minv)/(nlev-1);
            invstepsize = 1.0/stepsize;
        }
    }
    UniformQuant(double min, double stsize)
    {
        minvalue = min;
        stepsize = stsize;
        invstepsize = 1.0/stepsize;
    }
    inline unsigned int Symbol(double value)
    {
        return ((unsigned int)((value - minvalue) * invstepsize));
    }
    inline double Value(unsigned int code)
    {
        return (minvalue + ((double)code + 0.5)*stepsize);
    }
    void WriteHeader(BitStream &bs)
    {
        bs.WriteBits(nLevels, 32);
        if (nLevels<=1)
        {
            float meanvalue = (float)(minvalue+0.5*stepsize);
            bs.WriteBits(*((unsigned int *)&meanvalue),32);
        }
        else
        {
            float minv   = (float)minvalue;
            float stsize = (float)stepsize;
            bs.WriteBits(*((unsigned int *)&minv), 32);
            bs.WriteBits(*((unsigned int *)&stsize), 32);
        }
    }
    void ReadHeader(BitStream &bs)
    {
        nLevels = bs.ReadBits(32);
        if (nLevels==1)
        {
            unsigned int tmeanv = bs.ReadBits(32);
            minvalue = *(float *)&tmeanv;
            stepsize = 0.0;
            invstepsize = 0.0;
        }
        else
        {
            unsigned int tminv = bs.ReadBits(32);
            unsigned int tsteps = bs.ReadBits(32);
            minvalue = *(float *)&tminv;
            stepsize = *(float *)&tsteps;
            invstepsize = 1.0/stepsize;
        }
    }
};

#endif