android bitmap iplimage,IplImage CBitmap HBITMAP BITMAP之间的相互转换

//Karl_bmp.h

//原文链接：http://blog.163.com/liyujian5201314@126/blog/static/292913382012325101622740/

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

*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  ⑧.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->p_w_picpathData,pImage->p_w_picpathSize);

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 

{

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->p_w_picpathData,ds.dsBm.bmBits,pImage->p_w_picpathSize);

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->p_w_picpathData,(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 

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->p_w_picpathData,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;

}