Desktop/Daniele/Program Editing/Progetto di informatica 2/componenti/decompressore.cpp

#include "decompressore.h"
/* funzione che eleva a potenza b un intero a */
int decompressore::elevato (int a, int b)
{
if (a == 0) return 0;
int app = 1;
for (int i = 0; i < b; i++)
    app *= a;
return app;
}

/*questa funzione è necessaria per come è implementata la traduzione da
carattere a intero, infatti in certi casi i valori sono completamente
errati, definisco questa funzione per operare direttamente sui bit*/
int decompressore::traduci (char c)
{
int a = 0;
for (int i = 0; i < 8; i++)
    a = a + ((c >> (i)) & 1) * elevato(2,i);
return a;
}
//#define DEBUG true
    #if DEBUG
    #include <iostream>
    #endif
    
    #if DEBUG
    namespace dec
    {
    void preorderp (node* tree)
    {
    if (tree == 0) return;
    cout << tree -> left << ' ' << tree -> right << endl;
    preorderp (tree -> left);
    preorderp (tree -> right);
    }
    void preorder (node* tree)
    {
    if (tree == 0) return;
    cout << tree -> c << ' ' << tree -> freq << endl;
    preorder (tree -> left);
    preorder (tree -> right);
    }
    void postorder (node* tree)
    {
    if (tree == 0) return;
    postorder (tree -> left);
    postorder (tree -> right);
    cout << tree -> c << ' ' << tree -> freq << endl;
    }
    void inorder (node* tree)
    {
    if (tree == 0) return;
    inorder (tree -> left);
    cout << tree -> c << ' ' << tree -> freq << endl;
    inorder (tree -> right);
    }
    }
    #endif

decompressore::decompressore(const char file[], const char fileo[])
{
stream.open(fileo, ios::out|ios::binary);
if (!stream) throw "apertura";
    #if DEBUG
    cout << "apertura ultimata" << endl;
    system ("PAUSE");
    #endif
contatore = 8;
IOl in(file,pf,num); //pf ora punta a un array di 
                     //puntatori a frequenze (non ordinato)
    #if DEBUG
    cout << "vettorizzazione, stampo risultati" << endl;
    cout << "vettore pf:" << endl;
    for (int i = 0; i < num; i++)
        cout << pf[i]->c << ' ' << pf[i]->freq << endl;
    system ("PAUSE");
    #endif
occorrenze = new int[256];
for (int i = 0; i < 256; i++)
    occorrenze [i] = 0;
heap hp(pf,num); //costruisce lo heap dei puntatori (esso è ancora puntato da pf)
    #if DEBUG
    cout << "generazione heap completata" << endl;
    for (int i = 0; i < num; i++)
        cout << hp.v[i] -> c << ' ' << hp.v[i]->freq << endl;
    system ("PAUSE");
    #endif

int last = hp.lastn();
root = huffman (hp, last);
pun = root;
delete[] pf; //una volta che ho distrutto il contenuto di questo array
             //anche l'heap corrispondente è vuoto
pf = 0;
    #if DEBUG
    cout << "costruzione albero ultimata" << endl;
    dec::preorder (root);
    cout << "--------" << endl;
    dec::postorder (root);
    cout << "--------" << endl;
    dec::inorder (root);
    system ("PAUSE");
    #endif

buffer[0] = in.leggi(); //legge il primo numero se esiste
if (buffer[0] == -1) throw "vuoto"; //altrimenti genera l'eccezione
int p = riempibuffer(in);
if (p == -1) throw "vuoto";
    #if DEBUG
    cout << "primo riempimento eseguito con successo" << endl;
    for (int i = 0; i < 8; i++)
        cout << buffer[i] << ' ';
    cout << endl;
    #endif
traduci(in); //funzione che traduce l'intero file
    #if DEBUG
    cout << "traduzione terminata" << endl;
    #endif
delete[] occorrenze;
occorrenze = 0;
cancella (root);
pun = 0;
}

node* decompressore::huffman (heap H, int last) //il mio heap va a costruire
{                                               //l'albero di huffman
for(int i = 0; i < last; i++) 
    {
    node* t = new node;
    if (t == 0) throw "memoria";
    t->left = H.estrai();
    t->right = H.estrai();
    t->freq= t->left->freq + t->right->freq; 
    H.inserisci(t);     
    }
return H.estrai();
}

int decompressore::riempibuffer(IOl& in) //questa funzione inserisce nel buffer
                                         //dal secondo all'ultimo simbolo
{
if (contatore != 8) throw "contatore";
contatore = 0;
for (int i = 1; i < 8; i++)
    {
    int a = in.leggi();
    if (a == -1) return -1;
    buffer[i] = a;
    }
    
    #if DEBUG
    cout << "riempimento ultimato" << endl;
    for (int i = 0; i < 8; i++)
        cout << buffer[i] << ' ';
    cout << endl;
    #endif
return 1;
}

void decompressore::traduci(IOl& in) 
{
if (root -> left == 0 && root -> right == 0)
   { //nel caso avessi un solo carattere nel file
   int mem = in.leggi();
   while (mem != -1)
         {
         stream.put (root->c);
         if (++contatore == 8)
            {
            buffer[0] = mem;
            riempibuffer(in);
            mem = in.leggi();
            }
         }
   if (mem == -1)
      while (buffer[contatore++] == 1)
            stream.put (root -> c);
   return;
   }            
int mem = in.leggi(); //ogni volta mi asservo il prossimo numero, in questo modo
                      //se esso dovesse essere -1 (file terminato)
                      //posso invocare per tempo la funzione ultimo sull'ultimo+
                      //buffer completo del file
while (mem != -1)
    {   
    for (int i = 0; i < 8; i++) //ciclo che stampa il contenuto del buffer
        {
        if (contatore > 7 || contatore < 0)
            throw "contatore";
        if (buffer[contatore] == 0) pun = pun -> left;
        if (buffer[contatore] == 1) pun = pun -> right;
        contatore++;
        if (pun -> left == 0 && pun -> right == 0)
           {
           int intc = traduci (pun -> c);
           if(occorrenze[intc] == pun -> freq)
               throw "lettura";
           occorrenze[intc]++;
           stream.put(pun -> c);
           pun = root;
           }
        }
    buffer[0] = mem;
    riempibuffer(in);
    mem = in.leggi();
    }
ultimo();
return;
}

void decompressore::ultimo()
{
    #if DEBUG
    cout << "ultimo buffer" << endl;
    system ("PAUSE");
    for (int i = 0; i < 8; i++)
        cout << buffer[i] << ' ';
    cout << endl;
    #endif
for (int i = 0; i < 8; i++) //ciclo che stampa il contenuto del buffer
    {
    if (contatore > 7 || contatore < 0) throw "contatore";
    if (buffer[contatore] == 0) pun = pun -> left;
    if (buffer[contatore] == 1) pun = pun -> right;
    contatore++;
    if (pun -> left == 0 && pun -> right == 0) 
       {
       int intc = traduci (pun -> c);
       if(occorrenze[intc] == pun -> freq) //se si verifica questa con
                                               //condizione ho terminato la
                                               //traduzione e quindi esco
           return;
       occorrenze[intc]++;
       stream.put(pun -> c);
       pun = root;
       }
    }
}

void decompressore::cancella(node*& tree) //funzione di appoggio per la
                                          //distruzione dell'albero
{
if (tree==0) return;
cancella (tree ->left);
cancella (tree -> right);
delete tree;
tree = 0;
}




    

---