C++ -> tablica na bmp [problem]

0

Witam,
mam tablicę wypełnioną zerami i jedynkami, np.: int tab[szer][wys] i muszę ją przerobić na plik .bmp
sposób nieistotny, mogę używać funkcji bibliotecznych
ma być łatwo i prosto
napisałam coś, tworzy plik, w hexedytorze widzę, że zapełnia danymi, ale windy twierdzą, że plik jest uszkodzony
pomocy!!! mam już mało czasu a nie mam pojęcia co robię źle :(

void bmp (int tab [][SZEROKOSC_OBRAZKA], int wys)
{
        char bfType[2] = {'B', 'M'};    // Dwa bajty zawierające znaki 'BM' oznaczające, że jest to plik BMP.
        unsigned int bfSize = 54 + (3 * SZEROKOSC_OBRAZKA * wys);    // Całkowity rozmiar pliku wyrażony w bajtach.
        unsigned short bfReserved1 = 0;    // Zarezerwowane, wymagana wartość zero.
        unsigned short bfReserved2 = 0;    // Zarezerwowane, wymagana wartość zero.
        unsigned int bfOffBits = 54;            // Przesunięcie (wyrażone w bajtach) danych obrazu (mapy bitowej) od rekordu BITMAPFILEHEADER

        unsigned int biSize = 40;        // Rozmiar rekordu BITMAPINFOHEADER wyrażony w bajtach (powinien być zawsze 40).
        unsigned int biWidth = SZEROKOSC_OBRAZKA;            //     Szerokość obrazu w pikselach
        unsigned int biHeight = wys;        //     Wysokość obrazu w pikselach
        unsigned short biPlanes = 1;        // Przyjmuje zawsze wartość 1.
        unsigned short biBitCount = 24;    // Liczba bitów na piksel (1, 4, 8, 24)
        unsigned int biCompression = 0;    //     Typ kompresji obrazu:    BI_RGB - brak kompresji
        unsigned int biSizeImage = 3 * SZEROKOSC_OBRAZKA * wys;    // Rozmiar mapy bitowej obrazu wyrażony w bajtach. Może być ustawiony na zero, jeśli typem kompresji jest BI_RGB.
        unsigned int biXPelsPerMeter = 0;// Rozdzielczość pozioma obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
        unsigned int biYPelsPerMeter = 0;//     Rozdzielczość pionowa obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
        unsigned int biClrUsed = 0;            // Liczba elementów tablicy kolorów. Wartość zero oznacza maksymalną dopuszczalną liczbę kolorów.
        unsigned int biClrImportant = 0;        //     Liczba indeksów (kolorów) w tablicy kolorów, które są wymagane do poprawnego wyświetlenia obrazu. Wartość zero oznacza, że wszystkie kolory są wymagane.


   

    FILE *plik;
    if (( plik = fopen ("frak.bmp", "wb"))  ==  NULL)
    {
        cout << "Blad otwarcia pliku do zapisu\n";
        return;
    }
    else
        cout << "\n\nOtworzylem plik do zapisu\n";



    //zapis naglowkow do pliku
    fwrite(bfType, 1, sizeof(bfType), plik);
    fwrite(reinterpret_cast<char*>(&bfSize), 1, sizeof(bfSize), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved1), 1, sizeof(bfReserved1), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved2), 1, sizeof(bfReserved2), plik);
    fwrite(reinterpret_cast<char*>(&bfOffBits), 1, sizeof(bfOffBits), plik);
    fwrite(reinterpret_cast<char*>(&biSize), 1, sizeof(biSize), plik);
    fwrite(reinterpret_cast<char*>(&biWidth), 1, sizeof(biWidth), plik);
    fwrite(reinterpret_cast<char*>(&biHeight), 1, sizeof(biHeight), plik);
    fwrite(reinterpret_cast<char*>(&biPlanes), 1, sizeof(biPlanes), plik);
    fwrite(reinterpret_cast<char*>(&biBitCount), 1, sizeof(biBitCount), plik);
    fwrite(reinterpret_cast<char*>(&biCompression), 1, sizeof(biCompression), plik);
    fwrite(reinterpret_cast<char*>(&biSizeImage), 1, sizeof(biSizeImage), plik);
    fwrite(reinterpret_cast<char*>(&biXPelsPerMeter), 1, sizeof(biXPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biYPelsPerMeter), 1, sizeof(biYPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biClrUsed), 1, sizeof(biClrUsed), plik);
    fwrite(reinterpret_cast<char*>(&biClrImportant), 1, sizeof(biClrImportant), plik);
     

    // Wskaznik typu unsigned int ktory bedzie wykorzystany jako dynamiczna tablica 3-elementowa
    // do przechowywania wartości koloru piksela
    unsigned int *kolor_pix = new unsigned int[3];

   
    for (int i = 0;  i < SZEROKOSC_OBRAZKA;  i++)
    {
        for (int j = 0;  j < SZEROKOSC_OBRAZKA;  j++)
        {
            if (tab[j][i] == 1)
            {
                for (int k = 0;  k < 3;  k++)
                    kolor_pix[k] = 255;
            }
            else
            {
                for (int k = 0;  k < 3;  k++)
                    kolor_pix[k] = 0;
            }
       
        //zapis kolejnych pikseli
        fwrite(reinterpret_cast<char*>(kolor_pix), 1, 3, plik);
        }
    //    putchar ('\n');
    }

    if( fclose( plik ) )
        cout <<  "Plik 'frak.bmp' nie zostal zamkniety\n" ;
} 
1

Ech, sugestia żebyś użył do tego struktur jest pewnie nieodpowiednia bo czas Cię goni?

  1. Spróbuj pobawić się tym - http://www.flounder.com/bitmapinfo2.htm - albo czymś podobnym i zobacz gdzie jest błąd.

  2. Wyślij jakiś przykład tej uszkodzonej bitmapy.

  3. Za chwilę przeanalizuje twój kod i sprawdzę czy gdzieś widać błąd.

  • fwrite(reinterpret_cast<char*>(&bfSize), 1, sizeof(bfSize), plik); - jesteś pewien że u ciebie sizeof(int) == 4? Zdarza się 2...
  • fwrite(reinterpret_cast<char*>(&bfReserved1), 1, sizeof(bfReserved1), plik); - shorty mają zazwyczaj 2 bajty, ale lepiej w takich przypadkach zawsze używaj typów jak uint16_t, uint32_t - unikniesz błędu kiedyś.
    for (int i = 0;  i < SZEROKOSC_OBRAZKA;  i++)
    {
        for (int j = 0;  j < SZEROKOSC_OBRAZKA;  j++)

nie miało być j < wys przypadkiem (hint: miało być)?

  • unsigned int *kolor_pix = new unsigned int[3]; - chyba unsigned char miało być (to tak na boku, nie powoduje to że bitmapa jest nieprawidłowa tylko że generujesz zupełnie co innego niż myślisz).

Na razie tyle problemów wystarczy...

0

ok, wysyłam ten obrazek (zmieniłam rozszerzenie, bo forum nie akceptowało .bmp ;/ )

sama tablica ma różne wymiary, zależnie od tego, która klasa ja wyprodukowała
w jednej oba wymiary tablicy muszą być podzielne przez 3
ale gdyby tylko o to chodziło to obrazek by się chyba tylko rozjeżdżał, prawda?
to musi być coś z nagłówkiem

wcześniej sprawdziłam - u mnie short = 2B

dzięki za szybka odpowiedź :)

0

Wszystkie poprzednie uwagi nadal aktualne...

Poza tym, masz subtelny błąd - piksele są pakowane w wierszach w bitmapie, a ty je zapisujesz bez przerwy, patrz http://en.wikipedia.org/wiki/BMP_file_format#Pixel_storage - dlatego też piksele źle zapisujesz, wielkość obrazka jest przez Ciebie źle wyliczana (w twoim obrazie powinno być na przykład 18408 a nie 18252), i odpowiednio zmienia się wielkość pliku (do 18462).

Sprawdź - po zmianie tych wartości odpowiednio i dopełnieniu pliku zerami (na przykład) można już otworzyć bitmapę.

0

Mało tego bmp:

  1. zapisuje bitampy do górny nogami
  2. Każdy wiersz jest wyrównany do podzielnego przez 4. (
    jak dobrze pamiętam musisz sprawdzić czy (3SZEROKOSC_OBRAZKA) % 4 == 0 jezeli nie to musisz dopisać brakujące
    4 - (( 3
    SZEOKOSC_OBRAZKA) % 4) bajtów

Dodam jeszcze że obie pętle rysujące bitmapę są na SZEROKOSC_OBRAZKA przy wyliczaniu rozmiaru mapy bitowej używasz dodatkowej zmiennej "wys"

0

wiem, że zapisuje się do góry nogami, ale to są symetryczne fraktale, więc się tym nie przejmuję
inta sprawdziłam = 4B, dlatego go użyłam
to musi być .bmp
teraz już mi normalnie otwiera, ale z tablicy 78x78 utworzył mi 0,5 GB plik (!) - czy to normalne? A program działa tak długo, że już myślałam, że się zwiesił, że może jakaś pętla nieskończona...
załączyłabym obrazek, ale przy tej wielkości... więc wrzucam początek [dalej już same zera] w hexie

42 4d 82 47 00 00 00 00 00 00 36 00 00 00 28 00
00 00 4e 00 00 00 4e 00 00 00 01 00 18 00 00 00
00 00 4c 47 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

poza tym jest to całkiem czarny kwadracik
chyba uwzględniłam wszystkie pozostałe wasze uwagi, poprawiony kod:

void bmp (int tab [][SZEROKOSC_OBRAZKA], int wys)
{
	char bfType[2] = {'B', 'M'};	// Dwa bajty zawierające znaki 'BM' oznaczające, że jest to plik BMP.
    unsigned int bfSize = 54 + (3 * SZEROKOSC_OBRAZKA * wys);	// Całkowity rozmiar pliku wyrażony w bajtach.
    unsigned short bfReserved1 = 0;	// Zarezerwowane, wymagana wartość zero.
    unsigned short bfReserved2 = 0;	// Zarezerwowane, wymagana wartość zero.
    unsigned int bfOffBits = 54;			// Przesunięcie (wyrażone w bajtach) danych obrazu (mapy bitowej) od rekordu BITMAPFILEHEADER

	unsigned int biSize = 40;		// Rozmiar rekordu BITMAPINFOHEADER wyrażony w bajtach (powinien być zawsze 40).
    unsigned int biWidth = SZEROKOSC_OBRAZKA;			// 	Szerokość obrazu w pikselach
    unsigned int biHeight = wys;		// 	Wysokość obrazu w pikselach
    unsigned short biPlanes = 1;		// Przyjmuje zawsze wartość 1.
    unsigned short biBitCount = 24;	// Liczba bitów na piksel (1, 4, 8, 24)
    unsigned int biCompression = 0;	// 	Typ kompresji obrazu:    BI_RGB - brak kompresji
    unsigned int biSizeImage = 3 * SZEROKOSC_OBRAZKA * wys;	// Rozmiar mapy bitowej obrazu wyrażony w bajtach. Może być ustawiony na zero, jeśli typem kompresji jest BI_RGB.
    unsigned int biXPelsPerMeter = 0;// Rozdzielczość pozioma obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
    unsigned int biYPelsPerMeter = 0;// 	Rozdzielczość pionowa obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
    unsigned int biClrUsed = 0;			// Liczba elementów tablicy kolorów. Wartość zero oznacza maksymalną dopuszczalną liczbę kolorów.
    unsigned int biClrImportant = 0;		// 	Liczba indeksów (kolorów) w tablicy kolorów, które są wymagane do poprawnego wyświetlenia obrazu. Wartość zero oznacza, że wszystkie kolory są wymagane.
	

	FILE *plik;
	if (( plik = fopen ("frak.bmp", "wb"))  ==  NULL)
	{
		printf ("Blad otwarcia pliku do zapisu\n");
		return;
	}
	else
		printf ("\n\nOtworzylem plik do zapisu\n");



	//zapis naglowkow do pliku
    fwrite(bfType, 1, sizeof(bfType), plik);
    fwrite(reinterpret_cast<char*>(&bfSize), 1, sizeof(bfSize), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved1), 1, sizeof(bfReserved1), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved2), 1, sizeof(bfReserved2), plik);
    fwrite(reinterpret_cast<char*>(&bfOffBits), 1, sizeof(bfOffBits), plik);
    fwrite(reinterpret_cast<char*>(&biSize), 1, sizeof(biSize), plik);
    fwrite(reinterpret_cast<char*>(&biWidth), 1, sizeof(biWidth), plik);
    fwrite(reinterpret_cast<char*>(&biHeight), 1, sizeof(biHeight), plik);
    fwrite(reinterpret_cast<char*>(&biPlanes), 1, sizeof(biPlanes), plik);
    fwrite(reinterpret_cast<char*>(&biBitCount), 1, sizeof(biBitCount), plik);
    fwrite(reinterpret_cast<char*>(&biCompression), 1, sizeof(biCompression), plik);
    fwrite(reinterpret_cast<char*>(&biSizeImage), 1, sizeof(biSizeImage), plik);
    fwrite(reinterpret_cast<char*>(&biXPelsPerMeter), 1, sizeof(biXPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biYPelsPerMeter), 1, sizeof(biYPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biClrUsed), 1, sizeof(biClrUsed), plik);
    fwrite(reinterpret_cast<char*>(&biClrImportant), 1, sizeof(biClrImportant), plik);
     

    // Wskaznik typu unsigned int ktory bedzie wykorzystany jako dynamiczna tablica 3-elementowa
	// do przechowywania wartości koloru piksela
    unsigned char  *kolor_pix = new unsigned char [3];

	
	for (int i = 0;  i < wys;  i++)
	{
		for (int j = 0;  j < SZEROKOSC_OBRAZKA;  j++)
		{
			if (tab[j][i] == 1)
			{
				for (int k = 0;  k < 3;  k++)
					kolor_pix[k] = 255;
			}
			else
			{
				for (int k = 0;  k < 3;  k++)
					kolor_pix[k] = 0;
			}
		
	    //zapis kolejnych pikseli
		fwrite(reinterpret_cast<char*>(kolor_pix), 1, 3, plik);
		}
	//	putchar ('\n');

		while (((3*SZEROKOSC_OBRAZKA) % 4)  !=  0)
		{
			for (int k = 0;  k < 3;  k++)
				kolor_pix[k] = 0;
			fwrite(reinterpret_cast<char*>(kolor_pix), 1, 3, plik);
		}
	}

	if( fclose( plik ) )
		cout <<  "Plik 'frak.bmp' nie zostal zamkniety\n" ;
	else
		cout << "Zamknalem plik 'frak.bmp'\n";
}
1

tutaj masz błąd :

while (((3*SZEROKOSC_OBRAZKA) % 4)  !=  0) {
                        for (int k = 0;  k < 3;  k++)
                                kolor_pix[k] = 0;
                        fwrite(reinterpret_cast<char*>(kolor_pix), 1, 3, plik);
                }

To jest nieskończona pętla... 3*SZEROKOSC_OBRAZKA jest stała, wiec jezeli to jest nie podzielne przez 4 to masz błąd. popraw to na :

if (((3*SZEROKOSC_OBRAZKA) % 4)  !=  0) {
   for (int k = 0;  k < 3;  k++)
      kolor_pix[k] = 0;
      fwrite(reinterpret_cast<char*>(kolor_pix), 1, 4 - ((3*SZEROKOSC_OBRAZKA) % 4) , plik);
}
0

poprawiłam, ale nadal nie chce skończyć ;/
wiem, że to może trwać długo, ale chyba nie tak małej tablicy...
poza tym nigdy nie doczekałam do końca, zawsze po ~5 min zabijam proces
teraz znów otrzymałam całkiem czarny kwadrat, tylko, że już 1,5GB o.O

0

pokaż nowe źródło, i podaj wartości zmiennych SZEROKOSC_OBRAZKA i wys

0

teraz plik zaczyna się:

42 4d 82 47 00 00 00 00 00 00 36 00 00 00 28 00
00 00 4e 00 00 00 4e 00 00 00 01 00 18 00 00 00
00 00 4c 47 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

dalej same zera
tablica ma wymiary: SZEROKOSC_OBRAZKA i wys = 78
kod jest identyczny jak poprzednio, dodałam tylko Twoją poprawkę

1

Musisz coś źle robić, albo gdzie indziej masz jakiś błąd który wpływa na działanie tego kodu. Uruchomiłem ten kod u siebie :

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

#define SZEROKOSC_OBRAZKA 78


void bmp (int tab [][SZEROKOSC_OBRAZKA], int wys)
{
        char bfType[2] = {'B', 'M'};        // Dwa bajty zawierające znaki 'BM' oznaczające, że jest to plik BMP.
    unsigned int bfSize = 54 + (3 * SZEROKOSC_OBRAZKA * wys);        // Całkowity rozmiar pliku wyrażony w bajtach.
    unsigned short bfReserved1 = 0;        // Zarezerwowane, wymagana wartość zero.
    unsigned short bfReserved2 = 0;        // Zarezerwowane, wymagana wartość zero.
    unsigned int bfOffBits = 54;                        // Przesunięcie (wyrażone w bajtach) danych obrazu (mapy bitowej) od rekordu BITMAPFILEHEADER
 
        unsigned int biSize = 40;                // Rozmiar rekordu BITMAPINFOHEADER wyrażony w bajtach (powinien być zawsze 40).
    unsigned int biWidth = SZEROKOSC_OBRAZKA;                        //         Szerokość obrazu w pikselach
    unsigned int biHeight = wys;                //         Wysokość obrazu w pikselach
    unsigned short biPlanes = 1;                // Przyjmuje zawsze wartość 1.
    unsigned short biBitCount = 24;        // Liczba bitów na piksel (1, 4, 8, 24)
    unsigned int biCompression = 0;        //         Typ kompresji obrazu:    BI_RGB - brak kompresji
    unsigned int biSizeImage = 3 * SZEROKOSC_OBRAZKA * wys;        // Rozmiar mapy bitowej obrazu wyrażony w bajtach. Może być ustawiony na zero, jeśli typem kompresji jest BI_RGB.
    unsigned int biXPelsPerMeter = 0;// Rozdzielczość pozioma obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
    unsigned int biYPelsPerMeter = 0;//         Rozdzielczość pionowa obrazu wyrażona w pikselach na metr - można zignorować (ustawić na 0)
    unsigned int biClrUsed = 0;                        // Liczba elementów tablicy kolorów. Wartość zero oznacza maksymalną dopuszczalną liczbę kolorów.
    unsigned int biClrImportant = 0;                //         Liczba indeksów (kolorów) w tablicy kolorów, które są wymagane do poprawnego wyświetlenia obrazu. Wartość zero oznacza, że wszystkie kolory są wymagane.
 
 
        FILE *plik;
        if (( plik = fopen ("frak.bmp", "wb"))  ==  NULL)
        {
                printf ("Blad otwarcia pliku do zapisu\n");
                return;
        }
        else
                printf ("\n\nOtworzylem plik do zapisu\n");
 
 
 
        //zapis naglowkow do pliku
    fwrite(bfType, 1, sizeof(bfType), plik);
    fwrite(reinterpret_cast<char*>(&bfSize), 1, sizeof(bfSize), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved1), 1, sizeof(bfReserved1), plik);
    fwrite(reinterpret_cast<char*>(&bfReserved2), 1, sizeof(bfReserved2), plik);
    fwrite(reinterpret_cast<char*>(&bfOffBits), 1, sizeof(bfOffBits), plik);
    fwrite(reinterpret_cast<char*>(&biSize), 1, sizeof(biSize), plik);
    fwrite(reinterpret_cast<char*>(&biWidth), 1, sizeof(biWidth), plik);
    fwrite(reinterpret_cast<char*>(&biHeight), 1, sizeof(biHeight), plik);
    fwrite(reinterpret_cast<char*>(&biPlanes), 1, sizeof(biPlanes), plik);
    fwrite(reinterpret_cast<char*>(&biBitCount), 1, sizeof(biBitCount), plik);
    fwrite(reinterpret_cast<char*>(&biCompression), 1, sizeof(biCompression), plik);
    fwrite(reinterpret_cast<char*>(&biSizeImage), 1, sizeof(biSizeImage), plik);
    fwrite(reinterpret_cast<char*>(&biXPelsPerMeter), 1, sizeof(biXPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biYPelsPerMeter), 1, sizeof(biYPelsPerMeter), plik);
    fwrite(reinterpret_cast<char*>(&biClrUsed), 1, sizeof(biClrUsed), plik);
    fwrite(reinterpret_cast<char*>(&biClrImportant), 1, sizeof(biClrImportant), plik);
 
 
    // Wskaznik typu unsigned int ktory bedzie wykorzystany jako dynamiczna tablica 3-elementowa
        // do przechowywania wartości koloru piksela
    unsigned char  *kolor_pix = new unsigned char [3];
 
 
        for (int i = 0;  i < wys;  i++)
        {
                for (int j = 0;  j < SZEROKOSC_OBRAZKA;  j++)
                {
                        if (tab[i][j] == 1)
                        {
                                for (int k = 0;  k < 3;  k++)
                                        kolor_pix[k] = 255;
                        }
                        else
                        {
                                for (int k = 0;  k < 3;  k++)
                                        kolor_pix[k] = 0;
                        }
 
            //zapis kolejnych pikseli
                fwrite(reinterpret_cast<char*>(kolor_pix), 1, 3, plik);
                }
        //        putchar ('\n');
 
                if (((3*SZEROKOSC_OBRAZKA) % 4)  !=  0)
                {
                        for (int k = 0;  k < 3;  k++)
                                kolor_pix[k] = 0;
                        fwrite(reinterpret_cast<char*>(kolor_pix), 1, 4 - ((3*SZEROKOSC_OBRAZKA) % 4), plik);
                }
        }
 
        if( fclose( plik ) )
                cout <<  "Plik 'frak.bmp' nie zostal zamkniety\n" ;
        else
                cout << "Zamknalem plik 'frak.bmp'\n";
}


int main() {
 int tab[78][78];
 bmp (tab, 78);
}

Wszystko działa.

Btw. poprawiłem jeszcze jeden błąd z indeksowaniem do tablicy tab (odwrotnie indeksy). Dla kwadratowej to tylko błąd logiczny bez wpływu na tworzenie obrazka, problem wyszedłby dla tab prostokątnej.

0

Nie wiem co zmieniłeś, ale jak wkleiłam Twój kod to DZIAŁA!!! :D
wielkie dzięki :)) siedziałam nad tym dłuuugo
możesz mi jeszcze tylko powiedzieć dokładnie gdzie i co zmieniłeś?

0
  1. Sprawdź wewnątrz funkcji(debbuger) czy wys i SZEROKOSC_OBRAZKA maja prawidłowe wymiary.
  2. Sprawdź czy na pewno alokujesz prawidłowo pamięć dla tab i czy nie piszesz gdzies poza pamięc
  3. Jezeli źródło nie jest za duże to mozesz je tutaj całe udostepnić.

1 użytkowników online, w tym zalogowanych: 0, gości: 1