Compressor Class Reference

#include <Compressor.h>

Collaboration diagram for Compressor:

Public Member Functions
	Compressor ()
	~Compressor ()=default
void	setNrBits (int bits)
void	setIgnoreSign ()
void	reduceToUS (const std::vector< float > &vf, std::vector< unsigned short > &vi)
void	expandFromUStoFloat (const std::vector< unsigned short > &vi, std::vector< float > &vf)
void	reduce (const std::vector< float > &vf, std::vector< unsigned int > &vi)
void	expandToFloat (const std::vector< unsigned int > &vc, std::vector< float > &vf)

Private Attributes
int	m_bits
bool	m_sign
bool	m_bitStrip

Detailed Description

Definition at line 26 of file Compressor.h.

Constructor & Destructor Documentation

Compressor()

Compressor::Compressor ( )

inline

Definition at line 29 of file Compressor.h.

                {
        m_sign=false;
        m_bits=16;
                m_bitStrip = false;
    }

~Compressor()

Compressor::~Compressor ( )

default

Member Function Documentation

expandFromUStoFloat()

void Compressor::expandFromUStoFloat	(	const std::vector< unsigned short > &	vi,
		std::vector< float > &	vf )

Definition at line 29 of file Compressor.cxx.

                                                                                             {
    vf.reserve(vc.size());
    for (const auto& value : vc){
        unsigned int u(value << 16);
        vf.push_back(std::bit_cast<float>(u));
    }
}

expandToFloat()

void Compressor::expandToFloat	(	const std::vector< unsigned int > &	vc,
		std::vector< float > &	vf )

Definition at line 106 of file Compressor.cxx.

                                                                                       {
        vf.clear();
        if (vi.empty())
          return;
 
        std::vector<unsigned int>::const_iterator i=vi.begin();
 
        int format=(*i); ++i;
        m_sign= 1 & format;
//      if (m_sign) cout<<"Sign was neglected"<<endl;
        format=format>>1;
        m_bits= 63 & format; 
//      cout<<"Uncompressing "<<m_bits<<" bits!"<<endl;
        unsigned int vecs=(format>>6)&0xfffffff;
//      cout<<"vec size: "<<vecs<<endl;
        int bshift=32-m_bits;
 
        vf.reserve(vi.size()*m_bits/16+17); //this is roughly. can be made precisse. depends on sign stripping too.
 
        int L;
        if (m_sign) L=m_bits-1; else L=m_bits;  
        int CP=0; int FP=0; int REM=0;
        unsigned int V=0xffffffff>>(32-L); unsigned int R=0;
        unsigned int ui(*i);
 
 
        while (vecs){
                FP = CP + L;    // Future point = Current point + lenght 
                if (FP<=32){    // all of it is inside this integer 
                        R = ( ui >> (32-FP) ) & V;
                        R <<= bshift;
                        vf.push_back(std::bit_cast<float>(R)); 
                        if (FP < 32)
                          CP=FP;
                        else {
                          CP = 0;
                          ++i;
                          ui = (*i); // take next integer
                        }
                }
                else{                   // part of the float is in the next integer
                        REM = FP - 32;  // Remainder = Future point - 32
                        R = ( ui & (0xffffffff >> CP) ) << REM; // find first part
                        ++i;
                        ui = (*i); // take next integer
                        R |=  ui >> (32-REM) ;
                        R <<= bshift;
                        if (m_sign) R &= 0x7fffffff;
                        vf.push_back(std::bit_cast<float>(R));  
                        CP = REM;       // move Current point
                }
                --vecs;
        }
        return;
}

reduce()

void Compressor::reduce	(	const std::vector< float > &	vf,
		std::vector< unsigned int > &	vi )

Definition at line 38 of file Compressor.cxx.

                                                                              {
 
    vi.reserve(vf.size()*m_bits/16+17);//this is roughly. can be made precisse. depends on sign stripping too.
    // composing format word
    unsigned int format=0;
    unsigned int vfs=vf.size();
    format |= vfs;  // writes down 25 bits of vector size
    format=format<<6; 
    format |= m_bits & 63;// six bits
    format =format<<1;
    format |= m_sign;
    vi.push_back(format);
    
    // initializing variables
    int bshift=32-m_bits;
    int rounding=0x1<<(bshift-1);
    unsigned int vmax= 0x7f7<<20;
    vmax |= 0x000fffff xor (rounding);
    unsigned int rems=0xffffffff;
    if(m_sign) 
        rems>>=(bshift+1); 
    else 
        rems>>=bshift;      
    
    if (m_bitStrip){
        int F=32; 
        int L;
        if (m_sign) L=m_bits-1; else L=m_bits;
        unsigned int CUR=0; int IN=0;
        for (const auto& value : vf){
            auto u = std::bit_cast<unsigned int>(value);
            if ( (u & 0x7fffffff) > vmax) IN=u>>bshift;
            else IN=(u+rounding)>>bshift;
            
            IN&=rems; 
            
            if (F>L){ 
                F-=L;
                CUR|=(IN<<F);           
                }
            else if(F==L){
                F-=L;
                CUR|=(IN<<F);
                vi.push_back(CUR);
                CUR=0;F=32;
            }
            else{
                int D=L-F;
                CUR|=(IN>>D);
                vi.push_back(CUR);
                CUR=0; F=32-D;
                                // Avoid int overflow in shift.
                                IN &= (1U<<D)-1;
                CUR|=(IN<<F);
                }
        }
        vi.push_back(CUR);
        
    }
    else
        for (const auto& value : vf){
            vi.push_back(std::bit_cast<unsigned int>(value));
            }
    
    return;
}

reduceToUS()

void Compressor::reduceToUS	(	const std::vector< float > &	vf,
		std::vector< unsigned short > &	vi )

Definition at line 19 of file Compressor.cxx.

                                                                                     {
    constexpr unsigned int max_short_flt = 0x7f7f7fff;
    vc.reserve(vf.size());
    for (const auto& value : vf){
        auto u = std::bit_cast<unsigned int>(value);
        if ( (u & 0x7fffffff) > max_short_flt) vc.push_back (u>>16);
        else vc.push_back((u+0x8000)>>16);
    }
}

setIgnoreSign()

void Compressor::setIgnoreSign ( )

inline

Definition at line 49 of file Compressor.h.

{m_sign=true;}

setNrBits()

void Compressor::setNrBits ( int bits )

inline

Definition at line 36 of file Compressor.h.

                            {
        m_bits=bits;
        m_bitStrip=true; // will be used to disable compression (already programmed for compressor but not decompressor.)
        if (bits<12){
            std::cout<<"WARNING -> Too large compression requested. Will leave 12 bits instead!"<<std::endl;
            m_bits=12;
        }
        else if(bits>=32 || bits==0){
            std::cout<<"WARNING -> Compression to "<<bits<<" bits is not possible. Compressing to 31 bits !"<<std::endl;
            m_bits=31;
        }
    }

Member Data Documentation

m_bits

int Compressor::m_bits

private

Definition at line 66 of file Compressor.h.

m_bitStrip

bool Compressor::m_bitStrip

private

Definition at line 68 of file Compressor.h.

m_sign

bool Compressor::m_sign

private

Definition at line 67 of file Compressor.h.

---

The documentation for this class was generated from the following files:

• Compressor.h
• Compressor.cxx