PDA

Visualizza la versione completa : [C] Sottrazione tra caratteri


lazybone
11-05-2006, 21:48
Ho tre variabili di tipo char: a, b, c.
e so per certo che a è maggiore di b.

Se vado a fare:
c=a-b;
e poi vado a scrivere "c" su file, non sempre ottengo un file da un byte, ma a volte ottengo un file più grande. perchè?
Può sembrare una domanda stupida, ma devo fare un progetto per l'università ed è necessario che il file sia sempre di un byte...

come posso fare?
forse devo fare la sottrazione in qualche altro modo?

grazie mille.

oregon
11-05-2006, 22:05
Mostra il codice ... probabilmente scrivi il file in maniera errata ...

lazybone
12-05-2006, 07:59
Vabè, in realtà ho un po' semplificato il problema per rendere la domanda più semplice.
In realtà nel programma ho una matrice di caratteri 512x512 ed in uscita dovrei avere un file di 512x512=262.144 byte. però facendo questa operazione ottengo un file di 276.394 byte...

Queste sono le matrici più altri valori che ho dichiarato:

#define lun 512
#define lar 512
#define lMask 3
#define lunOrl lun+(lMask-1)
#define larOrl lar+(lMask-1)
unsigned char imgOrl[lunOrl][larOrl];
unsigned char Rank[lun][lar];

la prima delle quali contiene già dei valori...
Questa è la funzione che crea la seconda matrice:

void rango()
{
int i, j, x, y, z;
unsigned char mask[lMask*lMask];
unsigned char*punt = mask;

for(i=0;i<lunOrl-(lMask-1);i++)
for(j=0;j<larOrl-(lMask-1);j++) {
z=0;
for(x=i;x<i+lMask;x++)
for(y=j;y<j+lMask;y++) {
mask[z]=imgOrl[x][y];
z++;
}

punt = sort(mask);

//questa è la sottrazione in questione...
Rank[i][j]=mask[rangoMax] - mask[rangoMin];
}
}

e questa è la funzione che crea il file:

void output()
{
FILE *nuovo1;

if (!(nuovo1=fopen("Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(Rank, sizeof(unsigned char), lun*lar, nuovo1);
fclose(nuovo1);
}

Grazie mille per l'aiutio!

oregon
12-05-2006, 10:35
Ho provato la funzione di scrittura del file e crea un file delle dimensione corrette (262144).

Ai fini della creazione del file, la sottrazione non ha nulla a che vedere.

Non mi sembra di vedere errori che possano causare quello che dici. A meno che il file non venga scritto in altre parti del programma (e a parte le variabili rangoMax e rangoMin che non vedo definite ...).

lazybone
12-05-2006, 12:51
Prima di tutto grazie per l'aiuto.
Allora... il discorso è questo... io devo leggere una immagine raw da file, devo applicarle vari filtri e devo scrivere su file tutti i risultati ottenuti. sul fatto che la funzione di output funzionasse non avevo dubbi perchè questo è l'unico filtro che non funziona.
Gli altri filtri (che sono sostanzialmente uguali a questo tranne il punto dove faccio la sottrazione) sommano, dividono o ricopiano caratteri e funzionano perfettamente. Questo filtro che invece sottrae è l'unico che non funziona!!! Ora per logica credo che il bug sia per forza nella sottrazione... ora mi chiedo... c'è un altro modo per sottrarre caratteri, tipo con l'algebra booleana ad esempio? se si come si fa?
Grazie ancora per le precedenti considerazioni! :unz:

lazybone
12-05-2006, 12:53
dimenticavo... rangoMax e rangoMin sono regolarmente definite. :)

oregon
12-05-2006, 14:22
Se il problema, come hai detto, e' nelle dimensioni del file, la sottrazione (che e' corretta), ti ripeto, non c'entra nulla.

Ci sono altre parti del codice in cui scrivi su file?

P.S. Naturalmente, se il problema non e' l'errata lunghezza del file, il discorso e' un altro.

lazybone
12-05-2006, 14:51
l'unico punto in cui scrivo su file è quello che ho postato prima. non so cosa pensare...

l'intero codice se hai voglia di dargli un'occhiata è questo... tieni conto che l'unico file che esce male è quello che scrive la matrice rangeRank... tutti gli altri sono perfetti.


#include <stdio.h>

#define lun 512 //dimensione in pixel della lunghezza dell'immagine
#define lar 512 //dimensione in pixel della larghezza dell'immagine
#define lMask 3 //dimensione in pixel del lato della maschera utilizzata per il filtro
#define lunOrl lun+(lMask-1) //dimensione in pixel della lunghezza dell'immagine con l'orlatura
#define larOrl lar+(lMask-1) //dimensione in pixel della larghezza dell'immagine con l'orlatura
#define rangoMin 0 //rango minimo
#define rangoMed (lMask*lMask)/2 //rango mediano
#define rangoMax (lMask*lMask)-1 //rango massimo

//dichiarazione funzioni
void input();
void orlatura();
void rango();
unsigned char* sort(unsigned char[]);
void output();

//dichiarazione buffer vari
unsigned char img[lun][lar];
unsigned char imgOrl[lunOrl][larOrl];
unsigned char minRank[lun][lar];
unsigned char medRank[lun][lar];
unsigned char maxRank[lun][lar];
unsigned char midpointRank[lun][lar];
unsigned char rangeRank[lun][lar];
unsigned char alphaRank[lun][lar];

main()
{
input();
orlatura();
rango();
output();
}

void input()
{
//legge l'immagine raw e la inserisce in una matrice di caratteri
FILE *fi;
if (!(fi=fopen("lena.raw","r")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fread(img, sizeof(unsigned char), lun*lar, fi);
fclose(fi);
}

void orlatura()
{
//copia la matrice dell'immagine in una matrice comprensiva di orlatura

//per prima cosa inseriamo l'immagine senza orlatura al centro della matrice
//con l'orlatura
int i, j, dist;
for(i=0;i<lun;i++)
for(j=0;j<lar;j++)
imgOrl[i + lMask/2][j + lMask/2] = img[i][j];

//dopodichè assegnamo i valori ai pixel dell'orlatura
for(i=0;i<lunOrl;i++)
for(j=0;j<larOrl;j++)
{
if(j<lMask/2 && i>=lMask/2 && i<lunOrl-lMask/2)
{
dist=lMask/2-j;
imgOrl[i][j]=imgOrl[i][j+(dist*2)-1];
}
if(j>=larOrl-lMask/2 && i>=lMask/2 && i<lunOrl-lMask/2)
{
dist=j-((larOrl-lMask/2)-1);
imgOrl[i][j]=imgOrl[i][j-(dist*2)+1];
}
if(i<lMask/2 && j>=lMask/2 && j<larOrl-lMask/2)
{
dist=lMask/2-i;
imgOrl[i][j]=imgOrl[i+(dist*2)-1][j];
}
if(i>=lunOrl-lMask/2 && j>=lMask/2 && j<larOrl-lMask/2)
{
dist=i-((lunOrl-lMask/2)-1);
imgOrl[i][j]=imgOrl[i-(dist*2)+1][j];
}
if(i<lMask/2 && j<lMask/2)
{
imgOrl[i][j]=img[0][0];
}
if(i<lMask/2 && j>=larOrl-lMask/2)
{
imgOrl[i][j]=img[0][lar-1];
}
if(i>=lunOrl-lMask/2 && j>=larOrl-lMask/2)
{
imgOrl[i][j]=img[lun-1][lar-1];
}
if(i>=lunOrl-lMask/2 && j<lMask/2)
{
imgOrl[i][j]=img[lun-1][0];
}
}
}

void rango()
{
//applica il filtro utilizzando tre parametri diversi e creando tre nuove matrici
int i, j, x, y, z, n, temp;
unsigned char mask[lMask*lMask];
unsigned char*punt;

//sfogliamo l'immagine e per ogni punto carichiamo i valori della maschera
//in un vettore
for(i=0;i<lunOrl-(lMask-1);i++)
for(j=0;j<larOrl-(lMask-1);j++) {
z=0;
for(x=i;x<i+lMask;x++)
for(y=j;y<j+lMask;y++) {
mask[z]=imgOrl[x][y];
z++;
}

//richiamiamo la funzione che ordina il vettore
punt = sort(mask);

//assegnamo ai kernel il giusto valore
minRank[i][j]=mask[rangoMin];

medRank[i][j]=mask[rangoMed];

maxRank[i][j]=mask[rangoMax];

midpointRank[i][j]=(mask[rangoMax] + mask[rangoMin])/2;

temp=0;
for(n=rangoMed/2;n<=(rangoMed/2)*3;n++)
temp+=mask[n];
alphaRank[i][j]=temp/(n+1);

rangeRank[i][j]=mask[rangoMax]-mask[rangoMin];
}
}

unsigned char* sort(unsigned char mask[])
{
//ordina un vettore
int i, j, pos;
unsigned char min;
for(i=0;i<lMask*lMask-1;i++)
{
min=mask[i]; pos=i;
for(j=i+1;j<lMask*lMask;j++)
if(mask[j]<min)
{
min=mask[j];
pos=j;
}
if(pos!=i)
{
mask[pos]=mask[i];
mask[i]=min;
}
}
return(mask);
}

void output()
{
//scrive le tre matrici ottenute su sei nuovi file raw
FILE *nuovo1, *nuovo2, *nuovo3, *nuovo4, *nuovo5, *nuovo6;

if (!(nuovo1=fopen("Min Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(minRank, sizeof(unsigned char), lun*lar, nuovo1);
fclose(nuovo1);

if (!(nuovo2=fopen("Median Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(medRank, sizeof(unsigned char), lun*lar, nuovo2);
fclose(nuovo2);

if (!(nuovo3=fopen("Max Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(maxRank, sizeof(unsigned char), lun*lar, nuovo3);
fclose(nuovo3);

if (!(nuovo4=fopen("Midpoint Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(midpointRank, sizeof(unsigned char), lun*lar, nuovo4);
fclose(nuovo4);

if (!(nuovo5=fopen("Range Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(rangeRank, sizeof(unsigned char), lun*lar, nuovo5);
fclose(nuovo5);

if (!(nuovo6=fopen("Alpha Filter.raw","w")))
{
printf("Errore nell'apertura del file!");
exit(1);
}
fwrite(alphaRank, sizeof(unsigned char), lun*lar, nuovo6);
fclose(nuovo6);
}

oregon
12-05-2006, 15:31
Non riesco a vedere problemi nel codice ...

L'ho provato (ignorando l'input dato che mi manca un file di input ...) e genera tutti i file con la lunghezza corretta ...

... non so che dirti ...

Loading