📄 myfile.cpp
字号:
LPixel24bits datarg;
/*
* Allocate memory for DIB
*/
/* pDIBR=(LPSTR) ::GlobalLock((HGLOBAL) hDIBRed);
pDIBRG=(LPSTR) ::GlobalLock((HGLOBAL) hDIBRedGreen);
RbminfoHeader= (LPBITMAPINFOHEADER)pDIBR;
RGbminfoHeader= (LPBITMAPINFOHEADER)pDIBRG;
/*
* Go read the bits.
*/
/* int i,j,offsetr,offsetrg;
datarg=(LPixel24bits)(pDIBRG+sizeof(BITMAPINFOHEADER)+0* sizeof(RGBQUAD));
datar=pDIBR+sizeof(BITMAPINFOHEADER)+256* sizeof(RGBQUAD);
int ii,jj;
for(i=0;i<RGbminfoHeader->biHeight;i++)
{
ii=i-i0;
offsetr=(RbminfoHeader->biHeight-1-ii)*RbminfoHeader->biWidth;
offsetrg=(RGbminfoHeader->biHeight-1-i)*RGbminfoHeader->biWidth;
for(j=0;j<RGbminfoHeader->biWidth;j++)
{
jj=j-j0;
if(ii>0 && ii<RbminfoHeader->biHeight && jj>0 && jj<RbminfoHeader->biWidth)
datarg[offsetrg+j].r=datar[offsetr+jj];
else
datarg[offsetrg+j].r=0;
}//j circle
}//i circle
#ifdef _MAC
// First swap the size field
*((LPDWORD)pDIB) = SWAPLONG(*((LPDWORD)pDIBRG));
// Now swap the rest of the structure
ByteSwapInfo(pDIB, IS_WIN30_DIB(pDIBRG));
#endif
::GlobalUnlock((HGLOBAL) hDIBRed);
::GlobalUnlock((HGLOBAL) hDIBRedGreen);
}
HDIB WINAPI ImageZoomIn3(HDIB hDIB)
{
LPBITMAPINFOHEADER bminfoHeader;
DWORD dwBitsSize;
HDIB ZoomInhDIB;
BYTE *pDIB,*ZoomInpDIB,*Data,*ZoomInData;
LPixel24bits Datargb,ZoomInDatargb;
/*
* Allocate memory for DIB
*/
/* pDIB=(BYTE *) ::GlobalLock((HGLOBAL) hDIB);
int width,height,palettesize,BytesPerPixel,widtho,heighto;
bminfoHeader= (LPBITMAPINFOHEADER)pDIB;
widtho=bminfoHeader->biWidth;
heighto=bminfoHeader->biHeight;
width=(bminfoHeader->biWidth/3);
height=(bminfoHeader->biHeight/3);
if(width % 4)width= 4 *(width/4 -1);
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2;BytesPerPixel=1; break;
case 4: palettesize =16;BytesPerPixel=1; break;
case 8: palettesize =256;BytesPerPixel=1; break;
case 24: palettesize = 0;BytesPerPixel=3; break;
default: return NULL;
}
dwBitsSize=sizeof(BITMAPINFOHEADER)
+palettesize* sizeof(RGBQUAD)+width*height*BytesPerPixel;
ZoomInhDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,dwBitsSize);
if (ZoomInhDIB == 0)
{
return NULL;
}
ZoomInpDIB = (BYTE *) ::GlobalLock((HGLOBAL) ZoomInhDIB);
int headsize=sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
int i,j;
for(i=0;i<headsize;i++)
ZoomInpDIB[i]=pDIB[i];
LPBITMAPINFOHEADER p_bminfo = (LPBITMAPINFOHEADER)ZoomInpDIB;
p_bminfo->biSize = sizeof(BITMAPINFOHEADER);
p_bminfo->biWidth =(long) width;
p_bminfo->biHeight =(long)height;
p_bminfo->biCompression = BI_RGB;
p_bminfo->biSizeImage = (long)width*
(long)height*BytesPerPixel;
/*
* Go read the bits.
*/
/* if(bminfoHeader->biBitCount==24){
Datargb=(LPixel24bits)(pDIB+sizeof(BITMAPINFOHEADER));
ZoomInDatargb=(LPixel24bits)(ZoomInpDIB+sizeof(BITMAPINFOHEADER));
}
else{
Data=pDIB+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
ZoomInData=ZoomInpDIB+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
}
int offset,offset1,offset2,offset3,l,m;
unsigned int temp,temp1;
if(bminfoHeader->biBitCount==24)
{
for(i=0;i<height;i++)
{
offset=(height-1-i)*width;
l=3*i+1;
offset1=(heighto-1-(l+1))*widtho;
offset2=(heighto-1-(l ))*widtho;
offset3=(heighto-1-(l-1))*widtho;
for(j=0;j<width;j++)
{
m=3*j+1;
ZoomInDatargb[offset+j].r=
((Datargb[offset1+m-1].r
+Datargb[offset1+m ].r
+Datargb[offset1+m+1].r
+Datargb[offset2+m-1].r
+Datargb[offset2+m ].r
+Datargb[offset2+m+1].r
+Datargb[offset3+m-1].r
+Datargb[offset3+m ].r
+Datargb[offset3+m+1].r
)/9);
ZoomInDatargb[offset+j].g=
((Datargb[offset1+m-1].g
+Datargb[offset1+m ].g
+Datargb[offset1+m+1].g
+Datargb[offset2+m-1].g
+Datargb[offset2+m ].g
+Datargb[offset2+m+1].g
+Datargb[offset3+m-1].g
+Datargb[offset3+m ].g
+Datargb[offset3+m+1].g
)/9);
ZoomInDatargb[offset+j].b=
((Datargb[offset1+m-1].b
+Datargb[offset1+m ].b
+Datargb[offset1+m+1].b
+Datargb[offset2+m-1].b
+Datargb[offset2+m ].b
+Datargb[offset2+m+1].b
+Datargb[offset3+m-1].b
+Datargb[offset3+m ].b
+Datargb[offset3+m+1].b
)/9);
}//j circle
}//i circle
}
else
{
for(i=0;i<height;i++)
{
offset=(height-1-i)*width;
l=3*i+1;
offset1=(heighto-1-(l+1))*widtho;
offset2=(heighto-1-(l ))*widtho;
offset3=(heighto-1-(l-1))*widtho;
for(j=0;j<width;j++)
{
m=3*j+1;
temp=
((int)Data[offset1+m-1]
+(int)Data[offset1+m ]
+(int)Data[offset1+m+1]
+(int)Data[offset2+m-1]
+(int)Data[offset2+m ]
+(int)Data[offset2+m+1]
+(int)Data[offset3+m-1]
+(int)Data[offset3+m ]
+(int)Data[offset3+m+1]);
if((temp%9)>5)temp1=1;
else temp1=0;
ZoomInData[offset+j]=(BYTE)(temp/9+temp1);
}//j circle
}//i circle
}
#ifdef _MAC
// First swap the size field
*((LPDWORD)pDIB) = SWAPLONG(*((LPDWORD)ZoomInpDIB));
// Now swap the rest of the structure
ByteSwapInfo(pDIB, IS_WIN30_DIB(ZoomInpDIB));
#endif
::GlobalUnlock((HGLOBAL) hDIB);
::GlobalUnlock((HGLOBAL) ZoomInhDIB);
return ZoomInhDIB;
}
void WINAPI PointSmothDIB(HDIB hDIB,CPoint Ttxy,int size)
{
LPBITMAPINFOHEADER bminfoHeader;
LPSTR pDIB,data;
int palettesize,width,height;
LPixel24bits datargb;
pDIB=(LPSTR) ::GlobalLock((HGLOBAL) hDIB);
bminfoHeader= (LPBITMAPINFOHEADER)pDIB;
width = bminfoHeader->biWidth;
height =bminfoHeader->biHeight;
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2; break;
case 4: palettesize =16; break;
case 8: palettesize =256; break;
case 24: palettesize = 0; break;
default: return;
}
data=pDIB+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
int i,j,offset,offset1;
if(palettesize==0){
datargb=(LPixel24bits)data;
}
int i0,j0,i1,j1,ix,iy;
WORD averager,averageg,averageb,average;
int MASK_SIZE=size;
if(MASK_SIZE>11)MASK_SIZE=11;
BYTE temp;
if(palettesize==0)
{
for(i=(-size/2);i<=(size/2);i++)
{
i0=Ttxy.y+i;
offset=(height-1-i0)*width;
for(j=(-size/2);j<=(size/2);j++)
{
j0=Ttxy.x+j;
averager=averageb=averageg=0;
for(i1=(-MASK_SIZE/2);i1<=(MASK_SIZE/2);i1++)
{
ix=i0+i1;
offset1=(height-1-ix)*width;
for(j1=(-MASK_SIZE/2);j1<=(MASK_SIZE/2);j1++)
{
iy=j0+j1;
averager+=mask_unit[5+i1][5+j1]*datargb[offset1+iy].r;
averageg+=mask_unit[5+i1][5+j1]*datargb[offset1+iy].g;
averageb+=mask_unit[5+i1][5+j1]*datargb[offset1+iy].b;
}//end j0
}//end i0
averager=averager/(MASK_SIZE*MASK_SIZE-1);
averageg=averageg/(MASK_SIZE*MASK_SIZE-1);
averageb=averageb/(MASK_SIZE*MASK_SIZE-1);
datargb[offset+j0].r=(BYTE)averager;
datargb[offset+j0].g=(BYTE)averageg;
datargb[offset+j0].b=(BYTE)averageb;
}//end j
}//end i
}
if(palettesize!=0)
{
for(i=(-size/2);i<=(size/2);i++)
{
i0=Ttxy.y+i;
offset=(height-1-i0)*width;
for(j=(-size/2);j<=(size/2);j++)
{
j0=Ttxy.x+j;
average=0;
for(i1=(-MASK_SIZE/2);i1<=(MASK_SIZE/2);i1++)
{
ix=i0+i1;
offset1=(height-1-ix)*width;
for(j1=(-MASK_SIZE/2);j1<=(MASK_SIZE/2);j1++)
{
iy=j0+j1;
temp=data[offset1+iy];
average+=mask_unit[5+i1][5+j1]*temp;
}//end j0
}//end i0
average=average/(MASK_SIZE*MASK_SIZE-1);
data[offset+j0]=(BYTE)average;
}//end j
}//end i
}
return ;
}
BOOL WINAPI MyDIBToFLOAT(HDIB hDIBO,HDIB &hDIB,int &nn)
{
LPBITMAPINFOHEADER bminfoHeader;
DWORD dwBitsSize;
LPSTR pDIBO;
float *pDIB;
int palettesize ;
BYTE *data;
LPixel24bits datargb;
// Allocate memory for DIB
if( hDIBO==NULL)return FALSE;
pDIBO=(LPSTR) ::GlobalLock((HGLOBAL) hDIBO);
bminfoHeader= (LPBITMAPINFOHEADER)pDIBO;
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2;nn=1; break;
case 4: palettesize =16;nn=1; break;
case 8: palettesize =256;nn=1; break;
case 24: palettesize = 0;nn=3; break;
default: return FALSE;
}
data=(BYTE *)(pDIBO+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD));
if(palettesize==0)
{
datargb=(LPixel24bits)data;
}
dwBitsSize=DIBHeight(pDIBO)*DIBWidth(pDIBO)*sizeof(float);
hDIB=(HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,nn*dwBitsSize*sizeof(float));
if(hDIB==NULL)
{
AfxMessageBox("1:Memory allocation error in wt.h!\n");
return FALSE;
}
pDIB =(float *) ::GlobalLock((HGLOBAL) hDIB);
int i;
if(nn==1)
{
for(i=0;i<(int)(DIBHeight(pDIBO)*DIBWidth(pDIBO));i++)
pDIB[i]=data[i];
}
if(nn==3)
{
for(i=0;i<(int)(DIBHeight(pDIBO)*DIBWidth(pDIBO));i++)
{
pDIB[i]=(float)datargb[i].r;
pDIB[i+dwBitsSize]=(float)datargb[i].g;
pDIB[i+2*dwBitsSize]=(float)datargb[i].b;
}
}
::GlobalUnlock((HGLOBAL) hDIBO);
::GlobalUnlock((HGLOBAL) hDIB);
return TRUE;
}
BOOL WINAPI MyDIBFromFLOAT(HDIB hDIBO,HDIB hDIB)
{
LPBITMAPINFOHEADER bminfoHeader;
DWORD dwBitsSize;
LPSTR pDIBO;
float *pDIB;
int palettesize ;
BYTE *data;
LPixel24bits datargb;
// Allocate memory for DIB
if((hDIBO==NULL)||(hDIB==NULL))return FALSE;
pDIBO=(LPSTR) ::GlobalLock((HGLOBAL) hDIBO);
pDIB =(float *) ::GlobalLock((HGLOBAL) hDIB);
bminfoHeader= (LPBITMAPINFOHEADER)pDIBO;
int nn;
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2;nn=1; break;
case 4: palettesize =16;nn=1; break;
case 8: palettesize =256;nn=1; break;
case 24: palettesize = 0;nn=3; break;
default: return NULL;
}
data=(BYTE *)(pDIBO+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD));
if(palettesize==0)
{
datargb=(LPixel24bits)data;
}
dwBitsSize=DIBHeight(pDIBO)*DIBWidth(pDIBO)*sizeof(float);
int i;
if(nn==1)
{
int temp;
for(i=0;i<(int)(DIBHeight(pDIBO)*DIBWidth(pDIBO));i++)
{
temp=(int)pDIB[i];
if(temp<0)temp=0;
if(temp>255)temp=255;
data[i]=(BYTE)pDIB[i];
}
}
if(nn==3)
{
int temp;
for(i=0;i<(int)(DIBHeight(pDIBO)*DIBWidth(pDIBO));i++)
{
temp=(int)pDIB[i];
if(temp<0)temp=0;
if(temp>255)temp=255;
datargb[i].r=(BYTE)temp;
temp=(int)pDIB[i+dwBitsSize];
if(temp<0)temp=0;
if(temp>255)temp=255;
datargb[i].g=(BYTE)temp;
temp=(int)pDIB[i+2*dwBitsSize];
if(temp<0)temp=0;
if(temp>255)temp=255;
datargb[i].b=(BYTE)temp;
}
}
::GlobalUnlock((HGLOBAL) hDIBO);
::GlobalUnlock((HGLOBAL) hDIB);
return TRUE;
}
/*
void WINAPI CheckFeature(HDIB hDIB,int I,int J, BYTE *HF,BYTE *VF,BYTE *HVF)
{
LPBITMAPINFOHEADER bminfoHeader;
LPSTR pDIB,data;
int palettesize,width,height;
pDIB=(LPSTR) ::GlobalLock((HGLOBAL) hDIB);
bminfoHeader= (LPBITMAPINFOHEADER)pDIB;
width = bminfoHeader->biWidth;
height =bminfoHeader->biHeight;
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2; break;
case 4: palettesize =16; break;
case 8: palettesize =256; break;
case 24: palettesize = 0; break;
default: return;
}
data=pDIB+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
int iv,jv;
I=height-1-I;
if(palettesize!=0)
{
iv=I/2+height/2;
jv=J/2;
*HF=data[iv*width+jv];
iv=I/2;
jv=J/2+width/2;
*VF=data[iv*width+jv];
iv=I/2+height/2;
jv=J/2+width/2;
*HVF=data[iv*width+jv];
}
::GlobalUnlock((HGLOBAL) hDIB);
return ;
}
*/
LPSTR WINAPI GetDIBData(HDIB hDIBO)
{
LPBITMAPINFOHEADER bminfoHeader;
LPSTR pDIBO,data;
int palettesize ;
pDIBO=(LPSTR) ::GlobalLock((HGLOBAL) hDIBO);
bminfoHeader= (LPBITMAPINFOHEADER)pDIBO;
switch(bminfoHeader->biBitCount)
{
case 1: palettesize = 2; break;
case 4: palettesize =16; break;
case 8: palettesize =256; break;
case 24: palettesize = 0; break;
default: return NULL;
}
data=pDIBO+sizeof(BITMAPINFOHEADER)+palettesize* sizeof(RGBQUAD);
return data;
}
/*
#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)
{
// Note this doesn't swap the bcSize/biSize field. It assumes that the
// size field was swapped during read or while setting the fWin30Header
// flag.
if (fWin30Header)
{
LPBITMAPINFOHEADER lpBMIH = &(LPBITMAPINFO(lpHeader)->bmiHeader);
//lpBMIH->biSize = SWAPLONG(lpBMIH->biSize);
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*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -