PDA

Visualizza la versione completa : Creare un file BMP in C


WBNormal
14-05-2005, 03:39
Ciao. Ho studiato qualcosa riguardo alle strutture BITMAPFILEHEADER e BITMAPINFOHEADER e su come siano fatti i bmp. Io devo creare un file BMP con colori a 24 bit.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define bitForPixel 24
#define pixelsX 640
#define pixelsY 480
#define numColors 512
/*provvisoriamente usiamo 512 colori anche se 24 bit ne permettono molti di +*/

struct RGB {
unsigned char R;
unsigned char G;
unsigned char B;
};

void createShading(int*,int,int,int,int,int,int,struct RGB*);

typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef unsigned char BYTE;
typedef int LONG; /* 32-bit signed integer */

typedef struct tagBITMAPFILEHEADER {
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits;
} BMFH;

typedef struct tagBITMAPINFOHEADER {
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BMIH;

BMFH bmfh;
BMIH bmih;
struct RGB palettes[numColors];
struct RGB image[pixelsX*pixelsY];

void createShading(int *i,int r1,int g1,int b1,int r2,int g2,int b2,struct RGB *data)
{
int k;
int numColorsForShading = numColors / 4;
for(k=1; k<=numColorsForShading; k++){
data[*i].R = (r1*(numColorsForShading-k)+r2*k)/numColorsForShading;
data[*i].G = (g1*(numColorsForShading-k)+g2*k)/numColorsForShading;
data[*i].B = (b1*(numColorsForShading-k)+b2*k)/numColorsForShading;
(*i)++;
}
}

int main(){
bmih.biSize = sizeof(BMIH);
bmih.biWidth = pixelsX;
bmih.biHeight = pixelsY;
bmih.biPlanes = 1;
bmih.biBitCount = bitForPixel;
bmih.biCompression = 0L;
bmih.biSizeImage = pixelsX*pixelsY * bitForPixel/8;
bmih.biXPelsPerMeter = 0;
bmih.biYPelsPerMeter = 0;
bmih.biClrUsed = 0;
bmih.biClrImportant = 0;

bmfh.bfType = 0x4D42;
bmfh.bfOffBits = sizeof(BMFH) + sizeof(BMIH);
/*mi è stato detto di moltiplicare per 4 perchè anche se sono 24 bit devo scrivere su 32bit e l'ultimo byte è 0. Non so se devo moltiplicare per 4 pure in bmih.biSizeImage, eppure in molti sorgenti hanno utilizzato bitmapForPixel/8*/
bmfh.bfSize = bmfh.bfOffBits+ pixelsX*pixelsY * 4;
bmfh.bfReserved1 = 0;
bmfh.bfReserved2 = 0;

int Rblue = 000;
int Gblue = 000;
int Bblue = 255;
int Rred = 255;
int Gred = 000;
int Bred = 000;
int Rjellow = 255;
int Gjellow = 255;
int Bjellow = 000;
int Rcyan = 000;
int Gcyan = 255;
int Bcyan = 255;

int i = 0;

createShading(&i,Rblue,Gblue,Bblue,Rred,Gred,Bred,palettes);
createShading(&i,Rred,Gred,Bred,Rjellow,Gjellow,Bjellow,palettes) ;
createShading(&i,Rjellow,Gjellow,Bjellow,Rcyan,Gcyan,Bcyan,palett es);
createShading(&i,Rcyan,Gcyan,Bcyan,Rblue,Gblue,Bblue,palettes);
int colum, row;
int x=0; int y=0;
int color = 0;
for (colum=0; colum<pixelsX; colum++)
for (row=0; row<pixelsY; row++) { /* create shading diagonal*/
i = y*pixelsX+x;
memcpy(&image[i], &palettes[color], sizeof(struct RGB));
x++;
y++;
color++;
}
FILE *fp;
fp* fopen("file.bmp", "wb");
fwrite (void *buf, int size, int count, *fp); /*non so che mettere nei primi 3 argomenti*/
}

Volevo sapere se ce qualcosa da sistemare e assegnazioni da correggere prima di scrivere il file e vorrei sapere come scrivere questo file.

Grazie. CIAO

:))

Paulin
14-05-2005, 11:44
Cosa intendi creare un bitmap? Riprodurre/mostrare un file bitmap a schermo o generare/modificare una immagine?

Ad ogni modo il file handle della grafica incomincia sul 55esimo byte (l'header del file occupa 54 byte) il formato per il "thrue color" a 24 bit (16,8 milioni di colori) è 8:8:8 cioè 8 byte (una word) per il rosso, 8 byte per il verde e 8 byte per il blue, la quarta word é 00, omessa nel pacchetto grafico del bitmap ma andrà contata per ottenere un incremento nella posizione del pixel nella menoria grafica..


Scusa ma non è più semplice fare una scrittura in assembler? te la cavi con poche righe di comando.


Ciao,

WBNormal
14-05-2005, 18:59
Realmente dovrei disegnare un Frattale ma quale sia l'immagine non ha importanza. Conta sapere che la funzione generatrice del frattale fornisce le coordinate di ogni suo punto ad ogni iterazione.
In questo programma gli faccio disegnare una semplice diagonale per non confondere troppo chi mi aiuta.

Se vedi bene il sorgente ci sono i valori:

#define bitForPixel 24
bmfh.bfSize = bmfh.bfOffBits + pixelsX*pixelsY * 4;
bmih.biSizeImage = pixelsX * pixelsY * (bitForPixel/8);

bitForPixel/8 =3, se arrotondiamo al quarto byte =4. Un documento diceva che dovevo arrotondare il valore al quarto byte. Ora non ricordo se si riferisse a biSizeImage o bfSize. Ricordo comunque che diceva di arrotondare solo UNA di quelle variabili. Riguardo all'altra non parlava di arrotondamenti.

Quindi mi chiedo quali devo arrotondare. Inoltre alcuni sorgenti assegnavano a biSizeImage il valore 0.

Ormai tutto quello che cerco sui BMP e i campi delle sue strutture google lo mostra evidenziato inquanto lo ho già visitato e letto.

Potresti fare un controllo al sorgente e dargli una sistemata magari commentando sopra le modifiche????

Nella parte finale invece ce il problema di come scrivere il file.

Poi in assembler non saprei come fare. Però inserire del codice ASM nel codice C non sarebbe male. Comunque piuttosto aiutami in C, ho la sensazione che in ASM riscontrerò più problemi. :)

Riguardo alle dimensioni delle strutture:
printf("%d\n",sizeof(BMFH));
printf("%d\n",sizeof(BMIH));
stampano i valori:
16
40
quindi non 45 come dicevi. Probabilmente ho sbagliato qualcosa.

Grazie
ciaooooooo

WBNormal
14-05-2005, 21:39
Ho settato bi.imageSize con valore 0. Dicono che va settato a zero se l'immagine non è compressa. Ho eliminato i primi typedef e ho usato gli uint. Mo non so come scrivere il file. I file in un secondo momento mi serviranno per fare una animazione.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#define pixelsX 640
#define pixelsY 480
#define numColors 512

struct RGB {
uint8_t R;
uint8_t G;
uint8_t B;
};

void createShading(int*,int,int,int,int,int,int,struct RGB*);

typedef struct tagBITMAPFILEHEADER {
uint16_t bfType;
uint32_t bfSize;
uint16_t bfReserved1;
uint16_t bfReserved2;
uint32_t bfOffBits;
} BMFH;

typedef struct tagBITMAPINFOHEADER {
uint32_t biSize;
uint32_t biWidth;
uint32_t biHeight;
uint16_t biPlanes;
uint16_t biBitCount;
uint32_t biCompression;
uint32_t biSizeImage;
uint32_t biXPelsPerMeter;
uint32_t biYPelsPerMeter;
uint32_t biClrUsed;
uint32_t biClrImportant;
} BMIH;

typedef struct tagBITMAP
{
BMFH BitmapFileHeader;
BMIH BitmapHeader;
uint8_t BitmapBits[];
} BITMAP;

BMFH bmfh;
BMIH bmih;
struct RGB palettes[numColors];
struct RGB image[pixelsX*pixelsY];

void createShading(int *i,int r1,int g1,int b1,int r2,int g2,int b2,struct RGB *data)
{
int k;
int numColorsForShading = numColors / 4;
for(k=1; k<=numColorsForShading; k++){
data[*i].R = (r1*(numColorsForShading-k)+r2*k)/numColorsForShading;
data[*i].G = (g1*(numColorsForShading-k)+g2*k)/numColorsForShading;
data[*i].B = (b1*(numColorsForShading-k)+b2*k)/numColorsForShading;
(*i)++;
}
}

int main(){
bmih.biSize = sizeof(BMIH);
bmih.biWidth = pixelsX;
bmih.biHeight = pixelsY;
bmih.biPlanes = 1;
bmih.biBitCount = 24;
bmih.biCompression = 0;
bmih.biSizeImage = 0; /* 0 for no compression*/
bmih.biXPelsPerMeter = 0;
bmih.biYPelsPerMeter = 0;
bmih.biClrUsed = 0;
bmih.biClrImportant = 0;

bmfh.bfType = 0x4D42;
bmfh.bfOffBits = sizeof(BMFH) + sizeof(BMIH);
bmfh.bfSize = bmfh.bfOffBits + pixelsX*pixelsY * 4;
bmfh.bfReserved1 = 0;
bmfh.bfReserved2 = 0;

int Rblue = 000;
int Gblue = 000;
int Bblue = 255;
int Rred = 255;
int Gred = 000;
int Bred = 000;
int Rjellow = 255;
int Gjellow = 255;
int Bjellow = 000;
int Rcyan = 000;
int Gcyan = 255;
int Bcyan = 255;

int i = 0;

createShading(&i,Rblue,Gblue,Bblue,Rred,Gred,Bred,palettes);
createShading(&i,Rred,Gred,Bred,Rjellow,Gjellow,Bjellow,palettes) ;
createShading(&i,Rjellow,Gjellow,Bjellow,Rcyan,Gcyan,Bcyan,palett es);
createShading(&i,Rcyan,Gcyan,Bcyan,Rblue,Gblue,Bblue,palettes);

int colum;
int row;
int x=0;
int y=0;
int color = 0;

for (x=0; x<=pixelsY; x++) { /* CREATE SHADING DIAGONAL*/
y=x;
i = y*pixelsX+x;
memcpy(&image[i], &palettes[color], sizeof(struct RGB));
color++;
}
printf("%d\n",sizeof(BMFH));
printf("%d\n",sizeof(BMIH));
}

WBNormal
15-05-2005, 00:55
Ho fatto un ulteriore modifica.

Il sorgente lo trovi in questo indirizzo:

http://rafb.net/paste/results/Ikajrr10.html

Johnny_Depp
15-05-2005, 13:19
l'ho ripescato tra i vecchi appunti... spero possa esserti (in qualche modo) utile



// crea da zero una bitmap 24 bit

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int multiplo4(int i)
{
while(i%4!=0)
i++;

return i;
}

unsigned long size_bmp(unsigned int w, unsigned int h)
{
unsigned long sc, tb;
sc=w*3;
sc=multiplo4(sc);
tb=(sc*h)+54;

return tb;
}

void header2s(FILE *p, unsigned char x, unsigned char y)
{
unsigned int b1, b2;

b1=x;
b2=y;

fwrite(&b1, sizeof(char), 1, p);
fwrite(&b2, sizeof(char), 1, p);
}

void header2d(FILE *p, unsigned int x)
{
unsigned int b1=0, b2=0;
unsigned int i=0;

while(i<x)
{
i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
}

fwrite(&b1, sizeof(char), 1, p);
fwrite(&b2, sizeof(char), 1, p);
}

void header4s(FILE *p, unsigned char x, unsigned char y, unsigned char z, unsigned char u)
{
fwrite(&x, sizeof(char), 1, p);
fwrite(&y, sizeof(char), 1, p);
fwrite(&z, sizeof(char), 1, p);
fwrite(&u, sizeof(char), 1, p);
}

void header4d(FILE *p, unsigned long x)
{
unsigned int b1=0, b2=0, b3=0, b4=0;
unsigned long i=0;

while(i<x)
{
i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
if(b2>255){
b2=0;
b3++;
}
if(b3>255){
b3=0;
b4++;
}
}

fwrite(&b1, sizeof(char), 1, p);
fwrite(&b2, sizeof(char), 1, p);
fwrite(&b3, sizeof(char), 1, p);
fwrite(&b4, sizeof(char), 1, p);
}

void data(FILE *p, unsigned long tb, unsigned int iw)
{
unsigned int sc=0, df=0;
unsigned int dr=0, dg=0, db=0, n=0, j=0, y=0, z=0;
unsigned long i=55;

iw=iw*3;
sc=multiplo4(iw);
df=sc-iw;

printf("Inserisci ROSSO [min.0 - max.255]: ");
scanf("%d", &dr);
printf("Inserisci VERDE [min.0 - max.255]: ");
scanf("%d", &dg);
printf("Inserisci BLU [min.0 - max.255]: ");
scanf("%d", &db);

printf("Larghezza x 3: %d\n", iw);
printf("Byte mancanti: %d\n", df);
printf("Scan-line : %d\n", sc);

printf("Sto scrivendo i dati...\n");

for(i=55; i<=tb; )
{
if(j==iw && df>0)
{
y=0;
while(y<df)
{
fwrite(&n, sizeof(char), 1, p);
i++;
y++;

}
j=0;
}
else
{
if(z==0)
fwrite(&db, sizeof(char), 1, p);
else if(z==1)
fwrite(&dg, sizeof(char), 1, p);
else if(z==2)
fwrite(&dr, sizeof(char), 1, p);

z++;
if(z>2)
z=0;

i++;
j++;
}
}
}

int main()
{
FILE *p;
unsigned char i=0, w[5]="\0", h[5]="\0", s[20]= "\0";
unsigned long iw, ih, tb, sc;

system("mode con: cols=80 lines=20");

printf("Inserisci Larghezza: ");
while((w[i]=getchar()) != '\n')
{
if(i>3)break;
i++;
}
w[i]='\0';

i=0;

printf("Inserisci Altezza : ");
while((h[i]=getchar()) != '\n')
{
if(i>3)break;
i++;
}
h[i]='\0';

iw = (long) atoi(w);
ih = (long) atoi(h);

if((iw>1600 || ih>1200) || (iw<1 || ih<1))
{
printf("Dimensione non supportata! [min.1x1 - max.1600x1200]\n");
system("pause");
return 1;
}

tb = size_bmp(iw, ih);
printf("Totale Byte da creare: %d\n", tb);

strcat(s, w);
strcat(s, "x");
strcat(s, h);
strcat(s, "b.bmp");

printf("Nome file da creare : %s\n", s);

p = fopen(s, "wb");

header2s(p, 'B', 'M'); // 1,2 2byte * intestazione Windows Bitmap 24 bit (BM)
header4d(p, tb); // 3,4,5,6 4byte * dimensione totale file BMP
header4s(p, 0, 0, 0, 0); // 7,8,9,10 4byte * riservati
header4s(p, 54, 0, 0, 0); // 11,12,13,14 4byte * lunghezza intestazione (54)
header4s(p, 40, 0, 0, 0); // 15,16,17,18 4byte * ???
header4d(p, iw); // 19,20,21,22 4byte * larghezza in pixel Bitmap
header2d(p, ih); // 23,24 2byte * altezza in pixel Bitmap
header2s(p, 0, 0); // 25,26 2byte * numero di piani
header4s(p, 1, 0, 24, 0); // 27,28,29,30 4byte * numero di bit per pixel usati
header4s(p, 0, 0, 0, 0); // 31,32,33,34 4byte * tipo di compressione
header4d(p, tb-54); // 35,36,37,38 4byte * lunghezza dei DATI della bitmap in byte (dal byte 55 in poi)
header4s(p, 0, 0, 0, 0); // 39,40,41,42 4byte * risoluzione orizzontale
header4s(p, 0, 0, 0, 0); // 43,44,45,46 4byte * risoluzione verticale
header4s(p, 0, 0, 0, 0); // 47,48,49,50 4byte * numero colori usati
header4s(p, 0, 0, 0, 0); // 51,52,53,54 4byte * numero colori importati

data(p, tb, iw); // creo la bitmap (inserendo i dati relativi al colore RGB)

fclose(p);

printf("Operazione terminata.\n");
system("pause");

return 0;
}

WBNormal
15-05-2005, 22:52
Puoi mettere qualche commento alle funzioni e specificare cosa le variabili indicano???

Alcune sono di sole due lettere. Difficili da interpretare.

Ciaoooo
:)

WBNormal
16-05-2005, 00:12
Per capire meglio il tuo sorgente sto cercando di renderlo il più minimale possibile.

Ho eliminate gli scanf, i messaggi di errore, una funzione e alcune variabilie. Continua a funzionare correttamente

Puoi provare a ridurlo all'osso????

Ora lo ho ridocco così:

http://rafb.net/paste/results/bPPfIR91.html

WBNormal
16-05-2005, 04:07
Lo ho ridotto il massimo che potevo.
Volevo eliminare le 2 funzioni header rimaste.
Non fare caso alle variabili che hanno come nomi dei numeri.
Le ho messe provvisoriamente per sostiuire senza confondermi. Poi gli do dei nomi decenti.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>


void header2d(FILE *p, unsigned int x)
{
unsigned int b1=0, b2=0;
unsigned int i=0;

while(i<x)
{
i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
}

fwrite(&b1, sizeof(char), 1, p);
fwrite(&b2, sizeof(char), 1, p);
}


void header4d(FILE *p, unsigned long x)
{
unsigned int b1=0, b2=0, b3=0, b4=0;
unsigned long i=0;

while(i<x)
{
i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
if(b2>255){
b2=0;
b3++;
}
if(b3>255){
b3=0;
b4++;
}
}

fwrite(&b1, sizeof(char), 1, p);
fwrite(&b2, sizeof(char), 1, p);
fwrite(&b3, sizeof(char), 1, p);
fwrite(&b4, sizeof(char), 1, p);
}

void data(FILE *p, unsigned long tb)
{
unsigned int dr=0, dg=0, db=0, j=0, z=0;
unsigned long i=55;

printf("Inserisci ROSSO [min.0 - max.255]: ");
scanf("%d", &dr);
printf("Inserisci VERDE [min.0 - max.255]: ");
scanf("%d", &dg);
printf("Inserisci BLU [min.0 - max.255]: ");
scanf("%d", &db);

printf("Sto scrivendo i dati...\n");

for(i=55; i<=tb; )
{
if(z==0) fwrite(&db, sizeof(char), 1, p);
else if(z==1) fwrite(&dg, sizeof(char), 1, p);
else if(z==2) fwrite(&dr, sizeof(char), 1, p);
z++;
if(z>2)
z=0;

i++; j++;
}
}


int main()
{
FILE *p;
unsigned long iw, ih, tb, sc;
uint8_t zero = 0;
uint8_t uno = 1;
uint8_t ventiquattro = 24;
uint8_t quaranta = 40;
uint8_t cinquantaquattro = 54;

iw = 640;
ih = 480;

tb = iw*ih*4+54;

p = fopen("file.bmp", "wb");

uint8_t B = 'B';
uint8_t M = 'M';

fwrite(&B, sizeof(char), 1, p);
fwrite(&M, sizeof(char), 1, p);

header4d(p, tb); // 3,4,5,6 dimensione totale file BMP

fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&cinquantaquattro, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&quaranta, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&iw, sizeof(unsigned long), 1, p);

header2d(p, ih);

fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&uno, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&ventiquattro, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);

header4d(p, tb-54); // 35-38 lunghezza BMP in byte (dal byte 55 in poi)

fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);
fwrite(&zero, sizeof(char), 1, p);

data(p, tb);//creo la bitmap (inserendo i dati relativi al colore RGB)

fclose(p);

printf("Operazione terminata.\n");
return 0;
}


Infine vorrei sapere come accendere un pixel partendo dalle sue coordinate e conoscendo i valori RGB del colore di cui voglio accenderlo.

Dopo di che ho tutto quello che miserve per fare il mio frattale.

ti ringrazio per sto sorgente. Mi sta semplificando la vita.

WBNormal
16-05-2005, 15:23
Fra gli fwrite ho sistituito un while con un for. Ma non capisco a che serva nonstante funzioni. Perchè con w ossia la larghezza non hai usato quel ciclo ????'

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

void data(FILE *p, uint32_t tb)
{
uint32_t dr=0, dg=0, db=0, j=0, z=0;
uint32_t i=55;

printf("Inserisci ROSSO [min.0 - max.255]: ");
scanf("%d", &dr);
printf("Inserisci VERDE [min.0 - max.255]: ");
scanf("%d", &dg);
printf("Inserisci BLU [min.0 - max.255]: ");
scanf("%d", &db);

printf("Sto scrivendo i dati...\n");

for(i=55; i<=tb; )
{
if(z==0) fwrite(&db, sizeof(uint8_t), 1, p);
else if(z==1) fwrite(&dg, sizeof(uint8_t), 1, p);
else if(z==2) fwrite(&dr, sizeof(uint8_t), 1, p);
z++;
if(z>2)
z=0;

i++; j++;
}
}


int main()
{
FILE *p;
uint32_t w, h, tb, sc;
uint32_t b1=0, b2=0, b3=0, b4 =0, i=0;
uint8_t zero = 0;
uint8_t uno = 1;
uint8_t ventiquattro = 24;
uint8_t quaranta = 40;
uint8_t cinquantaquattro = 54;

w = 640;
h = 480;

tb = w*h*4+54;

p = fopen("file.bmp", "wb");

uint8_t B = 'B';
uint8_t M = 'M';

fwrite(&B, sizeof(uint8_t), 1, p);
fwrite(&M, sizeof(uint8_t), 1, p);

i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
if(b2>255){
b2=0;
b3++;
}
if(b3>255){
b3=0;
b4++;
}


fwrite(&b1, sizeof(uint8_t), 1, p);
fwrite(&b2, sizeof(uint8_t), 1, p);
fwrite(&b3, sizeof(uint8_t), 1, p);
fwrite(&b4, sizeof(uint8_t), 1, p);

fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&cinquantaquattro, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&quaranta, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&w, sizeof(uint32_t), 1, p);

b1=b2=0;

for(i=0; i<h; i++,b1++)
{
if(b1>255){
b1=0;
b2++;
}
}

fwrite(&b1, sizeof(uint8_t), 1, p);
fwrite(&b2, sizeof(uint8_t), 1, p);

fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&uno, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&ventiquattro, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);

b1=b2=i=0;
i++;
b1++;

if(b1>255){
b1=0;
b2++;
}
if(b2>255){
b2=0;
b3++;
}
if(b3>255){
b3=0;
b4++;
}


fwrite(&b1, sizeof(uint8_t), 1, p);
fwrite(&b2, sizeof(uint8_t), 1, p);
fwrite(&b3, sizeof(uint8_t), 1, p);
fwrite(&b4, sizeof(uint8_t), 1, p);



fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);
fwrite(&zero, sizeof(uint8_t), 1, p);

data(p, tb);//creo la bitmap (inserendo i dati relativi al colore RGB)

fclose(p);

printf("Operazione terminata.\n");
return 0;
}

Loading