从零开始 OpenCV (二) —— OpenCV 的基本数据类型和基本函数

从零开始 OpenCV (二) —— OpenCV 的基本数据类型和基本函数

OpenCV 的基本数据类型及其相关函数

...\opencv\build\include\opencv2\core\types_c.h

坐标点类型:

CvPoint

typedef struct CvPoint
{
int x;
int y;
}CvPoint;

CvPoint

CvPoint2D32f

CvPoint2D64f

CvPoint3D32f

CvPoint3D64f

记录矩形宽高的

CvSize

类型

typedef struct CvSize
{
int width;
int height;
}CvSize;

CvSize

CvSize2D32f

矩形类型:

CvRect

typedef struct CvRect
{
int x;
int y;
int width;
int height;
}CvRect;

标量(scalar)类型:

CvScalar

typedef struct CvScalar
{
double val[4];
}CvScalar;

CvRect

CvScalar

cvRect()

矩阵类型:

CvMat

CvMat

typedef struct CvMat
{
int type;
int step;

/* for internal use only */
int* refcount;
int hdr_refcount;

union
{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;

int rows;
int cols;
}CvMat;

type

CV_<bit_depth>(S|U|F)C<number_of_channels>

CV_8UC3

data

step

CvMat

type

rows

cols

cvCreateMat

// Creates a matrix header and allocates the matrix data.
CvMat* cvCreateMat(int rows, int cols, int type);

mat

cvReleaseMat

// Deallocates a matrix.
// The function decrements the matrix data reference counter and deallocates matrix header.
// If the data reference counter is 0, it also deallocates the data. :
void cvReleaseMat(CvMat** mat);

mat

cvCloneMat

// Creates an exact copy of the input matrix.
CvMat* cvCloneMat(const cvMat* mat);

CV_MAT_ELEM()

CV_MAT_ELEM_PTR()

#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size )  \
(assert( (unsigned)(row) < (unsigned)(mat).rows &&   \
(unsigned)(col) < (unsigned)(mat).cols ),   \
(mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))

#define CV_MAT_ELEM_PTR( mat, row, col )                 \
CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )

#define CV_MAT_ELEM( mat, elemtype, row, col )           \
(*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype)))

CvMat

CV_MAT_ELEM()

CV_MAT_ELEM_PTR

CvMat* may = cvCreateMat(5, 5, CV_32FC1);
// 读取 (3,3) 处的一元组
float elem_3_3 = CV_MAT_ELEM(*mat, float, 3, 3);
// 将 (3,3) 处的一元组的值改为 33
float* elemPtr_3_3 = (float*)CV_MAT_ELEM_PTR(*mat, 3, 3);
(*elemPtr_3_3) = 33;

cvGet*D

cvPtr*D

cvGet*D

// This is the "metatype" used only as a function parameter.
// It denotes that the function accepts arrays of multiple types, such as IplImage*, CvMat* or even CvSeq* sometimes.
// The particular array type is determined at runtime by analyzing the first 4 bytes of the header.
// In C++ interface the role of CvArr is played by InputArray and OutputArray.
typedef void CvArr;

// The functions return a specific array element.
// In the case of a sparse array the functions return 0
// if the requested node does not exist (no new node is created by the functions).
CvScalar cvGet1D (const CvArr* arr, int idx0);
CvScalar cvGet2D (const CvArr* arr, int idx0, int idx1);
CvScalar cvGet3D (const CvArr* arr, int idx0, int idx1, int idx2);

cvPtr*D

// Return pointer to a particular array element.
// The functions return a pointer to a specific array element.
// Number of array dimension should match to the number of indices passed to the function
// except for cvPtr1D function that can be used for sequential access to 1D, 2D or nD dense arrays.
uchar* cvPtr1D(const CvArr* arr, int idx0, int* type = NULL);
uchar* cvPtr2D(const CvArr* arr, int idx0, int idx1, int* type = NULL);
uchar* cvPtr3D(const CvArr* arr, int idx0, int idx1, int idx2, int* type = NULL);

data

IplImage

数据结构

IplImage

/*
* The following definitions (until #endif)
* is an extract from IPL headers.
* Copyright (c) 1995 Intel Corporation.
*/

#define IPL_DEPTH_SIGN 0x80000000

#define IPL_DEPTH_1U     1
#define IPL_DEPTH_8U     8
#define IPL_DEPTH_16U   16
#define IPL_DEPTH_32F   32

#define IPL_DEPTH_8S  (IPL_DEPTH_SIGN| 8)
#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)
#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)

#define IPL_DATA_ORDER_PIXEL  0
#define IPL_DATA_ORDER_PLANE  1

#define IPL_ORIGIN_TL 0
#define IPL_ORIGIN_BL 1

#define IPL_ALIGN_4BYTES   4
#define IPL_ALIGN_8BYTES   8
#define IPL_ALIGN_16BYTES 16
#define IPL_ALIGN_32BYTES 32

#define IPL_ALIGN_DWORD   IPL_ALIGN_4BYTES
#define IPL_ALIGN_QWORD   IPL_ALIGN_8BYTES

#define IPL_BORDER_CONSTANT   0
#define IPL_BORDER_REPLICATE  1
#define IPL_BORDER_REFLECT    2
#define IPL_BORDER_WRAP       3

/** The IplImage is taken from the Intel Image Processing Library, in which the format is native. OpenCV
only supports a subset of possible IplImage formats, as outlined in the parameter list above.

In addition to the above restrictions, OpenCV handles ROIs differently. OpenCV functions require
that the image size or ROI size of all source and destination images match exactly. On the other
hand, the Intel Image Processing Library processes the area of intersection between the source and
destination images (or ROIs), allowing them to vary independently.
*/
typedef struct _IplImage
{
int  nSize;             /**< sizeof(IplImage) */
int  ID;                /**< version (=0)*/
int  nChannels;         /**< Most of OpenCV functions support 1,2,3 or 4 channels */
int  alphaChannel;      /**< Ignored by OpenCV */
int  depth;             /**< Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,
IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported.  */
char colorModel[4];     /**< Ignored by OpenCV */
char channelSeq[4];     /**< ditto */
int  dataOrder;         /**< 0 - interleaved color channels, 1 - separate color channels.
cvCreateImage can only create interleaved images */
int  origin;            /**< 0 - top-left origin,
1 - bottom-left origin (Windows bitmaps style).  */
int  align;             /**< Alignment of image rows (4 or 8).
OpenCV ignores it and uses widthStep instead.    */
int  width;             /**< Image width in pixels.                           */
int  height;            /**< Image height in pixels.                          */
struct _IplROI *roi;    /**< Image ROI(Region of Interest). If NULL, the whole image is selected. */
struct _IplImage *maskROI;      /**< Must be NULL. */
void  *imageId;                 /**< "           " */
struct _IplTileInfo *tileInfo;  /**< "           " */
int  imageSize;         /**< Image data size in bytes
(==image->height*image->widthStep
in case of interleaved data)*/
char *imageData;        /**< Pointer to aligned image data.         */
int  widthStep;         /**< Size of aligned image row in bytes.    */
int  BorderMode[4];     /**< Ignored by OpenCV.                     */
int  BorderConst[4];    /**< Ditto.                                 */
char *imageDataOrigin;  /**< Pointer to very origin of image data
(not necessarily aligned) -
needed for correct deallocation */
} IplImage;

origin

IPL_ORIGIN_TL

IPL_ORIGIN_BL

dataOrder

IPL_DATA_ORDER_PIXEL

IPL_DATA_ORDER_PLANE

cvLoadImage

IplImage* cvLoadImage(const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR);

cvShowImage

/* display image within window (highgui windows remember their content) */
void cvShowImage(const char* name, const CvArr* image);

cvSetImageROI

cvResetImageROI

// Sets an image Region Of Interest (ROI) for a given rectangle.
// If the original image ROI was NULL and the rect is not the whole image,
//  the ROI structure is allocated.
// image: A pointer to the image header
// rect: The ROI rectangle
void cvSetImageROI(IplImage* image, CvRect rect);

// Resets the image ROI to include the entire image and releases the ROI structure.
void cvResetImageROI(IplImage* image);

src

cvScalar

#include "opencv/highgui.h"
#include "opencv/cv.h"

int main()
{
// load image from file
IplImage* src = cvLoadImage("C:\\Users\\yanglion\\Pictures\\Img\\Ali.jpg");

//
// set image's ROI
cvSetImageROI(src, cvRect(216, 123, 100, 70));
// dst(mask) = src(mask) - value = src(mask) + (-value)
cvSubS(src, cvScalar(50,50,100), src);
// Resets the image ROI to include the entire image and releases the ROI structure.
cvResetImageROI(src);

// create window
cvNamedWindow("Ali");
// display image within window (highgui windows remember their content)
cvShowImage("Ali", src);
// wait for key event infinitely (delay<=0) or for "delay" milliseconds
cvWaitKey();

return 0;
}