📄 myfile.cpp
字号:
// myfile.cpp
//
// Source file for Device-Independent Bitmap (DIB) API. Provides
// the following functions:
//
// SaveDIB() - Saves the specified dib in a file
// ReadDIBFile() - Loads a DIB from a file
//
//
// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and Microsoft
// QuickHelp and/or WinHelp documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.
#include "StdAfx.h"
#include <math.h>
#include <io.h>
#include <direct.h>
#include "dibapi.h"
/*
* 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
#define PAI 3.1415926
short mask_unit[][11]={
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,0,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1,1,1,1},
};
/*************************************************************************
*
* SaveDIB()
*
* 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 SaveDIB(HDIB hDib, CFile& file)
{
BITMAPFILEHEADER bmfHdr; // Header for Bitmap file
LPBITMAPINFOHEADER lpBI; // Pointer to DIB info structure
DWORD dwDIBSize;
if (hDib == NULL)
return FALSE;
/*
* Get a pointer to the DIB memory, the first of which contains
* a BITMAPINFO structure
*/
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 the fields of the file header
*/
/* Fill in file type (first 2 bytes must be "BM" for a bitmap) */
bmfHdr.bfType = DIB_HEADER_MARKER; // "BM"
// Calculating the size of the DIB is a bit tricky (if we want to
// do it right). The easiest way to do this is to call GlobalSize()
// on our global handle, but since the size of our global memory may have
// been padded a few bytes, we may end up writing out a few too
// many bytes to the file (which may cause problems with some apps).
//
// So, instead let's calculate the size manually (if we can)
//
// First, find size of header plus size of color table. Since the
// first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains
// the size of the structure, let's use this.
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;
// Now, since we have calculated the correct size, why don't we
// fill in the biSizeImage field (this will fix any .BMP files which
// have this field incorrect).
lpBI->biSizeImage = dwBmBitsSize;
}
// Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)
bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
bmfHdr.bfReserved1 = 0;
bmfHdr.bfReserved2 = 0;
/*
* Now, calculate the offset the actual bitmap bits will be in
* the file -- It's the Bitmap file header plus the DIB header,
* plus the size of the color table.
*/
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));
//
// Write the DIB header and the bits
//
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.
*************************************************************************/
HDIB WINAPI ReadDIBFile(CFile& file)
{
BITMAPFILEHEADER bmfHeader;
DWORD dwBitsSize;
HDIB hDIB;
LPSTR pDIB;
/*
* get length of DIB in bytes for use when reading
*/
dwBitsSize = file.GetLength();
/*
* Go read the DIB file header and check if it's valid.
*/
if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
return NULL;
#ifdef _MAC
ByteSwapHeader(&bmfHeader);
#endif
if (bmfHeader.bfType != DIB_HEADER_MARKER)
return NULL;
/*
* Allocate memory for DIB
*/
hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize);
if (hDIB == 0)
{
return NULL;
}
pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
/*
* Go read the bits.
*/
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;
}
/*
HDIB WINAPI ImageREDGREEN(HDIB hDIBRed,HDIB hDIBGreen)
{
LPBITMAPINFOHEADER RbminfoHeader,GbminfoHeader;
DWORD dwBitsSize;
HDIB hDIB;
LPSTR pDIB,pDIBR,pDIBG,datar,datag;
LPixel24bits data;
pDIBR=(LPSTR) ::GlobalLock((HGLOBAL) hDIBRed);
pDIBG=(LPSTR) ::GlobalLock((HGLOBAL) hDIBGreen);
int width,height;
RbminfoHeader= (LPBITMAPINFOHEADER)pDIBR;
GbminfoHeader= (LPBITMAPINFOHEADER)pDIBG;
width=max(RbminfoHeader->biWidth,GbminfoHeader->biWidth);
height=max(RbminfoHeader->biHeight,GbminfoHeader->biHeight);
dwBitsSize=sizeof(BITMAPINFOHEADER)
+0* sizeof(RGBQUAD)+3*width*height;
hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,dwBitsSize);
if (hDIB == 0)
{
::MessageBox(0,"申请内存太大，机器内存不够！","警告",MB_OK);
return NULL;
}
pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
LPBITMAPINFOHEADER p_bminfo = (LPBITMAPINFOHEADER)pDIB;
p_bminfo->biSize = sizeof(BITMAPINFOHEADER);
p_bminfo->biWidth = width;
p_bminfo->biHeight =height;
p_bminfo->biPlanes = 1;
p_bminfo->biBitCount =24;
p_bminfo->biCompression = BI_RGB;
p_bminfo->biSizeImage = (long)width*
(long)height*3;
p_bminfo->biXPelsPerMeter = 0;
p_bminfo->biYPelsPerMeter = 0;
p_bminfo->biClrUsed = 0;
p_bminfo->biClrImportant = 0;
data=(LPixel24bits)(pDIB+sizeof(BITMAPINFOHEADER)+0* sizeof(RGBQUAD));
datar=pDIBR+sizeof(BITMAPINFOHEADER)+256* sizeof(RGBQUAD);
datag=pDIBG+sizeof(BITMAPINFOHEADER)+256* sizeof(RGBQUAD);
int i,j,offset,offsetr,offsetg;
for(i=0;i<height;i++)
{
offset=(height-1-i)*width;
offsetr=(RbminfoHeader->biHeight-1-i)*RbminfoHeader->biWidth;
offsetg=(GbminfoHeader->biHeight-1-i)*GbminfoHeader->biWidth;
for(j=0;j<width;j++)
{
if(i<RbminfoHeader->biHeight && j<RbminfoHeader->biWidth)
data[offset+j].r=datar[offsetr+j];
if(i<GbminfoHeader->biHeight && j<GbminfoHeader->biWidth)
{
data[offset+j].g=datag[offsetg+j];
data[offset+j].b=datag[offsetg+j];
}
}//j circle
}//i circle
#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) hDIBRed);
::GlobalUnlock((HGLOBAL) hDIBGreen);
::GlobalUnlock((HGLOBAL) hDIB);
return hDIB;
}
HDIB WINAPI ImageMatchBaseOnGray(HDIB hDIB1,HDIB hDIB2,int y0,int Search_Scope)
{
LPBITMAPINFOHEADER LbminfoHeader,RbminfoHeader;
DWORD dwBitsSize;
HDIB hDIB;
LPSTR pDIB,pDIBL,pDIBR,dataL,dataR,data;
LPixel24bits datargbL,datargbR,datargb;
LPRGBQUAD rgb;
pDIBL=(LPSTR) ::GlobalLock((HGLOBAL) hDIB1);
pDIBR=(LPSTR) ::GlobalLock((HGLOBAL) hDIB2);
int widthL,heightL,widthR,heightR;
int colorsize,BytesPerPixel;
LbminfoHeader= (LPBITMAPINFOHEADER)pDIBL;
RbminfoHeader= (LPBITMAPINFOHEADER)pDIBR;
if(LbminfoHeader->biBitCount!=RbminfoHeader->biBitCount)return NULL;
switch(LbminfoHeader->biBitCount)
{
case 1: colorsize = 2;BytesPerPixel=1; break;
case 4: colorsize = 16;BytesPerPixel=1; break;
case 8: colorsize =256;BytesPerPixel=1; break;
case 24: colorsize = 0;BytesPerPixel=3; break;
default: return NULL;
}
widthL =LbminfoHeader->biWidth;
heightL=LbminfoHeader->biHeight;
widthR =RbminfoHeader->biWidth;
heightR=RbminfoHeader->biHeight;
dwBitsSize=sizeof(BITMAPINFOHEADER)
+colorsize* sizeof(RGBQUAD)+widthL*Search_Scope*BytesPerPixel;
hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,dwBitsSize);
if (hDIB == 0)
{
return NULL;
}
pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
LPBITMAPINFOHEADER p_bminfo = (LPBITMAPINFOHEADER)pDIB;
p_bminfo->biSize = sizeof(BITMAPINFOHEADER);
p_bminfo->biWidth =LbminfoHeader->biWidth;
p_bminfo->biHeight =Search_Scope;
p_bminfo->biPlanes =LbminfoHeader->biPlanes;
p_bminfo->biBitCount =LbminfoHeader->biBitCount;
p_bminfo->biCompression = BI_RGB;
p_bminfo->biSizeImage = 0;
p_bminfo->biXPelsPerMeter = 0;
p_bminfo->biYPelsPerMeter = 0;
p_bminfo->biClrUsed =LbminfoHeader->biClrUsed;
p_bminfo->biClrImportant = 0;
int i,j,ii;
rgb=(LPRGBQUAD)(pDIB+sizeof(BITMAPINFOHEADER));
for(i=0;i<colorsize;i++){
rgb[i].rgbRed = i;
rgb[i].rgbGreen = i;
rgb[i].rgbBlue = i;
rgb[i].rgbReserved = 0;
}
if(RbminfoHeader->biBitCount==24){
datargbL=(LPixel24bits)(pDIBL+sizeof(BITMAPINFOHEADER));
datargbR=(LPixel24bits)(pDIBR+sizeof(BITMAPINFOHEADER));
datargb =(LPixel24bits)(pDIB +sizeof(BITMAPINFOHEADER));
}
else{
dataL=pDIBL+sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
dataR=pDIBR+sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
data =pDIB +sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
}
int semi_scope=Search_Scope/2;
long offset1,offset2,offset3;
offset1=(heightL-1-y0)*widthL;
offset3=(heightR-1-y0)*widthR;
if(RbminfoHeader->biBitCount!=24)
{
for(i=0;i<widthL;i++)
{
for(j=(-semi_scope);j<semi_scope;j++)
{
ii=i+j;
offset2=(Search_Scope-1-(j+semi_scope))*widthL;
if((ii>0)&&(ii<widthR))
{
data[offset2+i]=abs(dataR[offset3+ii]-dataL[offset1+i]);
}
}
}
}
#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) hDIB1);
::GlobalUnlock((HGLOBAL) hDIB2);
::GlobalUnlock((HGLOBAL) hDIB);
return hDIB;
}
HDIB WINAPI ImageMatchABaseOnGray(HDIB hDIB1,HDIB hDIB2,int Lx0,int Ly0,int Rx0,int Ry0)
{
LPBITMAPINFOHEADER LbminfoHeader,RbminfoHeader;
DWORD dwBitsSize;
HDIB hDIB;
LPSTR pDIB,pDIBL,pDIBR,dataL,dataR,data;
LPixel24bits datargbL,datargbR,datargb;
LPRGBQUAD rgb;
/*
* Allocate memory for DIB
*/
/* pDIBL=(LPSTR) ::GlobalLock((HGLOBAL) hDIB1);
pDIBR=(LPSTR) ::GlobalLock((HGLOBAL) hDIB2);
int widthL,heightL,widthR,heightR;
int colorsize,BytesPerPixel;
LbminfoHeader= (LPBITMAPINFOHEADER)pDIBL;
RbminfoHeader= (LPBITMAPINFOHEADER)pDIBR;
if(LbminfoHeader->biBitCount!=RbminfoHeader->biBitCount)return NULL;
switch(LbminfoHeader->biBitCount)
{
case 1: colorsize = 2;BytesPerPixel=1; break;
case 4: colorsize = 16;BytesPerPixel=1; break;
case 8: colorsize =256;BytesPerPixel=1; break;
case 24: colorsize = 0;BytesPerPixel=3; break;
default: return NULL;
}
widthL =LbminfoHeader->biWidth;
heightL=LbminfoHeader->biHeight;
widthR =RbminfoHeader->biWidth;
heightR=RbminfoHeader->biHeight;
dwBitsSize=sizeof(BITMAPINFOHEADER)
+colorsize* sizeof(RGBQUAD)+widthL*heightL*BytesPerPixel;
hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,dwBitsSize);
if (hDIB == 0)
{
return NULL;
}
pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
LPBITMAPINFOHEADER p_bminfo = (LPBITMAPINFOHEADER)pDIB;
p_bminfo->biSize = sizeof(BITMAPINFOHEADER);
p_bminfo->biWidth =LbminfoHeader->biWidth;
p_bminfo->biHeight =LbminfoHeader->biWidth;
p_bminfo->biPlanes =LbminfoHeader->biPlanes;
p_bminfo->biBitCount =LbminfoHeader->biBitCount;
p_bminfo->biCompression = BI_RGB;
p_bminfo->biSizeImage = 0;
p_bminfo->biXPelsPerMeter = 0;
p_bminfo->biYPelsPerMeter = 0;
p_bminfo->biClrUsed =LbminfoHeader->biClrUsed;
p_bminfo->biClrImportant = 0;
int i,j;
rgb=(LPRGBQUAD)(pDIB+sizeof(BITMAPINFOHEADER));
for(i=0;i<colorsize;i++){
rgb[i].rgbRed = i;
rgb[i].rgbGreen = i;
rgb[i].rgbBlue = i;
rgb[i].rgbReserved = 0;
}
/*
* Go read the bits.
*/
/* if(RbminfoHeader->biBitCount==24){
datargbL=(LPixel24bits)(pDIBL+sizeof(BITMAPINFOHEADER));
datargbR=(LPixel24bits)(pDIBR+sizeof(BITMAPINFOHEADER));
datargb =(LPixel24bits)(pDIB +sizeof(BITMAPINFOHEADER));
}
else{
dataL=pDIBL+sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
dataR=pDIBR+sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
data =pDIB +sizeof(BITMAPINFOHEADER)+colorsize* sizeof(RGBQUAD);
}
long offset1,offset2;
int xx_offset,yy_offset;
xx_offset=Rx0-Lx0;
yy_offset=Ry0-Ly0;
if(RbminfoHeader->biBitCount!=24)
{
for(i=0;i<heightL;i++)
{
offset1=(heightL-1-i)*widthL;
if((i+yy_offset<0)||((i+yy_offset)>heightR))break;
offset2=(heightR-1-(i+yy_offset))*widthR;
for(j=0;j<widthL;j++)
{
if((j+xx_offset<0)||(j+xx_offset>widthR))break;
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -