#include "StdAfx.h"
#include "CHImageData.h"

#include "OpenCV/cxcore.h"
#include "OpenCV/cv.h"
#include "OpenCV/highgui.h"

using namespace CHImageControls;

CCHImageData::CCHImageData(void)
{
	m_bAllocatedData = FALSE;
	m_pImageData = NULL;
}

CCHImageData::CCHImageData(int nWidth, int nHeight, int nDepth, int nChannels)
{
	/* depth info
	IPL_DEPTH_8U - unsigned 8-bit integers
	IPL_DEPTH_8S - signed 8-bit integers
	IPL_DEPTH_16U - unsigned 16-bit integers
	IPL_DEPTH_16S - signed 16-bit integers
	IPL_DEPTH_32S - signed 32-bit integers
	IPL_DEPTH_32F - single precision floating-point numbers
	IPL_DEPTH_64F - double precision floating-point numbers
	*/
	m_pImageData = cvCreateImage(cvSize(nWidth, nHeight), nDepth, nChannels);
	if (m_pImageData) m_bAllocatedData = TRUE;
}

CCHImageData::~CCHImageData(void)
{
	ReleaseImage();
}

BOOL CCHImageData::GetImageExist(void) const	
{ 
	return m_pImageData ? TRUE: FALSE; 
}

BOOL CCHImageData::GetAllocatedData( void ) const
{
	return m_bAllocatedData;
}

int CCHImageData::GetHeight(void) const
{ 
	return GetImageExist() ? m_pImageData->height : 0; 
}

int CCHImageData::GetWidth(void) const		
{ 
	return GetImageExist() ? m_pImageData->width : 0; 
}

int CCHImageData::GetWidthStep(void) const	
{ 
	return GetImageExist() ? m_pImageData->widthStep : 0; 
}

int CCHImageData::GetDepth(void) const		
{ 
	return GetImageExist() ? m_pImageData->depth : 0; 
}

int CCHImageData::GetChannels(void) const	
{ 
	return GetImageExist() ? m_pImageData->nChannels : 0; 
}

int	CCHImageData::GetBpp(void) const		
{ 
	return GetImageExist() ? (m_pImageData->depth & 255)*m_pImageData->nChannels : 0; 
}

int	CCHImageData::GetImageSize(void) const
{
	return GetImageExist() ? m_pImageData->imageSize: 0; 
}

int	CCHImageData::GetPixelValue(int x, int y) const
{
	if (!GetImageExist()) return -1;

	if (GetDepth()!=IPL_DEPTH_8U) return -1;

	CvScalar sValue = cvGet2D(m_pImageData, y, x);

	return int(sValue.val[0]);
}

int	CCHImageData::SetPixelValue(int x, int y, int nR, int nG, int nB)
{
	if (!GetImageExist()) return 0;

	if (GetDepth()!=IPL_DEPTH_8U) return 0;

	CvScalar sValue;
	sValue.val[0] = nR;
	sValue.val[1] = nG;
	sValue.val[2] = nB;
	
	cvSet2D(m_pImageData, y, x, sValue);

	return 1;
}


BOOL CCHImageData::LoadImage(const CString& strFilename)
{
	ReleaseImage();

USES_CONVERSION;
	char str_filename[200];

#ifdef X
	sprintf_s(str_filename, "%s", W2A(strFilename));
#else
	sprintf_s(str_filename, "%s", strFilename);
#endif
	
	m_pImageData = cvLoadImage(str_filename, CV_LOAD_IMAGE_ANYCOLOR);

	if (m_pImageData==NULL) return FALSE;
	m_bAllocatedData = TRUE;

	return TRUE;
}

BOOL CCHImageData::SaveImage(const CString& strFilename, int nQiality)
{
	if (!GetImageExist()) return FALSE;

	// ext check
	int pos = strFilename.ReverseFind(_T('.'));
	if (pos==-1) return FALSE;

	CString extName = strFilename.Mid(pos+1, 3);

USES_CONVERSION;
	char str_filename[200];

#ifdef X
	sprintf_s(str_filename, "%s", W2A(strFilename));
#else
	sprintf_s(str_filename, "%s", strFilename);
#endif

	int nReturnValue = 0;

	if (extName.CompareNoCase(_T("bmp"))==0)
	{
		nReturnValue = cvSaveImage(str_filename, m_pImageData);
	}
	else if (extName.CompareNoCase(_T("jpg"))==0)
	{
		int param[3];
		param[0] = CV_IMWRITE_JPEG_QUALITY;     
		param[1] = nQiality;     
		param[2] = 0; 
		nReturnValue = cvSaveImage(str_filename, m_pImageData, param);
	}

	if (nReturnValue==0) return FALSE;

	return TRUE;
}

void CCHImageData::ReleaseImage(void)
{
	if (m_pImageData!=NULL)
	{
		if (m_bAllocatedData)
			cvReleaseImage(&m_pImageData);
		else
			cvReleaseImageHeader(&m_pImageData);
	}
	m_bAllocatedData = FALSE;
	m_pImageData = NULL;
}

BOOL CCHImageData::CreateImage(int nWidth, int nHeight, int nDepth, int nChannels)
{
	/* depth info
	IPL_DEPTH_8U - unsigned 8-bit integers
	IPL_DEPTH_8S - signed 8-bit integers
	IPL_DEPTH_16U - unsigned 16-bit integers
	IPL_DEPTH_16S - signed 16-bit integers
	IPL_DEPTH_32S - signed 32-bit integers
	IPL_DEPTH_32F - single precision floating-point numbers
	IPL_DEPTH_64F - double precision floating-point numbers
	*/

	ReleaseImage();
	m_pImageData = cvCreateImage(cvSize(nWidth, nHeight), nDepth, nChannels);
	if (m_pImageData==NULL) return FALSE;
	m_bAllocatedData = TRUE;

	return TRUE;
}

BOOL CCHImageData::CreateImageHeader( int nWidth, int nHeight, int nDepth/*=8*/, int nChannels/*=1*/ )
{
	/* depth info
	IPL_DEPTH_8U - unsigned 8-bit integers
	IPL_DEPTH_8S - signed 8-bit integers
	IPL_DEPTH_16U - unsigned 16-bit integers
	IPL_DEPTH_16S - signed 16-bit integers
	IPL_DEPTH_32S - signed 32-bit integers
	IPL_DEPTH_32F - single precision floating-point numbers
	IPL_DEPTH_64F - double precision floating-point numbers
	*/

	ReleaseImage();
	m_pImageData = cvCreateImageHeader(cvSize(nWidth, nHeight), nDepth, nChannels);
	if (m_pImageData==NULL) return FALSE;
	m_bAllocatedData = FALSE;

	return TRUE;
}

char* CCHImageData::GetImageBuffer(void)	
{ 
	return (GetImageExist()) ? m_pImageData->imageData : NULL; 
}

char* CCHImageData::GetImageBufferOrigin(void)	
{ 
	return (GetImageExist()) ? m_pImageData->imageDataOrigin : NULL; 
}

void CCHImageData::ShowImage(HDC hDC, const CRect& dstRect)
{
	if (!GetImageExist()) return;

	if (GetDepth()!=IPL_DEPTH_8U) return;

	if (m_pImageData->imageData==NULL) return;

	uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
	BITMAPINFO* bmi = (BITMAPINFO*)buffer;
	int bmp_w = m_pImageData->width, bmp_h = m_pImageData->height;

	SetStretchBltMode(hDC, COLORONCOLOR );

	FillBitmapInfo(bmi, bmp_w, bmp_h, GetBpp(), m_pImageData->origin );

	::StretchDIBits(
		hDC,
		dstRect.left, 
		dstRect.top, 
		dstRect.Width(), 
		dstRect.Height(),
		0, 
		0, 
		bmp_w, 
		bmp_h,
		m_pImageData->imageData, 
		bmi, 
		DIB_RGB_COLORS, 
		SRCCOPY );
}

void CCHImageData::ShowImage(HDC hDC, const CRect& srcRect, const CRect& dstRect)
{
	if (!GetImageExist()) return;

	if (GetDepth()!=IPL_DEPTH_8U) return;

	if (m_pImageData->imageData==NULL) return;

	uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
	BITMAPINFO* bmi = (BITMAPINFO*)buffer;
	int bmp_w = m_pImageData->width, bmp_h = m_pImageData->height;

	SetStretchBltMode(hDC, COLORONCOLOR);

	FillBitmapInfo(bmi, bmp_w, bmp_h, GetBpp(), m_pImageData->origin );

	::StretchDIBits(
		hDC,
		dstRect.left, 
		dstRect.top, 
		dstRect.Width(), 
		dstRect.Height(),
		srcRect.left, 
		srcRect.top, 
		srcRect.Width(), 
		srcRect.Height(),
		m_pImageData->imageData, 
		bmi, 
		DIB_RGB_COLORS, 
		SRCCOPY );
}

void CCHImageData::ShowImage(HDC hDC, int nSx, int nSy, int nWidth, int nHeight, int nFromX, int nFromY)
{
	if (!GetImageExist()) return;

	if (GetDepth()!=IPL_DEPTH_8U) return;

	uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
	BITMAPINFO* bmi = (BITMAPINFO*)buffer;
	int bmp_w = m_pImageData->width, bmp_h = m_pImageData->height;

	FillBitmapInfo( bmi, bmp_w, bmp_h, GetBpp(), m_pImageData->origin );

	nFromX = MIN( MAX( nFromX, 0 ), bmp_w - 1 );
	nFromY = MIN( MAX( nFromY, 0 ), bmp_h - 1 );

	int sw = MAX( MIN( bmp_w - nFromX, nWidth ), 0 );
	int sh = MAX( MIN( bmp_h - nFromY, nHeight ), 0 );

	SetDIBitsToDevice(
		hDC, 
		nSx, 
		nSy, 
		sw, 
		sh, 
		nFromX, 
		nFromY, 
		nFromY, 
		sh,
		m_pImageData->imageData + nFromY*m_pImageData->widthStep,
		bmi, 
		DIB_RGB_COLORS );
}

void CCHImageData::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;
		}
	}
}

BOOL CCHImageData::ClearImage(int nValue)
{
	if (!GetImageExist()) return FALSE;

	cvSet(m_pImageData, CV_RGB(nValue, nValue, nValue));

	return TRUE;
}

BOOL CCHImageData::CopyImageTo(CCHImageData *pToImage)
{
	if (pToImage==NULL) return FALSE;

	if (!GetImageExist()) return FALSE;

	pToImage->ReleaseImage();

	pToImage->m_pImageData = cvCloneImage(m_pImageData);
	pToImage->m_bAllocatedData = TRUE;

	return TRUE;
}

BOOL CCHImageData::CopyImageTo(IplImage *pToImage)
{
	if (!GetImageExist()) return FALSE;

	if (pToImage!=NULL) cvReleaseImage(&pToImage);

	pToImage = cvCloneImage(m_pImageData);

	return TRUE;
}

BOOL CCHImageData::CopyImageFrom(const CCHImageData *pFromImage)
{
	if (pFromImage==NULL) return FALSE;

	if (!pFromImage->GetImageExist()) return FALSE;

	ReleaseImage();

	m_pImageData = cvCloneImage(pFromImage->m_pImageData);
	m_bAllocatedData = TRUE;

	return TRUE;
}

BOOL CCHImageData::CopyImageFrom(const IplImage *pFromImage)
{
	if (pFromImage==NULL) return FALSE;

	ReleaseImage();

	m_pImageData = cvCloneImage(pFromImage);
	m_bAllocatedData = TRUE;

	return TRUE;
}

BOOL CCHImageData::GetSubImage(int nSx, int nSy, int nWidth, int nHeight, CCHImageData *pGetImage)
{
	if (pGetImage==NULL) return FALSE;
	if (!GetImageExist()) return FALSE;
	if (nSx < 0 || nSy < 0) return FALSE;
	if ((nSx+nWidth) > GetWidth() || (nSy+nHeight) > GetHeight()) return FALSE;

	// set roi
	CvRect orgROI = cvGetImageROI(m_pImageData);
	cvSetImageROI(m_pImageData, cvRect(nSx, nSy, nWidth, nHeight));

	// create out image
	pGetImage->ReleaseImage();
	pGetImage->CreateImage(nWidth, nHeight, GetDepth(), GetChannels());

	// copy roi image
	cvCopy(m_pImageData, pGetImage->m_pImageData);
	pGetImage->m_bAllocatedData = TRUE;

	// set origin (mch)
	pGetImage->m_pImageData->origin = m_pImageData->origin;

	// set org roi
	cvSetImageROI(m_pImageData, orgROI);

	return TRUE;
}

BOOL CCHImageData::GetSubImage(int nSx, int nSy, int nWidth, int nHeight, int nChannels, BYTE *pGetBuffer)
{
	if (pGetBuffer==NULL) return FALSE;
	if (!GetImageExist()) return FALSE;
	if (nChannels!=GetChannels()) return FALSE;
	if (IPL_DEPTH_8U!=GetDepth()) return FALSE;
	if (nSx < 0 || nSy < 0) return FALSE;
	if ((nSx+nWidth) > GetWidth() || (nSy+nHeight) > GetHeight()) return FALSE;

	// set roi
	CvRect orgROI = cvGetImageROI(m_pImageData);
	cvSetImageROI(m_pImageData, cvRect(nSx, nSy, nWidth, nHeight));

	// create out image
	IplImage* tmpImage;
	tmpImage = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_8U, nChannels);

	// copy roi image
	cvCopy(m_pImageData, tmpImage);

	int nGetStep = nWidth * nChannels;
	int nTmpStep = tmpImage->widthStep;	
	if (nGetStep==nTmpStep)
	{
		memcpy(pGetBuffer, tmpImage->imageData, sizeof(char)*tmpImage->imageSize);
	}
	else
	{
		for (int i=0; i<tmpImage->height; i++)
		{
			memcpy(&pGetBuffer[i*nGetStep], &tmpImage->imageData[i*nTmpStep], sizeof(char)*nGetStep);
		}
	}

	// set org roi
	cvSetImageROI(m_pImageData, orgROI);
	cvReleaseImage(&tmpImage);

	return TRUE;
}

BOOL CCHImageData::GetSubImage(const CRect& rtRect, CCHImageData *pGetImage)		
{ 
	return GetSubImage(rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), pGetImage); 
}

BOOL CCHImageData::GetSubImage(const CRect& rtRect, int nBpp, BYTE *pGetBuffer)	
{ 
	return GetSubImage(rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), nBpp, pGetBuffer); 
}

BOOL CCHImageData::GetBandImage(int nColorBand, CCHImageData* pGetImage)
{
	if (pGetImage==NULL) return FALSE;
	if (!GetImageExist()) return FALSE;
	if (GetDepth()!=IPL_DEPTH_8U) return FALSE;

	if (nColorBand==BandTypeColor || m_pImageData->nChannels<3)
	{
		pGetImage->ReleaseImage();
		pGetImage->m_pImageData = cvCloneImage(m_pImageData);
		pGetImage->m_bAllocatedData = TRUE;
		return TRUE;
	}

	if (!pGetImage->CreateImage(GetWidth(), GetHeight(), IPL_DEPTH_8U, 1)) return FALSE;

	int nChannelIndex = -1;



	char cChannelName;

	switch(nColorBand)
	{
	case BandTypeBlue:
		cChannelName = _T('B');
		break;

	case BandTypeGreen:
		cChannelName = _T('G');
		break;

	case BandTypeRed:
		cChannelName = _T('R');
		break;

	case BandTypeGray:
		cvCvtColor(m_pImageData, pGetImage->m_pImageData, CV_RGB2GRAY);

		// set origin (mch)
		pGetImage->m_pImageData->origin = m_pImageData->origin;
		return TRUE;

	default:
		pGetImage->ReleaseImage();
		return FALSE;
	}

	for (int i=0; i<m_pImageData->nChannels; i++)
	{
		if (m_pImageData->channelSeq[i]==cChannelName)
		{
			nChannelIndex = i;
			break;
		}
	}

	if (nChannelIndex==-1 || nChannelIndex>=m_pImageData->nChannels) return FALSE;

	switch(nChannelIndex)
	{
	case 0:
		cvCvtPixToPlane(m_pImageData, pGetImage->m_pImageData, NULL, NULL, NULL);
		break;
	case 1:
		cvCvtPixToPlane(m_pImageData, NULL, pGetImage->m_pImageData, NULL, NULL);
		break;
	case 2:
		cvCvtPixToPlane(m_pImageData, NULL, NULL, pGetImage->m_pImageData, NULL);
		break;
	case 3:
		cvCvtPixToPlane(m_pImageData, NULL, NULL, NULL, pGetImage->m_pImageData);
		break;
	}

	// set origin (mch)
	pGetImage->m_pImageData->origin = m_pImageData->origin;

	return TRUE;
}

BOOL CCHImageData::GetBandImage(int nColorBand, int nSx, int nSy, int nWidth, int nHeight, CCHImageData* pGetImage)
{
	CCHImageData tmpImage;

	if (!GetSubImage(nSx, nSy, nWidth, nHeight, &tmpImage)) return FALSE;

	if (!tmpImage.GetBandImage(nColorBand, pGetImage)) return FALSE;

	return TRUE;
}

BOOL CCHImageData::GetBandImage(int nColorBand, int nSx, int nSy, int nWidth, int nHeight, BYTE* pGetBuffer)
{
	CCHImageData tmpImage;

	if (!GetBandImage(nColorBand, &tmpImage)) return FALSE;

	if (!tmpImage.GetSubImage(nSx, nSy, nWidth, nHeight, 1, pGetBuffer)) return FALSE;

	return TRUE;
}


BOOL CCHImageData::GetBandImage(int nColorBand, const CRect& rtRect, CCHImageData* pGetImage)	
{ 
	return GetBandImage(nColorBand, rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), pGetImage); 
}

BOOL CCHImageData::GetBandImage(int nColorBand, const CRect& rtRect, BYTE* pGetBuffer)			
{ 
	return GetBandImage(nColorBand, rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), pGetBuffer); 
}

BOOL CCHImageData::SetSubImage(int nSx, int nSy, int nWidth, int nHeight, CCHImageData* pSetImage)
{
	if (pSetImage==NULL) return FALSE;
	if (!GetImageExist() || !pSetImage->GetImageExist()) return FALSE;
	if (GetDepth()!=pSetImage->GetDepth() || GetChannels()!=pSetImage->GetChannels()) return FALSE;
	if (nWidth!=pSetImage->GetWidth() || nHeight!=pSetImage->GetHeight()) return FALSE;
	if (nSx < 0 || nSy < 0) return FALSE;
	if ((nSx+nWidth) > GetWidth() || (nSy+nHeight) > GetHeight()) return FALSE;

	CvRect orgROI = cvGetImageROI(m_pImageData);
	cvSetImageROI(m_pImageData, cvRect(nSx, nSy, nWidth, nHeight));

	CvRect setROI = cvGetImageROI(pSetImage->m_pImageData);
	cvResetImageROI(pSetImage->m_pImageData);

	cvCopy(pSetImage->m_pImageData, m_pImageData);
	m_bAllocatedData = TRUE;

	// set origin (mch)
	m_pImageData->origin = pSetImage->m_pImageData->origin;

	cvSetImageROI(m_pImageData, orgROI);
	cvSetImageROI(pSetImage->m_pImageData, setROI);

	return TRUE;
}

BOOL CCHImageData::SetSubImage(int nSx, int nSy, int nWidth, int nHeight, int nChannels, BYTE *pSetBuffer)
{
	if (pSetBuffer==NULL) return FALSE;
	if (!GetImageExist()) return FALSE;
	if (nChannels!=GetChannels()) return FALSE;
	if (GetDepth()!=IPL_DEPTH_8U) return FALSE;
	if (nSx < 0 || nSy < 0) return FALSE;
	if ((nSx+nWidth) > GetWidth() || (nSy+nHeight) > GetHeight()) return FALSE;

	IplImage *tmpImage;
	tmpImage = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_8U, nChannels);

	int nSetStep = nWidth * nChannels;
	int nTmpStep = tmpImage->widthStep;	
	if (nSetStep==nTmpStep)
	{
		memcpy(tmpImage, pSetBuffer, sizeof(char)*tmpImage->imageSize);
	}
	else
	{
		for (int i=0; i<tmpImage->height; i++)
		{
			memcpy(&tmpImage->imageData[i*nTmpStep], &pSetBuffer[i*nSetStep], sizeof(char)*nSetStep);
		}
	}

	// set roi
	CvRect orgROI = cvGetImageROI(m_pImageData);
	cvSetImageROI(m_pImageData, cvRect(nSx, nSy, nWidth, nHeight));

	cvCopy(tmpImage, m_pImageData);
	m_bAllocatedData = TRUE;

	// set org roi
	cvSetImageROI(m_pImageData, orgROI);
	cvReleaseImage(&tmpImage);

	return TRUE;
}

BOOL CCHImageData::SetSubImage(const CRect& rtRect, CCHImageData *pSetImage)
{ 
	return SetSubImage(rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), pSetImage); 
}

BOOL CCHImageData::SetSubImage(const CRect& rtRect, int nBpp, BYTE *pSetBuffer)	
{ 
	return SetSubImage(rtRect.left, rtRect.top, rtRect.Width(), rtRect.Height(), nBpp, pSetBuffer); 
}

IplImage* CCHImageData::GetIplImage(void)
{ 
	return m_pImageData; 
}

BOOL CCHImageData::DrawLine(CPoint ptPos1, CPoint ptPos2, DWORD nColor, int nThickness, int nLineType, int nShift )
{
	if (!GetImageExist()) return FALSE;

	CvPoint pt1 = cvPoint(ptPos1.x, ptPos1.y);
	CvPoint pt2 = cvPoint(ptPos2.x, ptPos2.y);
	CvScalar color = cvScalar(GetBValue(nColor), GetGValue(nColor), GetRValue(nColor), 0);

	cvLine(m_pImageData, pt1, pt2, color, nThickness, nLineType, nShift);

	return TRUE;
}

BOOL CCHImageData::DrawRectangle(CPoint ptPos1, CPoint ptPos2, DWORD nColor, int nThickness, int nLineType, int nShift )
{
	if (!GetImageExist()) return FALSE;

	CvPoint pt1 = cvPoint(ptPos1.x, ptPos1.y);
	CvPoint pt2 = cvPoint(ptPos2.x, ptPos2.y);
	CvScalar color = cvScalar(GetBValue(nColor), GetGValue(nColor), GetRValue(nColor), 0);

	cvRectangle(m_pImageData, pt1, pt2, color, nThickness, nLineType, nShift);

	return TRUE;
}

BOOL CCHImageData::DrawCircle(CPoint ptCenter, int nRadius, DWORD nColor, int nThickness, int nLineType, int nShift )
{
	if (!GetImageExist()) return FALSE;

	if (nRadius<0) return FALSE;

	CvPoint center = cvPoint(ptCenter.x, ptCenter.y);
	CvScalar color = cvScalar(GetBValue(nColor), GetGValue(nColor), GetRValue(nColor), 0);

	cvCircle(m_pImageData, center, nRadius, color, nThickness, nLineType, nShift);

	return TRUE;
}

BOOL CCHImageData::DrawEllipse(CPoint ptCenter, CPoint ptSize, double dAngle, DWORD nColor, int nThickness, int nLineType, int nShift )
{
	if (!GetImageExist()) return FALSE;

	CvBox2D box;
	box.center.x	= (float)ptCenter.x;
	box.center.y	= (float)ptCenter.y;
	box.size.width	= (float)ptSize.x;
	box.size.height = (float)ptSize.y;
	box.angle		= (float)dAngle;

	CvScalar color = cvScalar(GetBValue(nColor), GetGValue(nColor), GetRValue(nColor), 0);
	cvEllipseBox(m_pImageData, box, color, nThickness, nLineType, nShift);

	return TRUE;
}

BOOL CCHImageData::DrawText(CPoint ptPoint, DWORD nColor, const CString& strText)
{
	if (!GetImageExist()) return FALSE;

	CvPoint point = cvPoint(ptPoint.x, ptPoint.y);
	CvScalar color = cvScalar(GetBValue(nColor), GetGValue(nColor), GetRValue(nColor), 0);
	CvFont font;

	cvInitFont(&font, CV_FONT_HERSHEY_PLAIN , 1.0, 1.0);// double shear=0, int thickness=1, int line_type=8 );

USES_CONVERSION;
	char str_text[200];

#ifdef X
	sprintf_s(str_text, "%s", W2A(strText));
#else
	sprintf_s(str_text, "%s", strText);
#endif

	cvPutText(m_pImageData, str_text, point, &font, color );

	return TRUE;
}

BOOL CCHImageData::DCtoIplImage(CDC* pDC, const CRect& rect)  
{
	if (pDC==NULL) return FALSE;

	int cx = rect.right - rect.left;  
	int cy = rect.bottom - rect.top;  

	if(cx <= 0 || cy <= 0) return FALSE;  

	HDC hMemDC = CreateCompatibleDC(pDC->m_hDC);  

	BITMAPINFO			bmi;  
	BITMAPINFOHEADER*	bmih = &(bmi.bmiHeader);  

	ZeroMemory(bmih, sizeof(BITMAPINFOHEADER));  
	bmih->biSize        = sizeof(BITMAPINFOHEADER);  

	bmih->biBitCount	= 24;  
	bmih->biWidth       = cx;  
	bmih->biHeight      = cy;  
	bmih->biPlanes      = 1;  

	LPVOID				pBits;  
	HBITMAP hBitmap = CreateDIBSection(pDC->m_hDC, &bmi, DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);  

	SelectObject(hMemDC, hBitmap);  

	BitBlt(hMemDC, 0, 0, cx, cy, pDC->m_hDC, rect.left, rect.top, SRCCOPY);  

	DeleteDC(hMemDC);  

	BOOL bResult = DIBtoIplImage(hBitmap);

	DeleteObject(hBitmap);

	return bResult;
}  


BOOL CCHImageData::DIBtoIplImage(HBITMAP& hbmp, HDC hdc)
{
	ReleaseImage();

	bool mustrelease = false;
	BITMAPINFO bmi;
	BITMAPINFOHEADER* bmih = &(bmi.bmiHeader);

	if (hdc == NULL) 
	{
		hdc = GetDC(NULL);
		mustrelease = true;
	}

	ZeroMemory(bmih, sizeof(BITMAPINFOHEADER));
	bmih->biSize = sizeof(BITMAPINFOHEADER);

	if (GetDIBits(hdc, hbmp, 0, 0, NULL, &bmi, DIB_RGB_COLORS)) 
	{
		int height	= (bmih->biHeight > 0) ? bmih->biHeight : -bmih->biHeight;
		int origin	= (bmih->biHeight > 0);

		if (origin)
		{
			_IplImage *pTempImage	= cvCreateImage(cvSize(bmih->biWidth, height),IPL_DEPTH_8U, 3);
			m_pImageData			= cvCreateImage(cvSize(bmih->biWidth, height),IPL_DEPTH_8U, 3);
			m_bAllocatedData		= TRUE;
			pTempImage->origin		= origin;
			bmih->biBitCount		= 24;
			bmih->biCompression		= BI_RGB;
			GetDIBits(hdc, hbmp, 0, height, pTempImage->imageData, &bmi,	DIB_RGB_COLORS);

			cvFlip(pTempImage, m_pImageData, 0);

			cvReleaseImage(&pTempImage);
		}
		else
		{
			m_pImageData			= cvCreateImage(cvSize(bmih->biWidth, height),IPL_DEPTH_8U, 3);
			m_bAllocatedData		= TRUE;
			m_pImageData->origin	= origin;
			bmih->biBitCount		= 24;
			bmih->biCompression		= BI_RGB;

			GetDIBits(hdc, hbmp, 0, height, m_pImageData->imageData, &bmi,	DIB_RGB_COLORS);
		}
	}

	if (mustrelease)
	{
		ReleaseDC(NULL, hdc);
	}

	return TRUE;
}

BOOL CCHImageData::SetImageDataPtr( char* pPtr )
{
	if (m_pImageData==NULL) return FALSE;

	if (m_pImageData->imageData) return FALSE;

	if (m_pImageData->imageDataOrigin) return FALSE;

	m_pImageData->imageData = m_pImageData->imageDataOrigin = pPtr;

	return TRUE;
}