Legacy ImageMagick Discussions Archive

Code: Select all

unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
FILE *filePtr; //our file pointer
BITMAPFILEHEADER bitmapFileHeader; //our bitmap file header
unsigned char *bitmapImage;  //store image data
int imageIdx=0;  //image index counter
unsigned char tempRGB;  //our swap variable

//open filename in read binary mode
filePtr = fopen(filename,"rb");
if (filePtr == NULL)
return NULL;

//read the bitmap file header
fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER),1,filePtr);

//verify that this is a bmp file by check bitmap id
if (bitmapFileHeader.bfType !=0x4D42)
{
fclose(filePtr);
return NULL;
}

//read the bitmap info header
fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER),1,filePtr);

//move file point to the begging of bitmap data
fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);

//allocate enough memory for the bitmap image data
bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);

//verify memory allocation
if (!bitmapImage)
{
free(bitmapImage);
fclose(filePtr);
return NULL;
}

//read in the bitmap image data
fread(bitmapImage,bitmapInfoHeader->biSizeImage,1,filePtr);

//make sure bitmap image data was read
if (bitmapImage == NULL)
{
fclose(filePtr);
return NULL;
}

//swap the r and b values to get RGB (bitmap is BGR)
for (imageIdx = 0;imageIdx < bitmapInfoHeader->biSizeImage;imageIdx+=3)
{
tempRGB = bitmapImage[imageIdx];
bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
bitmapImage[imageIdx + 2] = tempRGB;
}

//close file and return bitmap image data
fclose(filePtr);
return bitmapImage;
}

Code: Select all

BITMAPINFOHEADER* header = new BITMAPINFOHEADER;
unsigned char* pixels = LoadBitmapFile("D:/img.bmp", header);
Magick::Image img;
img.read(Magick::Blob(pixels, header->biSizeImage));
img.write("D:/twain.bmp");

Code: Select all

unsigned char* fullImg = (unsigned char*)malloc(sizeof(BITMAPINFOHEADER) + header->biSizeImage);
memcpy((void*)fullImg, (void*)header, sizeof(BITMAPINFOHEADER));
memcpy((void*)(fullImg + sizeof(BITMAPINFOHEADER)), pixels, header->biSizeImage);
unsigned char* pixelscpy = fullImg + sizeof(BITMAPINFOHEADER);
;copy to imagemagick
Magick::Image img;
img.read(Magick::Blob(fullImg, sizeof(BITMAPINFOHEADER) + header->biSizeImage));
img.write("D:/twain.bmp");

Code: Select all

#include <windows.h>
#include <wand/magick_wand.h>

void  SaveBitmap(char *filename,HBITMAP hBitmap)
{
	HDC        hdc=NULL;
	unsigned char *pBuf=NULL;
	BITMAPINFO bmp_inf;

	do {
		hdc = GetDC(NULL);
		ZeroMemory(&bmp_inf,sizeof(BITMAPINFO));
		bmp_inf.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
		// Passing a NULL gets just the header info containing 
		// the width and height which are used to compute the 
		// size required for a malloc
		GetDIBits(hdc,hBitmap,0,0,NULL,&bmp_inf,DIB_RGB_COLORS);

		if(bmp_inf.bmiHeader.biSizeImage <= 0)
			bmp_inf.bmiHeader.biSizeImage=bmp_inf.bmiHeader.biWidth*abs(bmp_inf.bmiHeader.biHeight)*(bmp_inf.bmiHeader.biBitCount+7)/8;

		if((pBuf = malloc(bmp_inf.bmiHeader.biSizeImage+sizeof(BITMAPINFOHEADER))) == NULL)
		{
			MessageBox( NULL, "Unable to Allocate Bitmap Memory", "Error", MB_OK|MB_ICONERROR);
			break;
		}
		bmp_inf.bmiHeader.biCompression=BI_RGB;
		// Now get the whole image
		GetDIBits(hdc,hBitmap,0,bmp_inf.bmiHeader.biHeight,pBuf+sizeof(BITMAPINFOHEADER), &bmp_inf, DIB_RGB_COLORS);
		{
			int i;
			unsigned char *p,*q;
			MagickWand *wand;

			// Copy the separate bmp_inf into the DIB info header which is 
			// now contiguous with the image data in pBuf
			p = (unsigned char *)&bmp_inf;
			q = pBuf;
			for(i=0;i<sizeof(BITMAPINFOHEADER);i++)*q++ = *p++;

			MagickWandGenesis();

			wand = NewMagickWand();
			MagickReadImageBlob(wand,pBuf,bmp_inf.bmiHeader.biSizeImage+sizeof(BITMAPINFOHEADER));

			// Force it OFF - shouldn't need this but IM's DIB coder 
			// forces matte on if the bit depth is 32 (which it is with a screencap). 
			MagickSetImageMatte(wand,MagickFalse);


			// Write the file
			MagickWriteImage(wand,filename);

			wand = DestroyMagickWand(wand);
			MagickWandTerminus();
		}
	} while(0);
	if(hdc)     ReleaseDC(NULL,hdc); 
	if(pBuf)    free(pBuf); 

}

Code: Select all

int handleToImage(HANDLE bitmap, MYIMAGE &image) const
{
	//Get the header of the bitmap (stored at the start of the handle's address)
	BITMAPINFOHEADER* header = (BITMAPINFOHEADER*)GlobalLock(bitmap);

	//We will store the bitmap into a magick++ image and transfer this to the image
	Magick::Image magickImg;
	//calculates the total number of bytes stored in 'header' (the structure is: BITMAPINFOHEADER, one RGBQUAD structure for each possible color, pixel data)
	int length = header->biSize + (00000001 << header->biBitCount)*sizeof(RGBQUAD) + header->biSizeImage; //note that if we are working with uncompressed bitmaps (32 bits), header->biSizeImage might be 0
	//read the bitmap into a magick++ using a BLOB
	try { magickImg.read(Magick::Blob(header, length)); }
	catch (...) { return 1; }

	//Load the magick++ object into the image
	if (image.load(magickImg) != 0)
	{
		return 1; //failed reading
	}

	//Free the bitmap handle now that it is loaded into the image
	GlobalUnlock(bitmap); GlobalFree(bitmap);

	return 0;
}