OpenCV 2.2.0 CvvImage的使用-天翼云

OpenCV 2.2.0 CvvImage的使用

2024-09-25 10:13:46 阅读次数：484

前几日，OpenCV 2.2.0版本出现了...但是...以前版本的CvvImage类不见了...为了能够继续使用这个类，下面把这个类的源代码贴出来，使用的时候将该代码加入到工程中便可以使用了。为了方便切换OpenCV的版本，这里用到了一些条件编译宏，来保证代码的灵活性。

不过OpenCV 2.2.0取消CvvImage这个类，一定是有它的原因的，具体可以在做实验的时候体会这些原因。

CvvImage头文件

#ifndef CVVIMAGE_CLASS_DEF
#define CVVIMAGE_CLASS_DEF

#include <cv.h>
#include <highgui.h>

/* CvvImage class definition */
class CvvImage
{
public:
CvvImage();
virtual ~CvvImage();

/* Create image (BGR or grayscale) */
virtual bool Create( int width, int height, int bits_per_pixel, int image_origin = 0 );

/* Load image from specified file */
virtual bool Load( const char* filename, int desired_color = 1 );

    /* Load rectangle from the file */
    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.right - r.left, r.bottom - ));
    }
#endif

/* Save entire image to specified file. */
virtual bool Save( const char* filename );

    /* Get copy of input image ROI */
    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);

    /* width and height of ROI */
    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 );

/* draw to highgui window */
virtual void Show( const char* window );

#if defined WIN32 || defined _WIN32
    /* draw part of image to the specified DC */
    virtual void Show( HDC dc, int x, int y, int width, int height,
        int from_x = 0, int from_y = 0 );
    /* draw the current image ROI to the specified rectangle of the destination DC */
    virtual void DrawToHDC( HDC hDCDst, RECT* pDstRect );
#endif

protected:

IplImage* m_img;
};

typedef CvvImage CImage;

#endif

CvvImage源文件

#include "public.h"

#ifndef RC_OPENCV_2_1_0 // RC_OPENCV_2_1_0
#include "CvvImage.h"

//
// Construction/Destruction
//

CV_INLINE RECT NormalizeRect( RECT r );
CV_INLINE RECT NormalizeRect( RECT r )
{
int t;

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

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

return r;
}

CV_INLINE CvRect RectToCvRect( RECT sr );
CV_INLINE CvRect RectToCvRect( RECT sr )
{
sr = NormalizeRect( sr );
return cvRect( sr.left, s, sr.right - sr.left, sr.bottom - s );
}

CV_INLINE RECT CvRectToRect( CvRect sr );
CV_INLINE RECT CvRectToRect( CvRect sr )
{
RECT dr;
dr.left = sr.x;
d = sr.y;
dr.right = sr.x + sr.width;
dr.bottom = sr.y + sr.height;

return dr;
}

CV_INLINE IplROI RectToROI( RECT r );
CV_INLINE IplROI RectToROI( RECT r )
{
IplROI roi;
r = NormalizeRect( r );
roi.xOffset = r.left;
roi.yOffset = ;
roi.width = r.right - r.left;
roi.height = r.bottom - ;
roi.coi = 0;

return roi;
}

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;
  }
}
}

CvvImage::CvvImage()
{
m_img = 0;
}

void CvvImage::Destroy()
{
cvReleaseImage( &m_img );
}

CvvImage::~CvvImage()
{
Destroy();
}

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;
}

void CvvImage::CopyOf( CvvImage& image, int desired_color )
{
IplImage* img = image.GetImage();
if( img )
{
CopyOf( img, desired_color );
}
}

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

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 );
  }
}
}

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;
}

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;
}

bool CvvImage::Save( const char* filename )
{
if( !m_img )
return false;
cvSaveImage( filename, m_img );
return true;
}

void CvvImage::Show( const char* window )
{
if( m_img )
cvShowImage( window, m_img );
}

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 );
}
}

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 );
}
}

void CvvImage::Fill( int color )
{
cvSet( m_img, cvScalar(color&255,(color>>8)&255,(color>>16)&255,(color>>24)&255) );
}

#endif // RC_OPENCV_2_1_0

public.h文件

#pragma once

#undef RC_OPENCV_2_1_0

/** 使用OpenCV 2.2.0, 则不定义下面的宏 */
/** #define RC_OPENCV_2_1_0 */

#ifdef _DEBUG
    #ifdef RC_OPENCV_2_1_0
        #pragma comment( lib, "cxcore210d.lib" )
        #pragma comment( lib, "cv210d.lib" )
        #pragma comment( lib, "highgui210d.lib" )
    #else
        #pragma comment( lib, "opencv_core220d.lib" )
        #pragma comment( lib, "opencv_highgui220d.lib" )
        #pragma comment( lib, "opencv_imgproc220d.lib" )
    #endif
#else
    #ifdef RC_OPENCV_2_1_0
        #pragma comment( lib, "cxcore210.lib" )
        #pragma comment( lib, "cv210.lib" )
        #pragma comment( lib, "highgui210.lib" )
    #else
        #pragma comment( lib, "opencv_core220.lib" )
        #pragma comment( lib, "opencv_highgui220.lib" )
        #pragma comment( lib, "opencv_imgproc220.lib" )
    #endif
#endif

版权声明：本文内容来自第三方投稿或授权转载，原文地址：https://blog.csdn.net/fengbingchun/article/details/6277124，作者：fengbingchun，版权归原作者所有。本网站转在其作品的目的在于传递更多信息，不拥有版权，亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系，请发邮件至ctyunbbs@chinatelecom.cn沟通。

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

OpenCV 2.2.0 CvvImage的使用

OpenCV 2.2.0 CvvImage的使用

相关文章

使用Python 训练OpenCV Cascade分类器 - 4

OpenCV库模块解析

TensorFlow模型导出到OpenCV调用

OpenCV基于形状的模板匹配

Python中的图像处理库

python将矩阵转化为灰度图

使用 Python 和 OpenCV 实现实时人脸识别

使用 OpenCV 进行人脸检测

使用 OpenCV 读取和显示图像与视频

使用 OpenCV 进行人眼检测

作者介绍

最新文章

python将矩阵转化为灰度图

使用 OpenCV 进行人脸检测

使用 OpenCV 读取和显示图像与视频

使用 OpenCV 进行人眼检测

使用 OpenCV 实现鼠标事件回调绘制图形

使用 OpenCV 进行图像的高斯模糊和边缘检测

热门文章

OpenCV支持的图像格式

OpenCV像素点处理

cvBlob 依赖 OpenCV 问题

OpenCV实现遍历文件夹下所有文件

OpenCV中OpenCL模块函数

OpenCV常遇问题解决方法汇总

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

ArUco与OpenCV

使用 OpenCV 读取和显示图像与视频

OpenCV从入门到精通——透视变换

OpenCV学习——图像融合

OpenCV实现遍历文件夹下所有文件

OpenCV常遇问题解决方法汇总