dib.cpp

电子监控的网络编程实例

				continue;
		}
	}

	m_lpBitmapInfoHeader=(LPBITMAPINFOHEADER)lpNewDib;
	m_lpDIB=(lpNewDib+ *(LPDWORD)lpNewDib+PaletteSize(lpNewDib));

	m_nWidth=nNewWidth;
	m_nHeight=nNewHeight;
	m_nWidthOfByte=WIDTHBYTES(m_nWidth*24);
	m_dwBitsSize=dwMemSize;


	::GlobalUnlock((HGLOBAL)m_hDIB);
	::GlobalFree((HGLOBAL)m_hDIB);

	::GlobalUnlock((HGLOBAL)m_hNewDib);
	m_hDIB=m_hNewDib;


}

//切错变换
//fAngle:切错的角度；bHorzOrVert：True为水平，False为竖直
void CDIB::Traverse(float fAngle,bool bHorzOrVert)
{
	ASSERT(fAngle>-90.0 && fAngle<90.0);

	if(fAngle<0)
		fAngle+=180;
	float  PI;
    PI=(float)4.0*atan(1.0);
    
	fAngle=fAngle*PI/180.0;

	//求新的高和宽
    int		x1,y1;
    int		nNewWidth,nNewHeight;
	int		nWidth=m_nWidth,nHeight=m_nHeight;
    
	//计算新的高度和宽度
	//水平切错
	if(bHorzOrVert)
	{
		nNewWidth=nWidth+abs(nHeight*tan(fAngle));
		nNewHeight=nHeight;
	}
	else
	{
		nNewWidth=nWidth;
		nNewHeight=abs(nWidth*tan(fAngle))+nHeight;
	}
	

	LPBITMAPINFOHEADER		lpBmp;
	LPSTR					lpDib,lpNewDib,lpRgb_Sour,lpRgb_Dest;

	DWORD					dwBytesPerLine_Sour,dwBytesPerLine_Dest;
	DWORD					dwMemSize;
	HDIB					m_hNewDib;

	dwBytesPerLine_Sour=WIDTHBYTES(24*nWidth);
	dwBytesPerLine_Dest=WIDTHBYTES(24*nNewWidth);
	dwMemSize=dwBytesPerLine_Dest*nNewHeight+sizeof(BITMAPINFOHEADER);

	//开始分配旋转后的内存
	m_hNewDib=(HDIB)::GlobalAlloc(GHND,dwMemSize);
	if(m_hNewDib==NULL)
	{
		AfxMessageBox("无法分配内存！",MB_OK+MB_ICONSTOP);

		return ;
	}

	//新缓冲区
	lpNewDib=(LPSTR)::GlobalLock((HGLOBAL)m_hNewDib);
	//源缓冲区
	lpDib =(LPSTR)::GlobalLock((HGLOBAL)m_hDIB);

	::memcpy(lpNewDib,lpDib,sizeof(BITMAPINFOHEADER));
	lpBmp=(LPBITMAPINFOHEADER)lpNewDib;
	lpBmp->biWidth=nNewWidth;
	lpBmp->biHeight=nNewHeight;
	lpBmp->biSizeImage=0;

	lpRgb_Sour =(LPSTR)(lpDib+*(LPDWORD)lpDib);
	lpRgb_Dest =(LPSTR)(lpNewDib+*(LPDWORD)lpNewDib);

	//开始变换
	int r,g,b;
	for(int y=0;y<nNewHeight;y++)
	{
		for(int x=0;x<nNewWidth;x++)
		{
			//水平切错
			if(bHorzOrVert)
			{
				//向右切错
				if(tan(fAngle)>0)
				{
					y1=y;
					x1=(x)-(y)*tan(fAngle);
				}
				//向左切错
				else 
				{
					y1=y;
					x1=(x)+(nNewHeight-1-y)*tan(fAngle);
				}
			}
			//竖直切错
			else
			{
				//向上切错
				if(tan(fAngle)>0)
				{
					x1=x;
					y1=(y)-(x)*tan(fAngle);
				}
				//向下切错
				else
				{
					x1=x;
					y1=(y)+(nNewWidth-1-x)*tan(fAngle);
				}
			}
			
			//反变换后的坐标是否在源图象内?
			if(x1<nWidth && x1>0 && y1>0 && y1<nHeight)
			{
				r=*(lpRgb_Sour+(nWidth-x1-1)*3+0+(nHeight-y1-1)*dwBytesPerLine_Sour);
				g=*(lpRgb_Sour+(nWidth-x1-1)*3+1+(nHeight-y1-1)*dwBytesPerLine_Sour);
				b=*(lpRgb_Sour+(nWidth-x1-1)*3+2+(nHeight-y1-1)*dwBytesPerLine_Sour);

			}
			else
			{
				r=255;
				g=255;
				b=255;
			}

			*(lpRgb_Dest+(nNewWidth-x-1)*3+0+(nNewHeight-y-1)*dwBytesPerLine_Dest)=(BYTE)r;
			*(lpRgb_Dest+(nNewWidth-x-1)*3+1+(nNewHeight-y-1)*dwBytesPerLine_Dest)=(BYTE)g;
			*(lpRgb_Dest+(nNewWidth-x-1)*3+2+(nNewHeight-y-1)*dwBytesPerLine_Dest)=(BYTE)b;
		}
	}

	::GlobalUnlock((HGLOBAL)m_hDIB);
	::GlobalFree((HGLOBAL)m_hDIB);

	::GlobalUnlock((HGLOBAL)m_hNewDib);
	m_hDIB=m_hNewDib;

	m_nWidth=nNewWidth;
	m_nHeight=nNewHeight;
}

void CDIB::RectMapToCircle()
{

}

BOOL CDIB::LoadJPG(CString fileName)
{
	HGLOBAL h=::LoadJPG(LPCTSTR(fileName));
	if(h==NULL)
		return FALSE;

	LPSTR	pTemp;
	pTemp = (LPSTR)::GlobalLock( h );

	BITMAPINFO *pBIH;
	BITMAPFILEHEADER *pFH=(BITMAPFILEHEADER *)pTemp;

	
	pBIH = (BITMAPINFO *) (pTemp+sizeof(BITMAPFILEHEADER));

	m_nWidth=pBIH->bmiHeader.biWidth;
	m_nHeight=pBIH->bmiHeader.biHeight;
	m_nWidthOfByte=WIDTHBYTES(m_nWidth*24);
	m_dwBitsSize=m_nWidthOfByte*m_nHeight+sizeof(BITMAPINFOHEADER);

	DWORD dwSize=(pBIH->bmiHeader.biSizeImage)?pBIH->bmiHeader.biSizeImage:m_nWidth*m_nHeight*3;

	BYTE *pSrc=(LPBYTE)(pTemp + pFH->bfOffBits);

	if(dwSize>m_dwBitsSize)
		m_dwBitsSize=dwSize;
		
	DeleteObject();

	m_hDIB = (HDIB)::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,m_dwBitsSize);

	LPSTR	lpDest;
	lpDest=(LPSTR)::GlobalLock(m_hDIB);
		
	memcpy(lpDest,(LPSTR)pBIH,dwSize);


	m_pPal=NULL;


	m_lpBitmapInfoHeader=(LPBITMAPINFOHEADER)lpDest;
	m_nWidth=m_lpBitmapInfoHeader->biWidth;
	m_nHeight=m_lpBitmapInfoHeader->biHeight;
	m_nWidthOfByte=WIDTHBYTES(m_nWidth*24);
	m_lpDIB=(lpDest+ sizeof(BITMAPINFOHEADER));

	::GlobalUnlock(m_hDIB);
	::GlobalUnlock (h);
	::GlobalFree( h );

	return true;
}

BOOL CDIB::SaveJPG(CString fileName,int	nQuality)
{
	DWORD dwFileSize = (DWORD)(sizeof(BITMAPFILEHEADER) + m_dwBitsSize) ;
	
	HGLOBAL h=::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwFileSize);
	if(h==NULL)
		return FALSE;

	LPSTR	lpSour,pTemp;
	pTemp = (LPSTR) ::GlobalLock( h );

	lpSour=(LPSTR)::GlobalLock(m_hDIB);

	BITMAPFILEHEADER *pFH=(BITMAPFILEHEADER *)pTemp;
	
	pFH->bfReserved1 = 0 ;
	pFH->bfReserved2 = 0 ;
	pFH->bfSize = dwFileSize ;
	pFH->bfType = 0X4D42 ;
	pFH->bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	
	BITMAPINFOHEADER *pBMI=(BITMAPINFOHEADER *)(pTemp+sizeof(BITMAPFILEHEADER));
	
	memcpy(pBMI,lpSour,m_dwBitsSize);

	BOOL bSave=::SaveJPG(LPCTSTR(fileName),h,nQuality);
	if(h!=NULL)
		::GlobalFree (h);

	::GlobalUnlock(m_hDIB);

	return bSave;
}

BOOL CDIB::SaveDIB(CString csFileName)
{
	CFile file;
	CFileException fe;

//	TRY
//	{
//	   file.Open(csFileName, CFile::modeCreate | CFile::modeWrite,NULL))
//	}
//	CATCH( CFileException, e )
//	{
//		if( e->m_cause == CFileException::fileNotFound )
//			printf( "ERROR: File not found\n");
//	}
//	END_CATCH

	if (!file.Open(csFileName, CFile::modeCreate | CFile::modeWrite |CFile::shareDenyNone, &fe))
	{
		fe.ReportError();

		return false;
	}

	TRY
	{
		if(!SaveDIB(file)) return false;
	}
	CATCH (CFileException, eLoad)
	{
		file.Abort(); // will not throw an exception
		return false;
	}
	END_CATCH
	
	return TRUE;
}

void CDIB::Write(HDIB	hDIB)
{
	LPSTR	lpDest,lpSour;
	
	lpDest=(LPSTR)::GlobalLock((HGLOBAL)m_hDIB);
	
	lpSour=(LPSTR)::GlobalLock((HGLOBAL)hDIB);

	DWORD	dwSize=m_dwBitsSize ;

	memcpy(lpDest,lpSour,dwSize);

	::GlobalUnlock((HGLOBAL)m_hDIB);
	::GlobalUnlock((HGLOBAL)hDIB);
}

void CDIB::WriteDIB(BYTE* bRed,BYTE* bGreen,BYTE* bBlue)
{
	LPSTR					lpDIBHdr;
	LPBITMAPINFOHEADER		lpbmi;
	LPSTR					lpDIB;


	if (m_hDIB == NULL)
		return ;

	lpDIBHdr  = (LPSTR) ::GlobalLock((HGLOBAL) m_hDIB);
	if(lpDIBHdr  ==NULL)
		return;

	lpbmi = (LPBITMAPINFOHEADER)lpDIBHdr;

	if (lpbmi  == NULL)
		return ;

	lpDIB=FindDIBBits();

	for(int  i=0;i<m_nHeight;i++)
		for(int  j=0;j<m_nWidth;j++)
		{
			*(lpDIB+i*m_nWidthOfByte+3*j)=(BYTE)(*(bBlue+i*m_nWidth+j));
			*(lpDIB+i*m_nWidthOfByte+3*j+1)=(BYTE)(*(bGreen+i*m_nWidth+j));
			*(lpDIB+i*m_nWidthOfByte+3*j+2)=(BYTE)(*(bRed+i*m_nWidth+j));
		}

	::GlobalUnlock((HGLOBAL) lpDIBHdr);
}

BOOL CDIB::Create(CBitmap&	Bitmap)
{
	BITMAP			bm;
	BITMAPINFOHEADER	bi;
	LPBITMAPINFOHEADER 	lpbi;
	DWORD			dwLen;
	HDIB			hDIB;
	HDIB			handle;
	HDC 			hDC;
	HPALETTE		hPal;


	ASSERT( Bitmap.GetSafeHandle() );


	// If a palette has not been supplied use defaul palette
	hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);

	// Get bitmap information
	Bitmap.GetObject(sizeof(bm),(LPSTR)&bm);

	// Initialize the bitmapinfoheader
	bi.biSize		= sizeof(BITMAPINFOHEADER);
	bi.biWidth		= bm.bmWidth;
	bi.biHeight 		= bm.bmHeight;
	bi.biPlanes 		= 1;
	bi.biBitCount		= 24;
	bi.biCompression	= BI_RGB;
	bi.biSizeImage		= 0;
	bi.biXPelsPerMeter	= 0;
	bi.biYPelsPerMeter	= 0;
	bi.biClrUsed		= 0;
	bi.biClrImportant	= 0;

	// Compute the size of the  infoheader and the color table
	dwLen  = bi.biSize ;

	// We need a device context to get the DIB from
	hDC = GetDC(NULL);
	hPal = SelectPalette(hDC,hPal,FALSE);
	RealizePalette(hDC);

	// Allocate enough memory to hold bitmapinfoheader and color table
	hDIB = (HDIB)GlobalAlloc(GMEM_FIXED,dwLen);

	if (!hDIB)
	{
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return FALSE;
	}

	lpbi = (LPBITMAPINFOHEADER)hDIB;

	*lpbi = bi;

	// Call GetDIBits with a NULL lpBits param, so the device driver 
	// will calculate the biSizeImage field 
	GetDIBits(hDC, (HBITMAP)Bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
			(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);

	bi = *lpbi;

	// If the driver did not fill in the biSizeImage field, then compute it
	// Each scan line of the image is aligned on a DWORD (32bit) boundary
	if (bi.biSizeImage == 0)
		bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8) 
						* bi.biHeight;

	// Realloc the buffer so that it can hold all the bits
	dwLen += bi.biSizeImage;

	m_nWidth=bi.biWidth ;
	m_nHeight=bi.biHeight ;
	m_nWidthOfByte=WIDTHBYTES(m_nWidth*24);
	if(dwLen<m_nWidthOfByte*m_nHeight+sizeof(BITMAPINFOHEADER))
		dwLen=m_nWidthOfByte*m_nHeight+sizeof(BITMAPINFOHEADER);


	if (handle = (HDIB)GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
		hDIB = handle;
	else
	{
		GlobalFree(hDIB);

		// Reselect the original palette
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return FALSE;
	}

	// Get the bitmap bits
	lpbi = (LPBITMAPINFOHEADER)hDIB;

	// FINALLY get the DIB
	BOOL bGotBits = GetDIBits( hDC, (HBITMAP)Bitmap.GetSafeHandle(),
				0L,				// Start scan line
				(DWORD)bi.biHeight,		// # of scan lines
				(LPBYTE)lpbi 			// address for bitmap bits
				+ (bi.biSize),
				(LPBITMAPINFO)lpbi,		// address of bitmapinfo
				(DWORD)DIB_RGB_COLORS);		// Use RGB for color table

	if( !bGotBits )
	{
		GlobalFree(hDIB);
		
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}

	SelectPalette(hDC,hPal,FALSE);
	ReleaseDC(NULL,hDC);


	LPSTR	lpDest=(LPSTR)GlobalLock(hDIB);

	m_nWidth=bi.biWidth ;
	m_nHeight=bi.biHeight ;
	m_nWidthOfByte=WIDTHBYTES(m_nWidth*24);
	m_dwBitsSize=dwLen;


	m_lpBitmapInfoHeader=(LPBITMAPINFOHEADER)lpDest;
	m_lpDIB=(lpDest+ *(LPDWORD)lpDest+PaletteSize(lpDest));

	m_pPal=NULL;

	GlobalUnlock(hDIB);

	m_hDIB=hDIB;

	return TRUE;
}

BOOL CDIB::Create( HBITMAP	hBitmap)
{
	CBitmap*	Bitmap=CBitmap::FromHandle(hBitmap);

	return Create(*Bitmap);
}

BOOL CDIB::IsNULL()
{
	if(m_hDIB) return FALSE;
	else return TRUE;
}