CvvImage.h和CvvImage.cpp

CvvImage.h和CvvImage.cpp

CvvImage.h

/**************************************************************************************************/
// 版权声明：Copyright (c) 2017. All rights reserved.
// 许可版本：Corporation　&　Enterprise
// 文件名称：CVVIMAGE.H
// 文件功能：CVVIMAGE类头文件
// 软件版本：Version 1.0
// 作者扣扣：370711753
// 修改时间：2017/11/04 20:57:31
// 修订说明：最初版本 1.0.0.00
/**************************************************************************************************/
#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF

// 包含头文件
#include <opencv/cv.h>
#include <opencv/highgui.h>

// CvvImage 类定义
class CvvImage
{
public:
	CvvImage();								// 标准构造函数
	virtual ~CvvImage();							// 标准析构函数

	// 创建图像（RGB图像或者灰度图像）
	virtual bool Create(int width,
		int height,
		int bits_per_pixel,
		int image_origin = 0);

	// 从文件中加载图像
	virtual bool Load(const char* filename,
		int desired_color = 1);

	// 从图像文件中生成矩形
	virtual bool LoadRect(const char* filename,
		int desired_color,
		CvRect r);

#if defined WIN32 || defined _WIN32
	virtual bool LoadRect(const char* filename,
		int desired_color,
		RECT r)
	{
		return LoadRect(filename, desired_color,
			cvRect(r.left, r.top, r.right - r.left, r.bottom - r.top));
	}
#endif

	// 保存图像到指定文件
	virtual bool Save(const char* filename);

	// 复制图像
	virtual void CopyOf(CvvImage& image,
		int desired_color = -1);
	virtual void CopyOf(IplImage* img,
		int desired_color = -1);

	// 获取图像
	IplImage* GetImage()
	{
		return m_img;
	};

	// 销毁图像
	virtual void Destroy(void);

	// 获取图像宽度
	int Width()
	{
		return !m_img ? 0 : !m_img->roi ? m_img->width : m_img->roi->width;
	};

	// 获取图像高度
	int Height()
	{
		return !m_img ? 0 : !m_img->roi ? m_img->height : m_img->roi->height;
	};

	// 获取图像颜色深度
	int Bpp()
	{
		return m_img ? (m_img->depth & 255)*m_img->nChannels : 0;
	};

	// 填充图像
	virtual void Fill(int color);

	// 在 HighGUI 窗口中显示图像
	virtual void Show(const char* window);

#if defined WIN32 || defined _WIN32
	// 在指定 DC 中显示图像
	virtual void Show(HDC dc,
		int x,
		int y,
		int width,
		int height,
		int from_x = 0,
		int from_y = 0);

	// 将当前图像ROI绘制到目标DC的指定矩形
	virtual void DrawToHDC(HDC hDCDst,
		RECT* pDstRect);
#endif

protected:
	// 图像
	IplImage*	m_img;
};

// 宏定义
typedef CvvImage CImage;

#endif
 

CvvImage.cpp

#include "stdafx.h"
#include "CvvImage.h"
 
/**************************************************************************************************/
// 函数名称：NormalizeRect()
// 函数功能：静态内嵌函数：普通矩形标准化。
// 函数参数：
//     输入参数: RECT r：普通矩形。
//     输出参数: 无
// 返 回 值：CV_INLINE RECT：普通矩形。
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:07:03
/**************************************************************************************************/
CV_INLINE RECT NormalizeRect(RECT r);
CV_INLINE RECT NormalizeRect(RECT r)
{
	int t = 0;

	if( r.left > r.right )
	{
		t = r.left;
		r.left = r.right;
		r.right = t;
	}

	if( r.top > r.bottom )
	{
		t = r.top;
		r.top = r.bottom;
		r.bottom = t;
	}

	return r;
}

/**************************************************************************************************/
// 函数名称：RectToCvRect()
// 函数功能：静态内嵌函数：普通矩形转化为CvRect矩形。
// 函数参数：
//     输入参数: RECT sr：普通矩形。
//     输出参数: 无
// 返 回 值：CV_INLINE CvRect：CvRect矩形。
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:08:18
/**************************************************************************************************/
CV_INLINE CvRect RectToCvRect(RECT sr);
CV_INLINE CvRect RectToCvRect(RECT sr)
{
	sr = NormalizeRect( sr );
	return cvRect(sr.left, sr.top, sr.right - sr.left, sr.bottom - sr.top);
}

/**************************************************************************************************/
// 函数名称：CvRectToRect()
// 函数功能：静态内嵌函数：CvRect矩形转化为普通矩形。
// 函数参数：
//     输入参数: CvRect sr：CvRect矩形。
//     输出参数: 无
// 返 回 值：CV_INLINE RECT：普通矩形。
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:09:20
/**************************************************************************************************/
CV_INLINE RECT CvRectToRect(CvRect sr);
CV_INLINE RECT CvRectToRect(CvRect sr)
{
	RECT dr;
	dr.left = sr.x;
	dr.top = sr.y;
	dr.right = sr.x + sr.width;
	dr.bottom = sr.y + sr.height;

	return dr;
}

/**************************************************************************************************/
// 函数名称：RectToROI()
// 函数功能：静态内嵌函数：普通矩形转化为图像区域。
// 函数参数：
//     输入参数: RECT r：普通矩形。
//     输出参数: 无
// 返 回 值：CV_INLINE IplROI：图像区域。
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:11:24
/**************************************************************************************************/
CV_INLINE IplROI RectToROI(RECT r);
CV_INLINE IplROI RectToROI(RECT r)
{
	IplROI roi;
	r = NormalizeRect( r );
	roi.xOffset = r.left;
	roi.yOffset = r.top;
	roi.width = r.right - r.left;
	roi.height = r.bottom - r.top;
	roi.coi = 0;

	return roi;
}

/**************************************************************************************************/
// 函数名称：FillBitmapInfo()
// 函数功能：全局函数：生成位图信息。
// 函数参数：
//     输入参数: BITMAPINFO * bmi：位图信息指针。
//     输入参数: int width：位图宽度。
//     输入参数: int height：位图高度。
//     输入参数: int bpp：位图深度。
//     输入参数: int origin：位图原点。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:12:50
/**************************************************************************************************/
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;
		}
	}
	return;
}

/**************************************************************************************************/
// 函数名称：CvvImage()
// 函数功能：标准构造函数。
// 函数参数：
//     输入参数: 无
//     输出参数: 无
// 返 回 值：无
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:15:03
/**************************************************************************************************/
CvvImage::CvvImage()
{
	m_img = NULL;
}

/**************************************************************************************************/
// 函数名称：Destroy()
// 函数功能：销毁图像
// 函数参数：
//     输入参数: 无
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:15:27
/**************************************************************************************************/
void CvvImage::Destroy()
{
	cvReleaseImage(&m_img);
}

/**************************************************************************************************/
// 函数名称：~CvvImage()
// 函数功能：标准析构函数.
// 函数参数：
//     输入参数: 无
//     输出参数: 无
// 返 回 值：无
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:15:52
/**************************************************************************************************/
CvvImage::~CvvImage()
{
	Destroy();
}

/**************************************************************************************************/
// 函数名称：Create()
// 函数功能：创建图像（RGB图像或者灰度图像）.
// 函数参数：
//     输入参数: int w：图像宽度。
//     输入参数: int h：图像高度。
//     输入参数: int bpp：图像深度。
//     输入参数: int origin：图像原点。
//     输出参数: 无
// 返 回 值：bool
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:16:13
/**************************************************************************************************/
bool CvvImage::Create(int w,
					  int h,
					  int bpp,
					  int origin)
{
	const unsigned max_img_size = 10000;

	if( (bpp != 8 && bpp != 24 && bpp != 32) ||
		(unsigned)w >= max_img_size || (unsigned)h >= max_img_size ||
		(origin != IPL_ORIGIN_TL && origin != IPL_ORIGIN_BL))
	{
		assert(0); // most probably, it is a programming error
		return false;
	}

	if( !m_img || Bpp() != bpp || m_img->width != w || m_img->height != h )
	{
		if( m_img && m_img->nSize == sizeof(IplImage))
			Destroy();

		/* prepare IPL header */
		m_img = cvCreateImage( cvSize( w, h ), IPL_DEPTH_8U, bpp/8 );
	}

	if( m_img )
		m_img->origin = origin == 0 ? IPL_ORIGIN_TL : IPL_ORIGIN_BL;

	return m_img != 0;
}

/**************************************************************************************************/
// 函数名称：CopyOf()
// 函数功能：复制图像。
// 函数参数：
//     输入参数: CvvImage & image：源图像。
//     输入参数: int desired_color：指定颜色。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:17:07
/**************************************************************************************************/
void CvvImage::CopyOf(CvvImage& image,
					  int desired_color)
{
	IplImage* img = image.GetImage();
	if(img)
	{
		CopyOf(img, desired_color);
	}
	return;
}

#define HG_IS_IMAGE(img) \
	((img) != 0 && ((const IplImage*)(img))->nSize == sizeof(IplImage) && \
	((IplImage*)img)->imageData != 0)

/**************************************************************************************************/
// 函数名称：CopyOf()
// 函数功能：复制图像.
// 函数参数：
//     输入参数: CvvImage & image：源图像。
//     输入参数: int desired_color：指定颜色。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:18:35
/**************************************************************************************************/
void CvvImage::CopyOf(IplImage* img,
					  int desired_color)
{
	if(HG_IS_IMAGE(img))
	{
		int color = desired_color;
		CvSize size = cvGetSize( img ); 

		if( color < 0 )
			color = img->nChannels > 1;

		if( Create( size.width, size.height,
			(!color ? 1 : img->nChannels > 1 ? img->nChannels : 3)*8,
			img->origin ))
		{
			cvConvertImage( img, m_img, 0 );
		}
	}
	return;
}

/**************************************************************************************************/
// 函数名称：Load()
// 函数功能：从文件中加载图像.
// 函数参数：
//     输入参数: const char * filename：图像文件名称。
//     输入参数: int desired_color：指定颜色。
//     输出参数: 无
// 返 回 值：bool
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:19:16
/**************************************************************************************************/
bool CvvImage::Load(const char* filename,
					int desired_color)
{
	IplImage* img = cvLoadImage( filename, desired_color );
	if( !img )
		return false;

	CopyOf( img, desired_color );
	cvReleaseImage( &img );

	return true;
}

/**************************************************************************************************/
// 函数名称：LoadRect()
// 函数功能：从图像文件中生成矩形。
// 函数参数：
//     输入参数: const char * filename：图像文件名称。
//     输入参数: int desired_color：指定颜色。
//     输入参数: CvRect r：CvRect矩形。
//     输出参数: 无
// 返 回 值：bool
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:19:56
/**************************************************************************************************/
bool CvvImage::LoadRect(const char* filename,
						int desired_color,
						CvRect r)
{
	if( r.width < 0 || r.height < 0 ) return false;

	IplImage* img = cvLoadImage( filename, desired_color );
	if( !img )
		return false;

	if( r.width == 0 || r.height == 0 )
	{
		r.width = img->width;
		r.height = img->height;
		r.x = r.y = 0;
	}

	if( r.x > img->width || r.y > img->height ||
		r.x + r.width < 0 || r.y + r.height < 0 )
	{
		cvReleaseImage( &img );
		return false;
	}

	/* truncate r to source image */
	if( r.x < 0 )
	{
		r.width += r.x;
		r.x = 0;
	}
	if( r.y < 0 )
	{
		r.height += r.y;
		r.y = 0;
	}

	if( r.x + r.width > img->width )
		r.width = img->width - r.x;

	if( r.y + r.height > img->height )
		r.height = img->height - r.y;

	cvSetImageROI( img, r );
	CopyOf( img, desired_color );

	cvReleaseImage( &img );
	return true;
}

/**************************************************************************************************/
// 函数名称：Save()
// 函数功能：保存图像到指定文件。
// 函数参数：
//     输入参数: const char * filename：指定图像文件名称。
//     输出参数: 无
// 返 回 值：bool
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:21:06
/**************************************************************************************************/
bool CvvImage::Save(const char* filename)
{
	if( !m_img )
	{
		return false;
	}
	cvSaveImage(filename, m_img);
	return true;
}

/**************************************************************************************************/
// 函数名称：Show()
// 函数功能：在 HighGUI 窗口中显示图像。
// 函数参数：
//     输入参数: const char * window：HighGUI 窗口。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:22:07
/**************************************************************************************************/
void CvvImage::Show(const char* window)
{
	if(m_img)
	{
		cvShowImage( window, m_img );
	}
	return;
}


/**************************************************************************************************/
// 函数名称：Show()
// 函数功能：在指定 DC 中显示图像。
// 函数参数：
//     输入参数: HDC dc：窗口句柄。
//     输入参数: int x：左上角X坐标。
//     输入参数: int y：左上角Y坐标。
//     输入参数: int w：图像宽度。
//     输入参数: int h：图像高度。
//     输入参数: int from_x：图像左上角X坐标。
//     输入参数: int from_y：图像左上角Y坐标。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:23:03
/**************************************************************************************************/
void CvvImage::Show(HDC dc, int x, int y, int w, int h, int from_x, int from_y)
{
	if(m_img && m_img->depth == IPL_DEPTH_8U)
	{
		uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
		BITMAPINFO* bmi = (BITMAPINFO*)buffer;
		int bmp_w = m_img->width, bmp_h = m_img->height;

		FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );

		from_x = MIN( MAX( from_x, 0 ), bmp_w - 1 );
		from_y = MIN( MAX( from_y, 0 ), bmp_h - 1 );

		int sw = MAX( MIN( bmp_w - from_x, w ), 0 );
		int sh = MAX( MIN( bmp_h - from_y, h ), 0 );

		SetDIBitsToDevice(
			dc, x, y, sw, sh, from_x, from_y, from_y, sh,
			m_img->imageData + from_y*m_img->widthStep,
			bmi, DIB_RGB_COLORS );
	}
	return;
}

/**************************************************************************************************/
// 函数名称：DrawToHDC()
// 函数功能：将当前图像ROI绘制到目标DC的指定矩形。
// 函数参数：
//     输入参数: HDC hDCDst：目标DC。
//     输入参数: RECT * pDstRect：图像ROI。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:24:53
/**************************************************************************************************/
void CvvImage::DrawToHDC(HDC hDCDst,
						 RECT* pDstRect) 
{
	if( pDstRect && m_img && m_img->depth == IPL_DEPTH_8U && m_img->imageData )
	{
		uchar buffer[sizeof(BITMAPINFOHEADER) + 1024];
		BITMAPINFO* bmi = (BITMAPINFO*)buffer;
		int bmp_w = m_img->width, bmp_h = m_img->height;

		CvRect roi = cvGetImageROI( m_img );
		CvRect dst = RectToCvRect( *pDstRect );

		if( roi.width == dst.width && roi.height == dst.height )
		{
			Show( hDCDst, dst.x, dst.y, dst.width, dst.height, roi.x, roi.y );
			return;
		}

		if( roi.width > dst.width )
		{
			SetStretchBltMode(
				hDCDst, // handle to device context
				HALFTONE );
		}
		else
		{
			SetStretchBltMode(
				hDCDst, // handle to device context
				COLORONCOLOR );
		}

		FillBitmapInfo( bmi, bmp_w, bmp_h, Bpp(), m_img->origin );

		::StretchDIBits(
			hDCDst,
			dst.x, dst.y, dst.width, dst.height,
			roi.x, roi.y, roi.width, roi.height,
			m_img->imageData, bmi, DIB_RGB_COLORS, SRCCOPY );
	}
	return;
}

/**************************************************************************************************/
// 函数名称：Fill()
// 函数功能：填充图像。
// 函数参数：
//     输入参数: int color：指定颜色。
//     输出参数: 无
// 返 回 值：void
// 创建作者：（QQ：370711753）
// 修改日期：2017/11/04 21:26:08
/**************************************************************************************************/
void CvvImage::Fill(int color)
{
	cvSet(m_img, cvScalar(color&255,(color>>8)&255,(color>>16)&255,(color>>24)&255));
	return;
}