4th Computer Vision Workshop
February 2011
Content Basic Structures
Arrays, Matrices, and Images
Matrix and Image Operators
Drawing Things
Drawing Text
Basic Structures
Basic Structures (Point)
typedef struct CvPoint
{
int x;
int y;
} CvPoint;
CV_INLINE CvPoint cvPoint(int x, int y)
{
CvPoint p;
p.x = x;
p.y = y;
return p;
}
CvPoint pt1;
pt1.x = 20;
pt1.y = 50
CvPoint pt2 = cvPoint(20, 50);
cxtypes.h
Basic Structures (Point)
typedef struct CvPoint
{
int x;
int y;
} CvPoint;
cxtypes.h
typedef struct CvPoint2D32f
{
float x;
float y;
} CvPoint2D32f;
typedef struct CvPoint2D64f
{
double x;
double y;
} CvPoint2D64f;
typedef struct CvPoint3D32f
{
float x;
float y;
float z;
} CvPoint3D32f;
typedef struct CvPoint3D64f
{
double x;
double y;
double z;
} CvPoint3D64f;
Basic Structures (Size)
typedef struct CvSize
{
int width;
int height;
} CvSize;
cxtypes.h
typedef struct CvSize2D32f
{
float width;
float height;
} CvSize2D32f
typedef struct CvRect
{
int x;
int y;
int width;
int height;
} CvRect;
Basic Structures (Scalar)
typedef struct CvScalar
{
double val[4];
} CvScalar;
cxtypes.h
/* Constructor:
initializes val[0] with val0, val[1] with val1, etc.
*/
inline CvScalar cvScalar( double val0, double val1=0,
double val2=0, double val3=0 );
/* Constructor:
initializes all of val[0]...val[3] with val0123
*/
inline CvScalar cvScalarAll( double val0123 );
/* Constructor:
initializes val[0] with val0, and all of val[1]...val[3] with zeros
*/
inline CvScalar cvRealScalar( double val0 );
Arrays, Matrices, and Images
Array → Matrix → Image
cxtypes.h
Even though OpenCV is implemented in C, the structures used in OpenCV
have an object-oriented design; in effect, IplImage is derived from
CvMat, which is derived from CvArr
Array→Matrix→Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
CV_<bit_depth>(S|U|F)C<number_of_channels>
CV_8UC3
CV_32FC1 32-bit floats
unsigned integer 8-bit triplets
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
the length of a row in bytes
a pointer to a data array
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
the height (rows) and width (cols) of the matrix
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
Matrix Header
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
Some Matrix Operators: // Create a new rows by cols matrix of type ‘type’
CvMat* cvCreateMat(int rows, int cols, int type)
// Creates only matrix header without allocating data
CvMat* cvCreateMatHeader(int rows, int cols, int type)
// allocates image, matrix or multi-dimensional array data
void cvCreateData(CvArr* arr)
// Initialize header on existing CvMat structure
CvMat* cvInitMatHeader(CvMat* mat,
int rows, int cols, int type,
void* data=NULL, int step=CV_AUTOSTEP)
// Like cvInitMatHeader() but allocates CvMat as well
CvMat cvMat(int rows, int cols, int type, void* data=NULL)
;
// Allocate a new matrix just like the matrix ‘mat’
CvMat* cvCloneMat(const cvMat* mat);
// Free the matrix ‘mat’, both header and data
void cvReleaseMat(CvMat** mat);
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
Accessing matrix elements
Easy way:
CV_MAT_ELEM()
CV_MAT_ELEM_PTR()
CvMat* mat = cvCreateMat( 5, 5, CV_32FC1 );
int i, j;
float sum = 0.0f;
for(i=0; i<5; i++)
for(j=0; j<5; j++)
CV_MAT_ELEM(*mat, float, i, j) = (float) i + j;
for(i=0; i<5; i++)
for(j=0; j<5; j++)
sum += CV_MAT_ELEM(*mat, float, i, j);
Array → Matrix → Image typedef struct CvMat
{
int type;
int step; //# bytes per row
int* refcount; // internal use
int hdr_refcount; // internal use
union{
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;
union{
int rows;
int height;
};
union{
int cols;
int width;
};
} CvMat;
cxtypes.h
Accessing matrix elements
Easy way:
CV_MAT_ELEM()
CV_MAT_ELEM_PTR()
CvMat* mat = cvCreateMat( 5, 5, CV_32FC1 );
int i, j;
float sum = 0.0f;
for(i=0; i<5; i++)
for(j=0; j<5; j++)
*((float*) CV_MAT_ELEM_PTR(*mat, i, j)) = (float) i + j;
for(i=0; i<5; i++)
for(j=0; j<5; j++)
sum += *((float*) CV_MAT_ELEM_PTR(*mat, i, j)) ;
Array → Matrix → Image
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
Array → Matrix → Image
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
• nSize - sizeof(IplImage)
• ID - Version, always equals 0
• nChannels - Number of channels. Most OpenCV functions support 1-4 channels.
• alphaChannel - Ignored by OpenCV
• depth - Pixel depth in bits. The supported depths are:
IPL_DEPTH_8U - Unsigned 8-bit integer
IPL_DEPTH_8S - Signed 8-bit integer
IPL_DEPTH_16U - Unsigned 16-bit integer
IPL_DEPTH_16S - Signed 16-bit integer
IPL_DEPTH_32S - Signed 32-bit integer
IPL_DEPTH_32F - Single-precision floating point
IPL_DEPTH_64F - Double-precision floating point
Array → Matrix → Image
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
• colorModel - Ignored by OpenCV.
• channelSeq - Ignored by OpenCV
• dataOrder - 0 = IPL_DATA_ORDER_PIXEL
1 = IPL_DATA_ORDER_PLANE
• origin - 0 = IPL_ORIGIN_TL
1 = IPL_ORIGIN_BL
• align - OpenCV ignores this and uses widthStep instead.
• width - Image width in pixels
• height - Image height in pixels
Array → Matrix → Image
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
• roi - Region Of Interest (ROI).
If not NULL, only this image region will be processed.
• maskROI - Must be NULL in OpenCV
• imageId - Must be NULL in OpenCV
• tileInfo - Must be NULL in OpenCV
Array → Matrix → Image
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
• imageSize - Image data size in bytes.
For interleaved data, this equals image->height*image->widthStep
• imageData - A pointer to the aligned image data
• widthStep - The size of an aligned image row, in bytes
• BorderMode - Border completion mode, ignored by OpenCV
• BorderConst - Border completion mode, ignored by OpenCV
• imageDataOrigin - A pointer to the origin of the image data
(not necessarily aligned). This is used for
image deallocation.
Accessing Image Data
typedef struct _IplImage {
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI* roi;
struct _IplImage* maskROI;
void* imageId;
struct _IplTileInfo* tileInfo;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char* imageDataOrigin;
} IplImage;
#include <stdio.h>
#include <cv.h>
#include <highgui.h>
void saturate_sv( IplImage* img )
{
for( int y=0; y<img->height; y++ ) {
uchar* ptr = (uchar*) (
img->imageData + y * img->widthStep
);
for( int x=0; x<img->width; x++ ) {
ptr[3*x+1] = 255;
ptr[3*x+2] = 255;
}
}
}
int main( int argc, char** argv )
{
IplImage* img = cvLoadImage( argv[1] );
cvNamedWindow("Example1", CV_WINDOW_AUTOSIZE );
saturate_sv(img);
cvShowImage("Example1", img );
cvWaitKey(0);
cvReleaseImage( &img );
cvDestroyWindow("Example1");
}
ROI
typedef struct _IplImage {
........................
int width;
int height;
........................
struct _IplROI* roi;
........................
char* imageData;
int widthStep;
........................
} IplImage;
void cvSetImageROI( IplImage* image, CvRect rect );
void cvResetImageROI( IplImage* image );
cvSetImageROI
ROI
typedef struct _IplImage {
........................
int width;
int height;
........................
struct _IplROI* roi;
........................
char* imageData;
int widthStep;
........................
} IplImage;
void cvSetImageROI( IplImage* image, CvRect rect );
void cvResetImageROI( IplImage* image );
cvSetImageROI
cvAddS
ROI
typedef struct _IplImage {
........................
int width;
int height;
........................
struct _IplROI* roi;
........................
char* imageData;
int widthStep;
........................
} IplImage;
void cvSetImageROI( IplImage* image, CvRect rect );
void cvResetImageROI( IplImage* image );
cvSetImageROI
cvAddS
#include <cv.h>
#include <highgui.h>
// ch3_ex3_12 image_name x y width height add#
int main(int argc, char** argv)
{
IplImage* src;
cvNamedWindow("Example3_12_pre", CV_WINDOW_AUTOSIZE);
cvNamedWindow("Example3_12_post", CV_WINDOW_AUTOSIZE);
if( argc == 7 && ((src=cvLoadImage(argv[1],1)) != 0 ))
{
int x = atoi(argv[2]);
int y = atoi(argv[3]);
int width = atoi(argv[4]);
int height = atoi(argv[5]);
int add = atoi(argv[6]);
cvShowImage( "Example3_12_pre", src);
cvSetImageROI(src, cvRect(x,y,width,height));
cvAddS(src, cvScalar(add, add, add),src);
cvResetImageROI(src);
cvShowImage( "Example3_12_post",src);
cvWaitKey();
}
cvReleaseImage( &src );
cvDestroyWindow("Example3_12_pre");
cvDestroyWindow("Example3_12_post");
return 0;
}
Drawing Things
Drawing Functions
Drawing functions work with matrices/images of arbitrary depth
The boundaries of the shapes can be rendered with antialiasing implemented only for 8-bit images for now
All the functions include the parameter color that uses a rgb value (that may be constructed with CV_RGB macro or the cvScalar function ) for color images and brightness for grayscale images
Drawing Functions
Clipping If a drawn figure is partially or completely outside the
image, the drawing functions clip it.
sub-pixel accuracy many drawing functions can handle pixel coordinates
specified with sub-pixel accuracy, i.e., the coordinates can be passed as fixed-point numbers, encoded as integers.
The number of fractional bits is specified by the shift parameter and the real point coordinates are calculated as
Point( , ) Point2f ( 2 , 2 )shift shiftx y x y
CV_RGB
Constructs a color value #define CV_RGB( r, g, b ) cvScalar( (b), (g), (r) )
Line
void cvLine(
CvArr* img,
CvPoint pt1,
CvPoint pt2,
CvScalar color,
int thickness=1,
int line_type=8,
int shift=0
);
Draws a line by the Bresenham’s algorithm
Rectangle
void cvRectangle(
CvArr* img,
CvPoint pt1,
CvPoint pt2,
double color,
int thickness=1
int line_type=8,
int shift=0
);
Draws simple, thick or filled rectangle
thickness
Thickness of lines that make up the rectangle. Negative values, e.g., CV_FILLED, make the function to draw a filled rectangle.
Circle
void cvCircle(
CvArr* img,
CvPoint center,
int radius,
cvScalar color,
int thickness=1
int line_type=8,
int shift=0
);
Draws simple, thick or filled circle
Ellipse
void cvEllipse(
CvArr* img,
CvPoint center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
cvScalar color,
int thickness=1
int line_type=8,
int shift=0
);
Draws simple or thick elliptic arc or fills ellipse sector
EllipseBox
void cvEllipseBox(
CvArr* img,
CvBox2D box,
cvScalar color,
int thickness=1
int line_type=8,
int shift=0
);
An alternate way to draw ellipse
typedef struct {
CvPoint2D32f center;
CvSize2D32f size;
float angle;
} CvBox2D;
FillPoly
void cvFillPoly(
CvArr* img,
CvPoint** pts,
int* npts,
int contours,
cvScalar color,
int line_type=8,
int shift=0
);
Fills polygons interior
pts
Array of pointers to polygons.
npts
Array of polygon vertex counters.
contours
#contours that bind the filled region.
FillConvexPoly
void cvFillConvexPoly(
CvArr* img,
CvPoint* pts,
int npts,
cvScalar color,
int thickness=1
int line_type=8,
int shift=0
);
Fills convex polygon
pts
Array of pointers to a single polygon
npts
Polygon vertex counter
PolyLine
void cvPolyLine(
CvArr* img,
CvPoint** pts,
int* npts,
int contours,
int is_closed,
cvScalar color,
int thickness=1
int line_type=8,
int shift=0
);
Draws simple or thick polygons
pts
Array of pointers to polygons.
npts
Array of polygon vertex counters.
contours
#contours that bind the filled region.
is_closed
Indicates whether the polylines must
be drawn closed.
Drawing Text
InitFont
void cvInitFont(
CvFont* font,
int font_face,
double hscale,
double vscale,
double shear=0,
int thickness=1,
int line_type=8
);
Initializes font structure
InitFont
void cvInitFont(
CvFont* font,
int font_face,
double hscale,
double vscale,
double shear=0,
int thickness=1,
int line_type=8
);
Initializes font structure
InitFont
void cvInitFont(
CvFont* font,
int font_face,
double hscale,
double vscale,
double shear=0,
int thickness=1,
int line_type=8
);
Initializes font structure
PutText
void cvPutText(
CvArr* img,
const char* text,
CvPoint org,
const CvFont* font,
CvScalar color
);
Draws text string
GetTextSize
void cvGetTextSize(
const char* text_string,
const CvFont* font,
CvSize* text_size,
int* baseline
);
Retrieves width and height of text string