dibapi.cpp

图像处理软件,功能比较基础

			uppImage[i][j]=*(lpDIBBits+dwOffset+j);
	}

	CComlib::OutputImageDataWithName( (void**) uppImage ,  wHeight ,wWidth ,FileName ,HeadBytes );

	CComlib::ffree_2d((void**)uppImage,wHeight);
	
	::GlobalUnlock((HGLOBAL)hDib);
	return TRUE;
}


/*************************************************************************

  Function:  ReadPICFile ( int &row , int &col , CString FileName , BOOL bFileType)

   Purpose:  Reads in the specified PIC or RAW file into a global chunk of
			 memory.

   Returns:  A handle to a dib (hDIB) if successful.
			 NULL if an error occurs.

  Comments:  BITMAPFILEHEADER is stripped off of the DIB.  Everything
			 from the end of the BITMAPFILEHEADER structure on is
			 returned in the global memory handle.

*************************************************************************/


HDIB WINAPI ReadPICFile( CString FileName )
{
	unsigned char** Image;
	BITMAPINFO* bmfInfo;
	DWORD dwBitsSize,dwSize,dOffset,dwHeadsize;
	HDIB hDIB;
	LPSTR pDIB,lpDIBBits;
	WORD wHeight,wWidth,wNewWidth;
	
	int Row , Col;
	Image = (BYTE **) CComlib::InputImageWithName(&Row , &Col , FileName);
	
	if(Image == NULL) return NULL;

	wWidth = Col;
	wHeight = Row;

	wNewWidth=(((wWidth*8)+31)/32)*4;
	dwSize=(DWORD)wNewWidth*wHeight;
	dwHeadsize=sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD);
	dwBitsSize=dwHeadsize+dwSize;
	dOffset=dwSize;

	 // Allocate memory for DIB
 
	hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize);
	if (hDIB == 0)
	{
		return NULL;
	}
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
	bmfInfo=(BITMAPINFO*)pDIB;
	WriteBmpHead(bmfInfo,wWidth,wHeight,8);
	lpDIBBits=pDIB+dwHeadsize;

  	for(WORD i=0;i<wHeight;i++)
	{
		dOffset-=wNewWidth;
		for(WORD j=0;j<wWidth;j++)
			*(lpDIBBits+dOffset+j)=Image[i][j];
	}

	CComlib::ffree_2d((void **)Image,wHeight);
	::GlobalUnlock((HGLOBAL) hDIB);
	return hDIB;
}

HDIB WINAPI ReadRAWFile(int Row,int Col, CString FileName, int HeadBytes , int nPixelBytes)
{
	unsigned char** Image;
	BITMAPINFO* bmfInfo;
	DWORD dwBitsSize,dwSize,dOffset,dwHeadsize;
	HDIB hDIB;
	LPSTR pDIB,lpDIBBits;
	WORD wHeight,wWidth,wNewWidth;
	
	Image = (BYTE **) CComlib::InputImageDataWithName( Row, Col , FileName , HeadBytes, sizeof(BYTE) );

	wWidth = Col;
	wHeight = Row;
	
	wNewWidth=(((wWidth*8)+31)/32)*4;
	dwSize=(DWORD)wNewWidth*wHeight;
	dwHeadsize=sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD);
	dwBitsSize=dwHeadsize+dwSize;
	dOffset=dwSize;

	 // Allocate memory for DIB
 
	hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize);
	if (hDIB == 0)
	{
		return NULL;
	}
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
	bmfInfo=(BITMAPINFO*)pDIB;
	WriteBmpHead(bmfInfo,wWidth,wHeight,8);
	lpDIBBits=pDIB+dwHeadsize;

  	for(WORD i=0;i<wHeight;i++)
	{
		dOffset-=wNewWidth;
		for(WORD j=0;j<wWidth;j++)
			*(lpDIBBits+dOffset+j)=Image[i][j];
	}

	CComlib::ffree_2d((void **)Image,wHeight);
	::GlobalUnlock((HGLOBAL) hDIB);
	return hDIB;
}


/*************************************************************************
 *
 * develop new function for DIB API 
 *
 * Dib Header Marker - used in writing DIBs to files
 *
 *************************************************************************/

#define DIB_HEADER_MARKER   ((WORD) ('M' << 8) | 'B')

#ifdef _MAC
#define SWAPWORD(x) MAKEWORD(HIBYTE(x), LOBYTE(x))
#define SWAPLONG(x) MAKELONG(SWAPWORD(HIWORD(x)), SWAPWORD(LOWORD(x)))
void ByteSwapHeader(BITMAPFILEHEADER* bmiHeader);
void ByteSwapInfo(LPSTR lpHeader, BOOL fWin30Header);
#endif

/*************************************************************************
 *
 * SaveDIBFile()
 *
 * Saves the specified DIB into the specified CFile.  The CFile
 * is opened and closed by the caller.
 *
 * Parameters:
 *
 * HDIB hDib - Handle to the dib to save
 *
 * CFile& file - open CFile used to save DIB
 *
 * Return value: TRUE if successful, else FALSE or CFileException
 *
 *************************************************************************/


BOOL WINAPI SaveDIBFile(HDIB hDib, CString FileName)
{
	CFile file;
	CFileException fe;

	if (!file.Open(FileName, CFile::modeCreate |
	  CFile::modeReadWrite | CFile::shareExclusive, &fe))
	{
//		ReportSaveLoadException(lpszPathName, &fe,
//			TRUE, AFX_IDP_INVALID_FILENAME);
		return FALSE;
	}

	BITMAPFILEHEADER bmfHdr; // Header for Bitmap file
	LPBITMAPINFOHEADER lpBI;   // Pointer to DIB info structure
	DWORD dwDIBSize;

	if (hDib == NULL)
		return FALSE;

	lpBI = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);
	if (lpBI == NULL)
		return FALSE;

	if (!IS_WIN30_DIB(lpBI))
	{
		::GlobalUnlock((HGLOBAL) hDib);
		return FALSE;       // It's an other-style DIB (save not supported)
	}

	/* Fill in file type (first 2 bytes must be "BM" for a bitmap) */
	bmfHdr.bfType = DIB_HEADER_MARKER;  // "BM"


	dwDIBSize = *(LPDWORD)lpBI + ::PaletteSize((LPSTR)lpBI);  // Partial Calculation

	// Now calculate the size of the image

	if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
	{
		// It's an RLE bitmap, we can't calculate size, so trust the
		// biSizeImage field

		dwDIBSize += lpBI->biSizeImage;
	}
	else
	{
		DWORD dwBmBitsSize;  // Size of Bitmap Bits only

		// It's not RLE, so size is Width (DWORD aligned) * Height

		dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) * lpBI->biHeight;

		dwDIBSize += dwBmBitsSize;

		lpBI->biSizeImage = dwBmBitsSize;
	}

	bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
	bmfHdr.bfReserved1 = 0;
	bmfHdr.bfReserved2 = 0;

	bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize
											  + PaletteSize((LPSTR)lpBI);
#ifdef _MAC
	ByteSwapHeader(&bmfHdr);

	// First swap the size field
	*((LPDWORD)lpBI) = SWAPLONG(*((LPDWORD)lpBI));

	// Now swap the rest of the structure (we don't save < Win30 files)
	ByteSwapInfo((LPSTR)lpBI, TRUE);
#endif

	TRY
	{
		// Write the file header
		file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
		file.WriteHuge(lpBI, dwDIBSize);
	}
	CATCH (CFileException, e)
	{
#ifdef _MAC
		// Swap everything back
		*((LPDWORD)lpBI) = SWAPLONG(*((LPDWORD)lpBI));
		ByteSwapInfo((LPSTR)lpBI, TRUE);
#endif
		::GlobalUnlock((HGLOBAL) hDib);
		THROW_LAST();
	}
	END_CATCH

#ifdef _MAC
	// Swap everything back
	*((LPDWORD)lpBI) = SWAPLONG(*((LPDWORD)lpBI));
	ByteSwapInfo((LPSTR)lpBI, TRUE);
#endif

	::GlobalUnlock((HGLOBAL) hDib);
	return TRUE;
}


/*************************************************************************

  Function:  ReadDIBFile (CFile&)

   Purpose:  Reads in the specified DIB file into a global chunk of
			 memory.

   Returns:  A handle to a dib (hDIB) if successful.
			 NULL if an error occurs.

  Comments:  BITMAPFILEHEADER is stripped off of the DIB.  Everything
			 from the end of the BITMAPFILEHEADER structure on is
			 returned in the global memory handle.

*************************************************************************/

BYTE WINAPI GetBmpBits(HDIB hDib)
{
	LPSTR pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDib);
	BITMAPINFO* bmfInfo=(BITMAPINFO*)pDIB;
	return bmfInfo->bmiHeader.biBitCount;
}

HDIB WINAPI ReadDIBFile( CString FileName)
{
	CFile file;
	CFileException fe;
	if (!file.Open(FileName, CFile::modeRead | CFile::shareDenyWrite, &fe))
	{
//		ReportSaveLoadException(lpszPathName, &fe,
//			FALSE, AFX_IDP_FAILED_TO_OPEN_DOC);
		return FALSE;
	}

	BITMAPFILEHEADER bmfHeader;
	DWORD dwBitsSize;
	HDIB hDIB;
	LPSTR pDIB;

	dwBitsSize = file.GetLength();

	if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
		return NULL;

#ifdef _MAC
	ByteSwapHeader(&bmfHeader);
#endif
	if (bmfHeader.bfType != DIB_HEADER_MARKER)
		return NULL;

	hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize);
	if (hDIB == 0)
	{
		return NULL;
	}
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);

	if (file.ReadHuge(pDIB, dwBitsSize - sizeof(BITMAPFILEHEADER)) !=
		dwBitsSize - sizeof(BITMAPFILEHEADER) )
	{
		::GlobalUnlock((HGLOBAL) hDIB);
		::GlobalFree((HGLOBAL) hDIB);
		return NULL;
	}
#ifdef _MAC
	// First swap the size field
	*((LPDWORD)pDIB) = SWAPLONG(*((LPDWORD)pDIB));

	// Now swap the rest of the structure
	ByteSwapInfo(pDIB, IS_WIN30_DIB(pDIB));
#endif
	::GlobalUnlock((HGLOBAL) hDIB);
	return hDIB;
}


#ifdef _MAC
void ByteSwapHeader(BITMAPFILEHEADER* bmfHeader)
{
	bmfHeader->bfType = SWAPWORD(bmfHeader->bfType);
	bmfHeader->bfSize = SWAPLONG(bmfHeader->bfSize);
	bmfHeader->bfOffBits = SWAPLONG(bmfHeader->bfOffBits);
}

void ByteSwapInfo(LPSTR lpHeader, BOOL fWin30Header)
{
	if (fWin30Header)
	{
		LPBITMAPINFOHEADER lpBMIH = &(LPBITMAPINFO(lpHeader)->bmiHeader);

		lpBMIH->biWidth = SWAPLONG(lpBMIH->biWidth);
		lpBMIH->biHeight = SWAPLONG(lpBMIH->biHeight);
		lpBMIH->biPlanes = SWAPWORD(lpBMIH->biPlanes);
		lpBMIH->biBitCount = SWAPWORD(lpBMIH->biBitCount);
		lpBMIH->biCompression = SWAPLONG(lpBMIH->biCompression);
		lpBMIH->biSizeImage = SWAPLONG(lpBMIH->biSizeImage);
		lpBMIH->biXPelsPerMeter = SWAPLONG(lpBMIH->biXPelsPerMeter);
		lpBMIH->biYPelsPerMeter = SWAPLONG(lpBMIH->biYPelsPerMeter);
		lpBMIH->biClrUsed = SWAPLONG(lpBMIH->biClrUsed);
		lpBMIH->biClrImportant = SWAPLONG(lpBMIH->biClrImportant);
	}
	else
	{
		LPBITMAPCOREHEADER lpBMCH = &(LPBITMAPCOREINFO(lpHeader)->bmciHeader);

		lpBMCH->bcWidth = SWAPWORD(lpBMCH->bcWidth);
		lpBMCH->bcHeight = SWAPWORD(lpBMCH->bcHeight);
		lpBMCH->bcPlanes = SWAPWORD(lpBMCH->bcPlanes);
		lpBMCH->bcBitCount = SWAPWORD(lpBMCH->bcBitCount);
	}
}
#endif