Come creare un .bmp in WinCE
-
22-07-2019 - |
Domanda
Ho una fotocamera che restituisce immagini grezze che possono essere facilmente convertite in bitmap che possono essere salvate in un file con il seguente metodo C # (che non ho scritto). Da varie fonti, ho determinato che le immagini hanno 8 bit per pixel e possono essere o meno in scala di grigi.
private void rawImgToBmp(byte[] imgData, String fname) {
Bitmap bmp = new Bitmap(getWidth(), getHeight(),
System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
for (int i = 0; i < 256; i++)
{ bmp.Palette.Entries[i] = Color.FromArgb(255, i, i, i); }
//Copy the data from the byte array into the bitmap
BitmapData bmpData =
bmp.LockBits( new Rectangle(0, 0, bmp.Width, bmp.Height),
ImageLockMode.WriteOnly, bmp.PixelFormat);
Marshal.Copy(imgData, 0, bmpData.Scan0, getWidth() * getHeight());
bmp.UnlockBits(bmpData); //Unlock the pixels
bmp.Save(FileName);
}
La mia domanda è: come potrei fare per scrivere il metodo equivalente in C ++, usando le funzioni integrate di Windows CE 4.2?
erisu: grazie per il codice tavolozza, penso che sia giusto. Ho fatto ricorso alla compilazione manuale del resto delle strutture, secondo la pagina Wikipedia .
Soluzione 2
Questo è il codice che funziona per me. Si basa sulla risposta di erisu e sulla la descrizione di Wikipedia del formato BMP . Per chiunque utilizzi questa risposta, ti consiglio di comprendere il formato BMP nel modo più completo possibile, in modo da poter adattare di conseguenza i campi dell'intestazione.
Il complicato loop alla fine è la mia soluzione alternativa per un problema con il mio hardware / sistema operativo, in cui non scriverebbe tutti i dati forniti a fwrite. Dovrebbe funzionare in qualsiasi ambiente.
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>
#define NPAL_ENT 256
INT WINAPI WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
INT nShowCmd )
{
int w = 1920, h = 1080; // My values, yours may vary
//////////////////////// File Operations ///////////////////////////////
// Reading raw img
FILE* f = fopen("\\FlashDisk\\raw_img.bin","r");
if(NULL == f){printf("BAD");exit(1);}
// Obtaining size of raw img
fseek (f , 0L , SEEK_END);
DWORD fsize = (DWORD)ftell (f);
fseek (f , 0L , SEEK_SET);
char *imgData = (char*) malloc (sizeof(char)*fsize);
if(NULL == imgData) {printf("NOT imgData");exit(2);}
// Copy contents of file into buffer
DWORD result = fread(imgData,1,fsize,f);
if (result != fsize) {
printf ("Reading error. Expected: %d, Got: %d\n",fsize, result );
if(ferror(f)){printf("An error: %d\n", ferror(f)); }
if(feof(f)) {printf("EOF\n");}
delete[] imgData;
fclose(f);
exit (3);
}
fclose(f);
//////////////////////// BMP Operations ///////////////////////////////
/* A bitmap has the following components:
* 1. BMP file header
* 2. Bitmap Information (DIB) header
* 3. Color Palette
* 4. Raw Data
*/
BITMAPFILEHEADER bmfh;
ZeroMemory( &bmfh, sizeof( bmfh ) );
bmfh.bfType = 0x4D42; // Magic #
bmfh.bfSize = sizeof( bmfh ) + sizeof( BITMAPINFOHEADER )
+ NPAL_ENT*sizeof(PALETTEENTRY) + w*h; // Or total file size if w/h not known
bmfh.bfOffBits = sizeof( bmfh ) + sizeof( BITMAPINFOHEADER )
+ NPAL_ENT*sizeof(PALETTEENTRY);
BITMAPINFOHEADER bmih;
ZeroMemory( &bmih, sizeof( bmih ) );
bmih.biWidth = w;
bmih.biHeight = h;
bmih.biSize = sizeof(bmih);
bmih.biPlanes = 1;
bmih.biBitCount = 8;
bmih.biCompression = BI_RGB;
bmih.biSizeImage = w * h;
int palSize = NPAL_ENT*sizeof(PALETTEENTRY);
LOGPALETTE *logpal=(LOGPALETTE*)new BYTE[sizeof(LOGPALETTE)+palSize];
if(!logpal) {delete [] imgData; printf("!logpal\n"); exit(4);}
logpal->palVersion=0x300;
logpal->palNumEntries=NPAL_ENT;
int i=0;
do { // Exact palette format varies. This is what worked for me
logpal->palPalEntry[i].peRed=i;
logpal->palPalEntry[i].peGreen=i;
logpal->palPalEntry[i].peBlue=i;
logpal->palPalEntry[i].peFlags=NULL;
} while(++i<NPAL_ENT);
// Complete bitmap is now in memory, time to save it
TCHAR bmpfname[80];
wsprintf( bmpfname, (TCHAR*) TEXT( "\\USBDisk\\out.bmp" ) );
// open the file for writing
FILE *bmpFile = _wfopen(bmpfname,L"wb");
if(!bmpFile) { delete[] imgData; delete[] logpal; exit(6); }
// write the bitmap to file, in whatever chunks WinCE allows
size_t totWrit = 0, offset = 0, writeAmt = 0;
while(totWrit < bmfh.bfSize){
if(totWrit < sizeof(bmfh)){ // File header
offset = totWrit;
totWrit += fwrite( ((char*)&bmfh)+offset, 1, sizeof(bmfh)-offset, bmpFile );
}
else if(totWrit<sizeof(bmfh)+sizeof(bmih)){ // Image header
offset = totWrit - sizeof(bmfh);
totWrit += fwrite( ((char*)&bmih)+offset, 1, sizeof(bmih)-offset, bmpFile );
}
else if(totWrit<sizeof(bmfh)+sizeof(bmih)+palSize) { // Pallette
offset = totWrit - sizeof(bmfh) - sizeof(bmih);
totWrit += fwrite( ((char*)&logpal->palPalEntry)+offset, 1, palSize-offset, bmpFile );
}
else { // Image data
offset = totWrit - sizeof(bmfh) - sizeof(bmih) - palSize;
if(bmfh.bfSize-totWrit >= IO_SIZE) {
writeAmt = IO_SIZE;
}
else {
writeAmt = bmfh.bfSize-totWrit;
}
totWrit += fwrite( &imageBuffer[offset], 1, writeAmt, bmpFile );
}
// Close and open after each iteration to please WinCE
fflush(bmpFile);
fclose(bmpFile);
Sleep(4000);
bmpFile = _wfopen(bmpfname,L"ab");
if(!bmpFile) {flog->lprintf("Couldn't reopen bmpfile"); delete [] logpal; return 0;}
}
fclose(bmpFile);
if(totWrit != bmfh.bfSize) {
printf("BMP Size mismatch: %d/%d.",totWrit,bmfh.bfSize);
delete [] imgData;
delete [] logpal;
exit(-1);
}
// Cleanup
delete [] imgData;
delete [] logpal;
return 0;
}
Altri suggerimenti
In genere utilizzo CreateBitmap o CreateCompatibleBitmap per generare bitmap in Windows. Non ho familiarità con WinCE ma le funzioni sembrano essere presenti. I tuoi dati sembrano essere a 8 bit per pixel con una tavolozza di 256 colori, quindi molto probabilmente avrai bisogno delle funzioni CreatePalette, SelectPalette e RealizePalette.
Qualcosa di simile (avviso: codice non testato):
HBITMAP hBmp=CreateBitmap(width, height, 1, 8, imgData);
LOGPALETTE logpal=(LOGPALETTE)new BYTE[sizeof(LOGPALETTE)+256*sizeof(PALETTEENTRY)];
logpal.palVersion=0x300;
logpal.palNumEntries=256;
int i=0;
do { //no idea your palette's format, however it looks to be greyscale?
logpal->mypal[i].peRed=i;
logpal->mypal[i].peGreen=i;
logpal->mypal[i].peBlue=i;
logpal->mypal[i].peFlags=NULL;
while(++i<256);
HPALETTE hPal=CreatePalette(logpal);
//If your trying to display it to a window's DC called mywindowsDC
HDC hBmpDC = CreateCompatibleDC(mywindowsDC);
SelectObject(hBmpDC, hBmp);
SelectPalette(hBmpDC, hPal, TRUE);
BitBlt(mywindowsDC, 0, 0, width, height, hBmpDC, 0, 0, SRCCOPY);
RealizePalette(mywindowsDC);
//clean up
DeleteDC(hBmpDC);
delete [](BYTE *)logpal;
DeleteObject(hPal);
DeleteObject(hBmp);
Non leggerei i dati dell'immagine usando le operazioni FILE *
: puoi farlo funzionare, ma è prolisso e soggetto a problemi come fread ()
che pensa a un Ctrl -Z significa End-of-File, inoltre devi ricordarti di chiudere il file al termine. Invece userei la classe MFC CFile
. Questo sarà simile a
BYTE* pbyImageData = NULL;
CFile fileImage;
if(fileImage.Open(_T("\\rawimage.dat"), CFile::modeRead, NULL))
{
pbyImageData = new BYTE[fileImage.GetLength()];
fileImage.Read(pbyImageData, fileImage.GetLength());
}
Le bitmap sono gestite facilmente in Windows CE utilizzando la classe CDIBSectionCE
. Questo è disponibile da CodeGuru ( 'Un wrapper DIBSection per Win32 e WinCE '). Usando CDIBSectionCE, faresti qualcosa del genere ...
// The BITMAPINFO struct is almost completely unusable because it has
// space for a less-than-generous 1-colour palette, so I always end up
// creating a home-grown version with room for 256 colours:
struct BITMAPINFO256
{
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[256];
} stcBmpInfo;
// ...Fill in the BITMAPINFO structure -- bitmap size etc.
stcBmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
stcBmpInfo.bmiHeader.biWidth = ....
/// etc ... keep the code you have for filling in bitmap info at present
// Now load up the image into the DIB Section
CDIBSectionCE bmp;
bmp.SetBitmap((BITMAPINFO*)&stcBmpInfo, pbyImageData);
// Now write the bitmap out as a file
bmp.Save(_T("\\mybitmap.bmp");
Nota che CDIBSectionCE
gestisce tutti gli elementi dell'intestazione del file. Tutto quello che devi fare è leggere i dati dell'immagine, spingerli in una sezione DIB e quindi chiedergli di salvarsi come file bitmap.