2nd section

4th Computer Vision Workshop
February 2011

Content
 Basic Structures
 Arrays, Matrices, and Images
 Matrix and Image Operators
 Drawing Things
 Drawing Text

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;
{
double x;
double y;
} CvPoint2D64f;
{
float x;
float y;
float z;
} CvPoint3D32f;
{
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 );

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

{
int type;
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

{
int type;
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

{
int type;
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

{
int type;
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

{
int type;
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);

{
int type;
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);

{
int type;
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)) ;

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;

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;
void* imageId;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
} 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_32F - Single-precision floating point
IPL_DEPTH_64F - Double-precision floating point

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;
void* imageId;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
} 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

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;
void* imageId;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
} 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

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;
void* imageId;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
} 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
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;
void* imageId;
int imageSize;
char* imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
} 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
........................
int width;
int height;
........................
........................
char* imageData;
int widthStep;
........................
} IplImage;
void cvSetImageROI( IplImage* image, CvRect rect );
void cvResetImageROI( IplImage* image );
cvSetImageROI

ROI
........................
int width;
int height;
........................
........................
char* imageData;
int widthStep;
........................
} IplImage;
cvSetImageROI
cvAddS

ROI
........................
int width;
int height;
........................
........................
char* imageData;
int widthStep;
........................
} IplImage;
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 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 shift
x 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.

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

2nd section

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to 2nd section (20)

2nd section