yvachot/Projet-C-Huffman
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Yûki - Compress working

Browse source
This commit is contained in:
name 2019-12-15 20:15:55 +01:00
parent e7305b7ab8
commit c8a0b3f359
No known key found for this signature in database
GPG key ID: 03E8F3CF3183323A
7 changed files with 104 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

15
Compress.c
View file

@ -125,6 +125,21 @@ void init_codage(plex Code[], int n){
}
}
void compression(plex *Code,int n){
Bin_file *cmp;
cmp=Ouv_Bit("cmp.txt",'w');
printf("%s",(Code[0]->code)[0]);
int i;
for(i=0;i<n;i++){
char *s;
s=Code[i]->code;
while(s!='\0'){
Ec_Bit(cmp,s);
s++;
}
}
}
/*#########################################################################################################*/
/* Partie Gestion de fichiers */

30
arbre_de_codage/arbre_binaire.c
View file

@ -3,7 +3,6 @@
#include <assert.h>
#include <string.h>
#include "arbre_binaire.h"
#define DEBUG 1
arbre creer_arbre_vide (void)
{
@ -50,9 +49,8 @@ arbre creer_feuille(Elt e, int p)
bool est_feuille(arbre a)
{
if(est_arbre_vide(a)){
return 0;
}
if (est_arbre_vide(a))
return 0 ;
return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
}
@ -72,30 +70,8 @@ void free_arbre(arbre a)
}
void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]){
/*
De ce que j'ai testé, ça marche de temps en temps même en ne changeant pas le caractère recherché, je pense qu'il y a un problème avec VSCode encore une fois LOL (Yûki)
*/
/*
#ifdef DEBUG
printf("\nDEBUG ARBRE RECHERCHER : \n");
printf(" est_arbre_vide(a) : %d\n",est_arbre_vide(a));
if(!est_arbre_vide(a)){
printf(" est_feuille(a) : %d\n",(est_feuille(a)));
printf(" racine(a) : %c\n",racine(a));
printf(" c : %c\n",c);
printf(" est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
printf(" est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
printf(" S : %s\n",s);
printf("--FIN DEBUG ARBRE RECHERCHER--\n");
}
else{
printf("ARBRE VIDE\n");
}
#endif
*/
if(!est_arbre_vide(a)){
printf("Racine : %c",racine(a));
if(racine(a)==c){
if((a->fils_gauche==NULL)&&(a->fils_droit==NULL)&&(racine(a)==c)){
found[0]=1;
s[s_len]='\0';
return ;

12
arbre_de_codage/arbre_binaire.h
View file

@ -1,10 +1,10 @@
#ifndef __ARBRE_BINAIRE__
#define __ARBRE_BINAIRE__
typedef int Elt;
typedef char Elt;
typedef int bool;
struct znoeud {
char elt ;
Elt elt ;
int poids;
struct znoeud *fils_gauche;
struct znoeud *fils_droit;
@ -12,19 +12,15 @@ struct znoeud {
typedef struct znoeud noeud ;
typedef struct znoeud * arbre;
typedef struct zcode{
int lettre;
char *s;
} codage;
typedef struct zcode * code;
arbre creer_arbre_vide(void);
arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd);
arbre fils_gauche(arbre a);
arbre fils_droit(arbre a);
Elt racine(arbre a);
bool est_arbre_vide(arbre a);
arbre creer_feuille(Elt e, int p) ;
bool est_feuille(arbre a) ;
void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]);
void serialisation(arbre a,FILE *file);
#endif

45
gestion_des_fichiers/gestion_fichiers.c
View file

@ -7,9 +7,6 @@
#include <string.h>
#include "gestion_fichiers.h"
Bin_file *Ouv_Bit(char *p,char mode)
{
Bin_file *A;
@ -52,11 +49,13 @@ void Ec_Bit(Bin_file *output,char bit) // On veux u
output->i_octet=0;
output->record[output->i_record]=octet; // On va apres le for remetre i_octet a 0 puis on passe dans record la valeur du char octet pour conserver
output->i_record++; //ce que l'on veut écrire
output->nb_octets++; //On incrémente aussi i record pour passer a l'élèment suivant et nb_octets car on en a traiter un autre
output->nb_octets++;
printf("ouput : %d %d\n",output->i_record,output->nb_octets); //On incrémente aussi i record pour passer a l'élèment suivant et nb_octets car on en a traiter un autre
if(output->i_record==BLOCK_SIZE) //On vérifie ensuite que record qui sert de buffer soit plein avant d'écrire sont contenue.
{
fwrite(output->record,1,BLOCK_SIZE,output->file);
output->i_record=0; //si on éceit on reinitialise i record pour passer auxélèments suivant
printf("test\n");
fwrite(output->record,1,BLOCK_SIZE,output->file);
output->i_record=0; //si on éceit on reinitialise i record pour passer auxélèments suivant
}
}
@ -71,7 +70,7 @@ char Lec_Bit(Bin_file*input)
int i; //i est un compteur utiliser pour les boucles for
if (input->record_length==0){ // Si le buffer (record),est videon va aller chercher lesélèments du fichier
if (input->record_length==0){ // Si le buffer (record),est vide on va aller chercher lesélèments du fichier
input->record_length = fread(input->record,1,BLOCK_SIZE,input->file); //Pour cela on récupère dans record_length le nombre d'élèment de input-file et on les écrit dans record
input->i_record=0; //On réinitialise l'indice de record pour recommencerdepuis le début.
@ -113,7 +112,7 @@ int Ferm_Bit(Bin_file *fichier)
unsigned char octet,b; // On déclare deux unsigned char octet et b qui auront la même utilité que dans Ec_Bit
int nb_octets=fichier->nb_octets;
if(fichier->mode="w") // Si le fichier a été ouvert en mode écriture on va aller écrire la fin du buffer
if(fichier->mode=='w') // Si le fichier a été ouvert en mode écriture on va aller écrire la fin du buffer
{ // dans le fichier.
if(fichier->i_octet!=0) //Pour cela on répète le même principe que dans Ec_Bit
{
@ -140,32 +139,4 @@ int Ferm_Bit(Bin_file *fichier)
fclose(fichier->file); //On ferme ensuite le fichier et on libère l'espace occupé par le srtuct Bin_File.
free(fichier);
return nb_octets;
}
/*
void main()
{
Bin_file *p;
char s[16];
int i;
p=Ouv_Bit("test.txt",'r');
printf("%i\n",p->record_length);
for (i=0;i<16;i++){
s[i]=Lec_Bit(p);
}
for(i=0;i<16;i++){
printf("%c",s[i]);
}
Ferm_Bit(p);
p=Ouv_Bit("test.txt","w");
Ec_Bit(p,'0');
Ec_Bit(p,'1');
Ec_Bit(p,'1');
Ec_Bit(p,'0');
Ec_Bit(p,'0');
Ec_Bit(p,'1');
Ec_Bit(p,'1');
Ec_Bit(p,'0');
Ferm_Bit(p);
}
*/
}

15
gestion_des_fichiers/gestion_fichiers.h
View file

@ -3,11 +3,11 @@
*/
#ifndef __GESTION_FICHIERS__
#define __GESTION_FICHIERS__
#include <stdio.h>
#define BLOCK_SIZE 128 //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
#define BLOCK_SIZE 1 //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
struct zBin_file{
FILE *file; // Identificateur fichier
typedef struct
{
FILE *file; // Identificateur fichier
char mode; //Mode de lecture r ou w
unsigned char record[BLOCK_SIZE]; //Tampon pour lire ou écrire
int record_length; //nombre d'élèments du tampon
@ -16,16 +16,11 @@ struct zBin_file{
int i_octet; //indice dansl'octet
int nb_octets; //Nb octet lis/écrit
};
typedef struct zBin_file Bin_file;
typedef struct zBin_file pBin_file;
}Bin_file;
Bin_file *Ouv_bit(char *p,char mode);
void Ec_Bit(Bin_file *output,char bit);
char Lec_Bit(Bin_file*input);
int Ferm_Bit(Bin_file *fichier);
#endif

120
main_compress.c
View file

@ -1,17 +1,18 @@
#include <stdio.h>
#include <string.h>
#include "arbre_de_codage/arbre_binaire.c"
#include <assert.h>
#include <stdlib.h>
#include "gestion_des_fichiers/gestion_fichiers.h"
#include "main_compress.h"
#include "arbre_de_codage/arbre_binaire.h"
#define ASCII_EXT 256
// main_compress.c [nom_du_fichier_a_compresser]
int main(int argc, char **argv){
FILE *file;
const char *filename = argv[1];
const char *mode= "rb";
Bin_file *p;
char *filename = argv[1];
char mode= 'r';
// Vérification de l'existance du second argument (Nom du fichier à compresser)
printf("Argc : %d\n",argc);
if(argc != 2){
@ -19,7 +20,7 @@ int main(int argc, char **argv){
return -1;
}
// Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
else if(!(file=fopen(filename,mode))){
else if(!(p=Ouv_Bit(filename,mode))){
printf("\nErreur : Fichier %s inexistant\n",filename);
return -2;
}
@ -28,36 +29,25 @@ int main(int argc, char **argv){
printf("Tableau initialisé -1: \n");
init_tab(N,ASCII_EXT); // On initialise l'arbre avec des poids de -1
printf("Tableau get freq : \n");
frequence(N,file); // On récupère la fréquence d'apparition des lettres du fichiers
frequence(N,p->file); // On récupère la fréquence d'apparition des lettres du fichiers
printf("Tableau tri : \n");
tri_tab(N,ASCII_EXT); // On fait un tri à bulle sur ce tableau
printf("Tableau affichage : \n");
afficher_tab(N,ASCII_EXT);
arbre huff;
printf("Huffman : \n");
huff = huffman(N);
// Récupération du code de chaque charactere
printf("Code : \n");
char s[10]="";
int f[1]={0};
char search='-';
arbre_rechercher(huff,search,s,0,f);
if(f[0]==1){
printf("\nTrouve : %s\n",s);
}
else{
printf("\nPas Trouve\n");
}
plex Codage[ASCII_EXT];
rewind(file);
init_codage(Codage,ASCII_EXT);
get_lexique(file, Codage,huff);
printf("\nFIN TEST\n");
printf("Arbre :\n");
int found[1]={0};
int taille=huff->poids;
plex Codage[taille];
init_codage(Codage,taille);
printf("Lexique:\n");
get_lexique(p->file, Codage,huff);
printf("Compression %s : \n",Codage[0]->code);
compression(Codage,taille,huff);
printf("Fermeture:\n");
Ferm_Bit(p);
return 0;
}
@ -68,16 +58,6 @@ void init_tab(arbre T[], int n){
}
}
void init_codage(plex Code[], int n){
int i;
for(i=0;i<n;i++){
lex * tmp = malloc(sizeof(lex));
tmp->code=NULL;
tmp->lettre=0;
Code[i]=tmp;
}
}
void frequence(arbre T[], FILE *file){
int c;
while((c=fgetc(file))!=EOF){
@ -126,8 +106,6 @@ void afficher_tab(arbre T[], int n){
arbre huffman(arbre T[]){
// Création de l'arbre de codage de Huffman en considérant une liste avec les fréquences d'apparition des caractères ordonnée croissante
// récupérer les deux plus petits poids (cf : deux premieres occurences)
arbre H = malloc(sizeof(arbre));
H=creer_arbre_vide();
int i;
@ -151,18 +129,50 @@ arbre huffman(arbre T[]){
return T[Index];
}
void get_lexique(FILE *file, plex Code[], arbre huff){
int c_int;
char c_char;
while((c_int=fgetc(file))!=EOF){
c_char = c_int;
if(Code[c_int]->lettre!=c_char){
Code[c_int]->lettre=c_char;
char s[9]="";
int f[1]={0};
arbre_rechercher(huff,c_char,s,0,f);
printf("Code %c : %s\n",c_int,s);
Code[c_int]->code=s;
void init_codage(plex Code[], int n){
int i;
int j;
for(i=0;i<n;i++){
lex * tmp = malloc(sizeof(lex));
for(j=0;j<ASCII_EXT;j++){
tmp->code[j]=0;
}
tmp->lettre=0;
Code[i]=tmp;
}
}
void get_lexique(FILE *file, plex Code[], arbre huff){
int i;
char c_char;
rewind(file);
i=0;
char s[ASCII_EXT]="";
while((c_char=fgetc(file))!=EOF){
Code[i]->lettre=c_char;
int f[1]={0};
arbre_rechercher(huff,c_char,s,0,f);
strcpy(Code[i]->code,s);
printf("Code %c : %s\n",c_char,Code[i]->code);
i++;
}
}
void compression(plex Code[],int n, arbre H){
Bin_file* cmp;
cmp=Ouv_Bit("cmp.txt",'w');
serialisation(H,cmp->file);
fwrite("123",3,1,cmp->file);
int i;
int j;
char tmp;
for(i=0;i<n;i++){
j=0;
while(Code[i]->code[j]!='\0'){
printf(" %s %c\n",Code[i]->code,Code[i]->code[j]);
Ec_Bit(cmp,Code[i]->code[j]);
j++;
}
printf("\n");
}
}

7
main_compress.h
View file

@ -1,11 +1,12 @@
#ifndef __MAIN_COMPRESS__
#define __MAIN_COMPRESS__
#include "arbre_de_codage/arbre_binaire.h"
#include <stdio.h>
#include "arbre_de_codage/arbre_binaire.h"
#include "gestion_des_fichiers/gestion_fichiers.h"
struct lexique{
char lettre;
char *code;
char code[256];
};
typedef struct lexique lex;
typedef struct lexique* plex;
@ -15,7 +16,7 @@ void frequence(arbre T[], FILE *file);
void tri_tab(arbre T[],int n);
void afficher_tab(arbre T[], int n);
void init_tab(arbre T[], int n);
void init_codage(plex Code[], int n);
void get_lexique(FILE *file, plex Code[], arbre huff);
void init_codage(plex Code[], int n);
#endif