IplImage CBitmap HBITMAP BITMAP之间的相互转换

//Karl_bmp.h
/****************************************************************
*function: IplImage  CBitmap  HBITMAP  BITMAP之间的相互转换
*Write-By:ShadowWalker
*Date:2012-4-25
①.IplImage 2 CBitmap ②.CBitmap 2 IplImage
③.HBITMAP 2 IplImage ④.IplImage 2 HBITMAP
⑤.HBITMAP 2 CBitmap ⑥.HBITMAP 2 CBitmap
⑦.BITMAP 2 CBitmap  ⑧.HBITMAP 2 BITMAP 
⑨.BITMAP 2 HBITMAP 
****************************************************************/
//1.IplImage 2 CBitmap
CBitmap * IplImage2CBitmap(const IplImage *pImage)
{
    if( pImage && pImage->depth == IPL_DEPTH_8U )
    {
        HDC hDC=GetDC()->GetSafeHdc();
       uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
       BITMAPINFO* bmi = (BITMAPINFO*)buffer;
       int bmp_w = pImage->width, bmp_h = pImage->height;
       FillBitmapInfo( bmi, bmp_w, bmp_h, pImage->depth*pImage->nChannels, pImage->origin );
     
       char *pBits=NULL;
       HBITMAP hBitmap=CreateDIBSection(hDC,bmi,DIB_RGB_COLORS,(void**)&pBits,NULL,0);
       memcpy(pBits,pImage->imageData,pImage->imageSize);
       CBitmap *pBitmap=new CBitmap;
       pBitmap->Attach(hBitmap);

       return pBitmap;
    }
    else
       return NULL;
}

void FillBitmapInfo( BITMAPINFO* bmi, int width, int height, int bpp, int origin)
{
    assert( bmi && width >= 0 && height >= 0 && (bpp == 8 || bpp == 24 || bpp == 32));

    BITMAPINFOHEADER* bmih = &(bmi->bmiHeader);

    memset( bmih, 0, sizeof(*bmih));
    bmih->biSize = sizeof(BITMAPINFOHEADER);
    bmih->biWidth = width;
    bmih->biHeight = origin ? abs(height) : -abs(height);
    bmih->biPlanes = 1;
    bmih->biBitCount = (unsigned short)bpp;
    bmih->biCompression = BI_RGB;

    if( bpp == 8 )
    {
       RGBQUAD* palette = bmi->bmiColors;
       int i;
       for( i = 0; i < 256; i++ )
       {
        palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;
        palette[i].rgbReserved = 0;
       }
    }
}

//2.CBitmap 2 IplImage
IplImage *CBitmap2IplImage(const CBitmap *pBitmap)
{
     DIBSECTION ds;
     pBitmap->GetObject(sizeof(ds),&ds);
     IplImage *pImage=cvCreateImage(cvSize(ds.dsBm.bmWidth,ds.dsBm.bmHeight),8,ds.dsBmih.biBitCount/8);
     memcpy(pImage->imageData,ds.dsBm.bmBits,pImage->imageSize);
     return pImage;
}

//3.HBITMAP 2 IplImage
IplImage* hBitmap2Ipl(HBITMAP hBmp)
{
    BITMAP bmp; 
 ::GetObject(hBmp,sizeof(BITMAP),&bmp);//hBmp-->bmp
 int nChannels = bmp.bmBitsPixel == 1 ? 1 : bmp.bmBitsPixel/8 ;
 int depth = bmp.bmBitsPixel == 1 ? IPL_DEPTH_1U : IPL_DEPTH_8U; 
 IplImage* img = cvCreateImage(cvSize(bmp.bmWidth,bmp.bmHeight),depth,nChannels); //cvCreateImageHeader
 //pBuffer = (char*)malloc(bmp.bmHeight*bmp.bmWidth*nChannels*sizeof(char));
    memcpy(img->imageData,(char*)(bmp.bmBits),bmp.bmHeight*bmp.bmWidth*nChannels);
 IplImage *dst = cvCreateImage(cvGetSize(img),img->depth,3);
 cvCvtColor(img,dst,CV_BGRA2BGR);
 cvReleaseImage(&img);
 return dst;
}
//4.IplImage 2 HBITMAP
HBITMAP  IplImage2hBitmap(IplImage* pImg)
{
 BYTE tmp[sizeof(BITMAPINFO)+1024];
 BITMAPINFO *bmi = (BITMAPINFO*)tmp;
 HBITMAP hBmp;
 int i;
 memset(bmi,0,sizeof(BITMAPINFO));
 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 bmi->bmiHeader.biWidth = pImg->width;
 bmi->bmiHeader.biHeight = pImg->height; 
 bmi->bmiHeader.biPlanes = 1;
 bmi->bmiHeader.biBitCount = pImg->nChannels * pImg->depth;
 bmi->bmiHeader.biCompression = BI_RGB;
 bmi->bmiHeader.biSizeImage = 0;//if biCompression is BI_RGB,this can be 0
 bmi->bmiHeader.biClrImportant =0 ;
 
 switch(pImg->nChannels * pImg->depth) 
 { 
 case 8 : 
  for(i=0 ; i < 256 ; i++){ 
   bmi->bmiColors[i].rgbBlue = i;
   bmi->bmiColors[i].rgbGreen= i;
   bmi->bmiColors[i].rgbRed= i;
  }
  break;
 case 32:
 case 24: 
  ((DWORD*) bmi->bmiColors)[0] = 0x00FF0000;
  ((DWORD*) bmi->bmiColors)[1] = 0x0000FF00;
  ((DWORD*) bmi->bmiColors)[2] = 0x000000FF;
  break; 
 } 
 hBmp = ::CreateDIBSection(NULL,bmi,DIB_RGB_COLORS,NULL,0,0);
 
 SetDIBits(NULL,hBmp,0,pImg->height,pImg->imageData,bmi,DIB_RGB_COLORS);
 
 return hBmp;
}
//5.HBITMAP 2  CBitmap
CBitmap HBITMAP2CBitmap(HBITMAP  hbitmap)
{
 CBitmap   cbitmap;
 cbitmap.Attach(hbitmap);
 return cbitmap;
}
6.CBitmap 2 HBITMAP
HBITMAP  CBitmap2HBITMAP(CBitmap bitmap )
{
 HBITMAP bmp = HBITMAP(bitmap);
 //bmp=(HBITMAP)bitmap.GetSafeHandle();
 return bmp;
}
 
//7.BITMAP 2 CBitmap
CBitmap BITMAP2CBitmap(BITMAP   bmp)
{
 CBitmap bitmap;
 bitmap.GetBitmap(&bmp);
 return bitmap;
}
//8.HBITMAP 2 BITMAP 
BITMAP HBITMAP2BITMAP(HBITMAP hBmp)
{
 BITMAP bmp; 
 ::GetObject(hBmp,sizeof(BITMAP),&bmp);//
 return bmp;
}
//9.BITMAP 2 HBITMAP
HBITMAP BITMAP2HBITMAP(BITMAP hBmp);
{  
  CBitmap cbitmap = BITMAP2CBitmap(bmp);
  return CBitmap2HBITMAP(cbitmap);
}