Horizontal Grays S2

Sets mouse handler for the specified window

C++: void setMouseCallback(const string& winname, MouseCallback onMouse, void* userdata=0 )

C: void cvSetMouseCallback(const char* window_name, CvMouseCallback on_mouse, void* param=NULL )

Python: cv.SetMouseCallback(windowName, onMouse, param=None) → None

Parameters:

winname – Window name

onMouse – Mouse callback. See OpenCV samples, such as https://github.com/Itseez/opencv/tree/master/samples/cpp/ffilldemo.cpp, on how to specify and use the callback.

userdata – The optional parameter passed to the callback.

link : http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=cvsetmousecallback#void cvSetMouseCallback(const char* window_name, CvMouseCallback on_mouse, void* param)

void on_eventhandle(int event, int x ,int y, int flag, void* param)

{

switch(event)

{

case CV_EVENT_LBUTTONDOWN:

if(getFlag == 0)

{

getx = x;

gety = y;

getFlag = 1;

}else if(getFlag == 1)

{

getFlag = 2;

}

break;

case CV_EVENT_RBUTTONDOWN:

getFlag = 0;

break;

}

}

C: CvScalar cvGet1D(const CvArr* arr, int idx0)

C: CvScalar cvGet2D(const CvArr* arr, int idx0, int idx1)

C: CvScalar cvGet3D(const CvArr* arr, int idx0, int idx1, int idx2)

C: CvScalar cvGetND(const CvArr* arr, const int* idx)

Python: cv.Get1D(arr, idx) → scalar

Python: cv.Get2D(arr, idx0, idx1) → scalar

Python: cv.Get3D(arr, idx0, idx1, idx2) → scalar

Python: cv.GetND(arr, indices) → scalar

Return a specific array element.

Parameters:

arr – Input array

idx0 – The first zero-based component of the element index

idx1 – The second zero-based component of the element index

idx2 – The third zero-based component of the element index

idx – Array of the element indices

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).

link : http://docs.opencv.org/modules/core/doc/old_basic_structures.html?highlight=cvget2d#CvScalar cvGet2D(const CvArr* arr, int idx0, int idx1)

CvScalar s = cvGet2D(HSVImg,gety,getx);

H = (int)s.val[0];

S = (int)s.val[1];

V = (int)s.val[2];

CvScalar v = cvGet2D(img,gety,getx);

getBlue = (int)v.val[0];

getGreen = (int)v.val[1];

getRed = (int)v.val[2];

//calculate HSV Boundary

lowH = H * LOW_BOUND;

highH = H * HIGH_BOUND;

if(highH >= 180) highH = 179;

lowS = S * LOW_BOUND;

highS = S * HIGH_BOUND;

if(highS >= 256) highS = 255;

lowV = V * LOW_BOUND;

highV = V * HIGH_BOUND;

if(highV >= 256) highV = 255;

Creates a matrix header and allocates the matrix data.

C: CvMat* cvCreateMat(int rows, int cols, int type)

Python: cv.CreateMat(rows, cols, type) → mat

Parameters:

rows – Number of rows in the matrix

cols – Number of columns in the matrix

type – The type of the matrix elements in the form CV_<bit depth><S|U|F>C<number of channels> , where S=signed, U=unsigned, F=float. For example, CV _ 8UC1 means the elements are 8-bit unsigned and the there is 1 channel, and CV _ 32SC2 means the elements are 32-bit signed and there are 2 channels.

The function call is equivalent to the following code:

link : http://docs.opencv.org/modules/core/doc/old_basic_structures.html?highlight=cvcreatemat#CvMat* cvCreateMat(int rows, int cols, int type)

Checks if array elements lie between the elements of two other arrays.

C++: void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)

Python: cv2.inRange(src, lowerb, upperb[, dst]) → dst

C: void cvInRange(const CvArr* src, const CvArr* lower, const CvArr* upper, CvArr* dst)

C: void cvInRangeS(const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst)

Python: cv.InRange(src, lower, upper, dst) → None

Python: cv.InRangeS(src, lower, upper, dst) → None

Parameters:

src – first input array.

lowerb – inclusive lower boundary array or a scalar.

upperb – inclusive upper boundary array or a scalar.

dst – output array of the same size as src and CV_8U type.

The function checks the range as follows:

For every element of a single-channel input array:

\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq  \texttt{upperb} (I)_0

For two-channel arrays:

\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq  \texttt{upperb} (I)_0  \land \texttt{lowerb} (I)_1  \leq \texttt{src} (I)_1 \leq  \texttt{upperb} (I)_1

and so forth.

That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the specified 1D, 2D, 3D, ... box and 0 otherwise.

When the lower and/or upper boundary parameters are scalars, the indexes (I) at lowerb and upperb in the above formulas should be omitted.

link : http://docs.opencv.org/modules/core/doc/operations_on_arrays.html?highlight=cvinranges#void cvInRangeS(const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst)

mask = cvCreateMat(size.height, size.width,CV_8UC1);

cvInRangeS(HSVImg, cvScalar(lowH,lowS,lowV),cvScalar(highH,highS,highV),mask);

Erodes an image by using a specific structuring element.

C++: void erode(InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )

Python: cv2.erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) → dst

C: void cvErode(const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1)

Python: cv.Erode(src, dst, element=None, iterations=1) → None

Parameters:

src – input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F` or ``CV_64F.

dst – output image of the same size and type as src.

element – structuring element used for erosion; if element=Mat() , a 3 x 3 rectangular structuring element is used.

anchor – position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.

iterations – number of times erosion is applied.

borderType – pixel extrapolation method (see borderInterpolate() for details).

borderValue – border value in case of a constant border (see createMorphologyFilter() for details).

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\texttt{dst} (x,y) =  \min _{(x',y'):  \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')

The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

link : http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=cverode#void cvErode(const CvArr* src, CvArr* dst, IplConvKernel* element, int iterations)

Dilates an image by using a specific structuring element.

C++: void dilate(InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() )

Python: cv2.dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) → dst

C: void cvDilate(const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1 )

Python: cv.Dilate(src, dst, element=None, iterations=1) → None

Parameters:

src – input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F` or ``CV_64F.

dst – output image of the same size and type as src.

element – structuring element used for dilation; if element=Mat() , a 3 x 3 rectangular structuring element is used.

anchor – position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.

iterations – number of times dilation is applied.

borderType – pixel extrapolation method (see borderInterpolate() for details).

borderValue – border value in case of a constant border (see createMorphologyFilter() for details).

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\texttt{dst} (x,y) =  \max _{(x',y'):  \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')

The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

cvErode(mask,mask,NULL);

cvDilate(mask,mask,NULL);

//============================================================================

// Name        : GetColor.cpp

// Author      : 

// Version     :

// Copyright   : Your copyright notice

// Description : Hello World in C++, Ansi-style

//============================================================================

#include <iostream>

#include <stdio.h>

#include <sys/time.h>

#include "opencv2/opencv.hpp"

#define LOW_BOUND 0.7

#define HIGH_BOUND 1.3

struct timeval start_time;

struct timeval end_time;

double elapsed_time;

float fps;

double total_fps = 0.0,average_fps = 0.0;

long cnt=1;

char buffer[25];

CvFont font;

char getFlag = 0;

long getx,gety;

int getRed,getGreen,getBlue;

int Bval,Rval,Gval;

using namespace std;

void on_eventhandle(int event, int x ,int y, int flag, void* param)

{

switch(event)

{

case CV_EVENT_LBUTTONDOWN:

if(getFlag == 0)

{

getx = x;

gety = y;

getFlag = 1;

}else if(getFlag == 1)

{

getFlag = 2;

}

break;

case CV_EVENT_RBUTTONDOWN:

getFlag = 0;

break;

}

}

int main() {

IplImage* img;

IplImage* GrayImg=0;

IplImage* SmoothImg=0;

IplImage* Edge=0;

IplImage* HSVImg;

IplImage* HImg = 0;

IplImage* SImg = 0;

IplImage* VImg = 0;

CvMat* mask;

int key;

int k;

double dp = 1;

double min_dist = 300;

int H,S,V;

int lowH,lowS,lowV,highH,highS,highV;

CvSize size;

int cx,cy,radius,ccnt;

cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX,0.5,0.5);

CvCapture* capture = cvCaptureFromCAM(0);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, 640);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, 480);

cvSetCaptureProperty( capture, CV_CAP_PROP_FPS, 65);

while(1)

{

gettimeofday(&start_time,NULL);

cvGrabFrame(capture);

img = cvRetrieveFrame(capture);

cvSetMouseCallback("PreviewImage",on_eventhandle,(void*)img);

if(getFlag == 0)

{

sprintf(buffer,"Picking up color by left click");

cvPutText(img,buffer,cvPoint(200,20),&font,CV_RGB(255,255,255));

}else if(getFlag == 1)

{

sprintf(buffer,"If below color is right you chosen, start detect by left click again");

cvPutText(img,buffer,cvPoint(20,20),&font,CV_RGB(255,255,255));

size = cvGetSize(img);

CvScalar v = cvGet2D(img,gety,getx);

getBlue = (int)v.val[0];

getGreen = (int)v.val[1];

getRed = (int)v.val[2];

//Convert get RGB to HSV

SmoothImg = cvCreateImage(size,IPL_DEPTH_8U,3);

cvSmooth(img,SmoothImg,CV_GAUSSIAN,9,9,2,2);

HSVImg = cvCreateImage(size,IPL_DEPTH_8U,3);

cvCvtColor(SmoothImg,HSVImg,CV_BGR2HSV);

CvScalar s = cvGet2D(HSVImg,gety,getx);

H = (int)s.val[0];

S = (int)s.val[1];

V = (int)s.val[2];

sprintf(buffer,"X= %d,Y= %d,R= %d G= %d, B= %d, H= %d, S= %d, V= %d",getx,gety,getRed,getGreen,getBlue,H,S,V);

cvPutText(img,buffer,cvPoint(getx,gety),&font,CV_RGB(255,255,255));

//printf("X= %d,Y= %d,Red = %d, Green = %d, Blue = %d\n",getx,gety,getRed,getGreen,getBlue);

}else{

sprintf(buffer,"You can picking up again by right click");

cvPutText(img,buffer,cvPoint(100,20),&font,CV_RGB(255,255,255));

//SmoothImg = cvCreateImage(size,IPL_DEPTH_8U,3);

cvSmooth(img,SmoothImg,CV_GAUSSIAN,9,9,2,2);

//Change Color Space

cvCvtColor(SmoothImg,HSVImg,CV_BGR2HSV);

//calculate HSV Boundary

lowH = H * LOW_BOUND;

highH = H * HIGH_BOUND;

if(highH >= 180) highH = 179;

lowS = S * LOW_BOUND;

highS = S * HIGH_BOUND;

if(highS >= 256) highS = 255;

lowV = V * LOW_BOUND;

highV = V * HIGH_BOUND;

if(highV >= 256) highV = 255;

//Masking

mask = cvCreateMat(size.height, size.width,CV_8UC1);

cvInRangeS(HSVImg, cvScalar(lowH,lowS,lowV),cvScalar(highH,highS,highV),mask);

//CvMat* tempMat;

//tempMat = cvCreateMat(size.height, size.width,CV_8UC1);

//cvMorphologyEx(mask,mask,tempMat,NULL,CV_MOP_OPEN);

//IplConvKernel *se21 = cvCreateStructuringElementEx(21,21,10,10,CV_SHAPE_RECT,NULL);

//IplConvKernel *se11 = cvCreateStructuringElementEx(11,11,5,5,CV_SHAPE_RECT,NULL);

cvErode(mask,mask,NULL);

cvDilate(mask,mask,NULL);

//cvErode(mask,mask,se21);

//cvDilate(mask,mask,se11);

//cvErode(mask,mask,se21);

//cvReleaseStructuringElement(&se21);

//cvReleaseStructuringElement(&se11);

//cvReleaseMat(&tempMat);

//Hough Tranform

GrayImg = cvCreateImage(size,8,1);

cvCopy(mask,GrayImg,NULL);

cvSmooth(GrayImg,GrayImg,CV_GAUSSIAN,15,15,2,2);

CvMemStorage* storage = cvCreateMemStorage(0);

CvSeq* Circles = cvHoughCircles(GrayImg,storage,CV_HOUGH_GRADIENT,2,size.height/10,100,40,5,60);

//CvSeq* Circles = cvHoughCircles(GrayImg,storage,CV_HOUGH_GRADIENT,1,100,100,50,0,0);

for(k=0;k<Circles->total;k++)

{

float* circle;

circle = (float*)cvGetSeqElem(Circles,k);

ccnt = Circles->total;

cx = cvRound(circle[0]);

cy = cvRound(circle[1]);

radius = cvRound(circle[2]);

cvCircle(img,cvPoint(cx,cy),radius,CV_RGB(0,255,0),3,8,0);

sprintf(buffer,"X=%d, Y=%d, R=%d",cx,cy,radius);

cvPutText(img,buffer,cvPoint(cx-80,cy+radius+15),&font,CV_RGB(255,255,255));

}

cvReleaseMemStorage(&storage);

cvNamedWindow( "HSVImage", 1 );

cvShowImage( "HSVImage", HSVImg);

cvMoveWindow("HSVImage",850,200);

cvNamedWindow( "Mask", 1 );

cvShowImage( "Mask", mask);

cvMoveWindow("Mask",850,700);

}

cvNamedWindow( "PreviewImage", 1 );

cvShowImage( "PreviewImage", img );

cvMoveWindow("PreviewImage",200,200);

//cvNamedWindow( "GrayImage", 1 );

//cvShowImage( "GrayImage", GrayImg );

//cvMoveWindow("GrayImage",850,400);

key = cvWaitKey(1);

if(key > 10) break;

gettimeofday(&end_time, NULL);

elapsed_time = (double)(end_time.tv_sec) + (double)(end_time.tv_usec)/1000000.0 - (double)(start_time.tv_sec) - (double)(start_time.tv_usec)/1000000.0;

fps = 1.0 / elapsed_time;

total_fps += fps;

average_fps = total_fps / (double)(cnt);

cnt++;

if(cnt == 100)

{

cnt = 1;

total_fps = 0.0;

}

elapsed_time *= 1000.0;

printf("Elapsed T = %2.3f ms, Frame = %2.3f (fps), Avrg Frame Rate = %2.3f\n",elapsed_time,fps,average_fps);

//cvReleaseMemStorage(&storage);

} //end of while(1)

cvReleaseImage(&img);

cvReleaseCapture( &capture );

cvReleaseMat(&mask);

cvReleaseImage(&SmoothImg);

cvReleaseImage(&GrayImg);

cvReleaseImage(&HSVImg);

return 0;

}

Finds contours in a binary image.

C++: void findContours(InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())

C++: void findContours(InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())

Python: cv2.findContours(image, mode, method[, contours[, hierarchy[, offset]]]) → contours, hierarchy

C: int cvFindContours(CvArr* image, CvMemStorage* storage, CvSeq** first_contour, int header_size=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0,0) )

Python: cv.FindContours(image, storage, mode=CV_RETR_LIST, method=CV_CHAIN_APPROX_SIMPLE, offset=(0, 0)) → contours

Parameters:

image – Source, an 8-bit single-channel image. Non-zero pixels are treated as 1’s. Zero pixels remain 0’s, so the image is treated as binary . You can use compare() , inRange() , threshold() , adaptiveThreshold() , Canny() , and others to create a binary image out of a grayscale or color one. The function modifies the image while extracting the contours.

contours – Detected contours. Each contour is stored as a vector of points.

hierarchy – Optional output vector, containing information about the image topology. It has as many elements as the number of contours. For each i-th contour contours[i] , the elements hierarchy[i][0] , hiearchy[i][1] , hiearchy[i][2] , and hiearchy[i][3] are set to 0-based indices in contours of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.

mode –

Contour retrieval mode (if you use Python see also a note below).

CV_RETR_EXTERNAL retrieves only the extreme outer contours. It sets hierarchy[i][2]=hierarchy[i][3]=-1 for all the contours.

CV_RETR_LIST retrieves all of the contours without establishing any hierarchical relationships.

CV_RETR_CCOMP retrieves all of the contours and organizes them into a two-level hierarchy. At the top level, there are external boundaries of the components. At the second level, there are boundaries of the holes. If there is another contour inside a hole of a connected component, it is still put at the top level.

CV_RETR_TREE retrieves all of the contours and reconstructs a full hierarchy of nested contours. This full hierarchy is built and shown in the OpenCV contours.c demo.

method –

Contour approximation method (if you use Python see also a note below).

CV_CHAIN_APPROX_NONE stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and (x2,y2) of the contour will be either horizontal, vertical or diagonal neighbors, that is, max(abs(x1-x2),abs(y2-y1))==1.

CV_CHAIN_APPROX_SIMPLE compresses horizontal, vertical, and diagonal segments and leaves only their end points. For example, an up-right rectangular contour is encoded with 4 points.

CV_CHAIN_APPROX_TC89_L1,CV_CHAIN_APPROX_TC89_KCOS applies one of the flavors of the Teh-Chin chain approximation algorithm. See [TehChin89] for details.

offset – Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

Approximates a polygonal curve(s) with the specified precision.

C++: void approxPolyDP(InputArray curve, OutputArray approxCurve, double epsilon, bool closed)

Python: cv2.approxPolyDP(curve, epsilon, closed[, approxCurve]) → approxCurve

C: CvSeq* cvApproxPoly(const void* src_seq, int header_size, CvMemStorage* storage, int method, double eps, int recursive=0 )

Parameters:

curve –

Input vector of a 2D point stored in:

std::vector or Mat (C++ interface)

Nx2 numpy array (Python interface)

CvSeq or `` CvMat (C interface)

approxCurve – Result of the approximation. The type should match the type of the input curve. In case of C interface the approximated curve is stored in the memory storage and pointer to it is returned.

epsilon – Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.

closed – If true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

header_size – Header size of the approximated curve. Normally, sizeof(CvContour) is used.

storage – Memory storage where the approximated curve is stored.

method – Contour approximation algorithm. Only CV_POLY_APPROX_DP is supported.

recursive – Recursion flag. If it is non-zero and curve is CvSeq*, the function cvApproxPoly approximates all the contours accessible from curve by h_next and v_next links.

The functions approxPolyDP approximate a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm

See https://github.com/Itseez/opencv/tree/master/samples/cpp/contours2.cpp for the function usage model.

http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html?highlight=cvapproxpoly#CvSeq* cvApproxPoly(const void* src_seq, int header_size, CvMemStorage* storage, int method, double eps, int recursive)

//============================================================================

// Name        : 20140317_RECTANGLE2.cpp

// Author      : jslee

// Version     :

// Copyright   : Your copyright notice

// Description : Hello World in C++, Ansi-style

//============================================================================

#include <iostream>

#include <stdio.h>

#include <sys/time.h>

#include <math.h>

#include "opencv2/opencv.hpp"

struct timeval start_time;

struct timeval end_time;

double elapsed_time;

float fps;

double total_fps = 0.0,average_fps = 0.0;

long cnt=1;

int cx,cy,radius,ccnt;

using namespace std;

int main() {

IplImage* img;

IplImage* GrayImg=0;

IplImage* Edge=0;

IplImage* HSVImg;

IplImage* HImg = 0;

IplImage* SImg = 0;

IplImage* VImg = 0;

int key;

int i,k;

double dp = 1;

double min_dist = 300;

double t,s;

double angle12,angle23,angle34,angle41;

int px1,py1,px2,py2,sx1,sy1,sx2,sy2,sx3,sy3,sx4,sy4,spx1,spy1,spx2,spy2;

double len12,len23,len34,len41;

double longlen;

double abase, aheight;

char buffer[25];

CvFont font;

cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX,0.5,0.5);

CvSeq* result;

CvPoint* pt1;

CvPoint* pt2;

CvPoint* pt3;

CvPoint* pt4;

CvCapture* capture = cvCaptureFromCAM(0);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, 640);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, 480);

cvSetCaptureProperty( capture, CV_CAP_PROP_FPS, 65);

while(1)

{

gettimeofday(&start_time,NULL);

cvGrabFrame(capture);

img = cvRetrieveFrame(capture);

GrayImg = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);

Edge = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);

cvCvtColor(img,GrayImg,CV_BGR2GRAY);

cvSmooth(GrayImg,GrayImg,CV_GAUSSIAN,9,9,2,2);

cvThreshold(GrayImg,GrayImg,200,255,CV_THRESH_BINARY);

cvCanny(GrayImg,Edge,25,200,3);

CvMemStorage* storage = cvCreateMemStorage(0);

CvSeq* Contours;

cvFindContours(Edge,storage,&Contours, sizeof(CvContour),CV_RETR_LIST,CV_CHAIN_APPROX_SIMPLE);

while(Contours)

{

result = cvApproxPoly(Contours,sizeof(CvContour),storage,CV_POLY_APPROX_DP,cvContourPerimeter(Contours)*0.02,0);

if(result->total == 4 && fabs(cvContourArea(result,CV_WHOLE_SEQ)) > 1000 && cvCheckContourConvexity(result))

{

pt1 = (CvPoint*)cvGetSeqElem(result,0);

pt2 = (CvPoint*)cvGetSeqElem(result,1);

pt3 = (CvPoint*)cvGetSeqElem(result,2);

pt4 = (CvPoint*)cvGetSeqElem(result,3);

int x1 = pt1->x;

int y1 = pt1->y;

int x2 = pt2->x;

int y2 = pt2->y;

int x3 = pt3->x;

int y3 = pt3->y;

int x4 = pt4->x;

int y4 = pt4->y;

cvCircle(img,cvPoint(x1,y1),3,CV_RGB(255,0,0),3,8,0);

cvCircle(img,cvPoint(x2,y2),3,CV_RGB(255,0,0),3,8,0);

cvCircle(img,cvPoint(x3,y3),3,CV_RGB(255,0,0),3,8,0);

cvCircle(img,cvPoint(x4,y4),3,CV_RGB(255,0,0),3,8,0);

cvLine(img,cvPoint(x1,y1),cvPoint(x2,y2),CV_RGB(0,0,255),2,8,0);

cvLine(img,cvPoint(x2,y2),cvPoint(x3,y3),CV_RGB(0,0,255),2,8,0);

cvLine(img,cvPoint(x3,y3),cvPoint(x4,y4),CV_RGB(0,0,255),2,8,0);

cvLine(img,cvPoint(x4,y4),cvPoint(x1,y1),CV_RGB(0,0,255),2,8,0);

//calculate angle

//calculate length of two point

len12 = sqrt(pow(x1-x2,2) + pow(y1-y2,2));

len23 = sqrt(pow(x2-x3,2) + pow(y2-y3,2));

len34 = sqrt(pow(x3-x4,2) + pow(y3-y4,2));

len41 = sqrt(pow(x4-x1,2) + pow(y4-y1,2));

//sort len

longlen = len12;

px1 = x1;

py1 = y1;

px2 = x2;

py2 = y2;

sx1 = x2;

sy1 = y2;

sx2 = x3;

sy2 = y3;

sx3 = x4;

sy3 = y4;

sx4 = x1;

sy4 = y1;

if(len23 > longlen)

{

longlen = len23;

px1 = x2;

py1 = y2;

px2 = x3;

py2 = y3;

sx1 = x3;

sy1 = y3;

sx2 = x4;

sy2 = y4;

sx3 = x1;

sy3 = y1;

sx4 = x2;

sy4 = y2;

}

if(len34 > longlen)

{

longlen = len34;

px1 = x3;

py1 = y3;

px2 = x4;

py2 = y4;

sx1 = x4;

sy1 = y4;

sx2 = x1;

sy2 = y1;

sx3 = x2;

sy3 = y2;

sx4 = x3;

sy4 = y3;

}

if(len41 > longlen)

{

longlen = len41;

px1 = x1;

py1 = y1;

px2 = x4;

py2 = y4;

sx1 = x1;

sy1 = y1;

sx2 = x2;

sy2 = y2;

sx3 = x3;

sy3 = y3;

sx4 = x4;

sy4 = y4;

}

spx1 = (sx1 + sx2) / 2;

spy1 = (sy1 + sy2) / 2;

spx2 = (sx3 + sx4) / 2;

spy2 = (sy3 + sy4) / 2;

cvLine(img,cvPoint(spx1,spy1),cvPoint(spx2,spy2),CV_RGB(0,255,0),2,8,0);

px1 = spx1;

py1 = spy1;

px2 = spx2;

py2 = spy2;

//find min x -> point2

//point 1 - point2

abase = px2 - px1;

aheight = py2 - py1;

angle23 = atan(aheight/abase);

angle12 = angle23*180.0/3.141592;

sprintf(buffer,"ang= %02.2f",angle12);

cvPutText(img,buffer,cvPoint(abs((px2+px1)/2),abs((py2+py1)/2)),&font,CV_RGB(255,0,0));

}

Contours = Contours->h_next;

}

cvNamedWindow( "PreviewImage", 1 );

cvShowImage( "PreviewImage", img );

cvMoveWindow("PreviewImage",200,100);

cvNamedWindow( "GrayImage", 1 );

cvShowImage( "GrayImage", GrayImg );

cvMoveWindow("GrayImage",850,600);

cvNamedWindow( "Edge", 1 );

cvShowImage( "Edge", Edge );

cvMoveWindow("Edge",850,100);

key = cvWaitKey(1);

if(key > 10) break;

gettimeofday(&end_time, NULL);

elapsed_time = (double)(end_time.tv_sec) + (double)(end_time.tv_usec)/1000000.0 - (double)(start_time.tv_sec) - (double)(start_time.tv_usec)/1000000.0;

fps = 1.0 / elapsed_time;

total_fps += fps;

average_fps = total_fps / (double)(cnt);

cnt++;

if(cnt == 100)

{

cnt = 1;

total_fps = 0.0;

}

elapsed_time *= 1000.0;

printf("Elapsed T = %2.3f ms, Frame = %2.3f (fps), Avrg Frame Rate = %2.3f count = %d\n",elapsed_time,fps,average_fps,result->total);

//Circles->total = 0;

cvReleaseImage(&GrayImg);

cvReleaseImage(&Edge);

cvReleaseMemStorage(&storage);

} //end of while(1)

cvReleaseImage(&img);

cvReleaseCapture( &capture );

return 0;

}

sudo apt-get install cmake

sudo apt-get install libtbb2

sudo apt-get install libtbb-dev

sudo apt-get install libgtk2.0-dev

sudo apt-get install libjpeg62-dev

sudo apt-get install libjasper-dev

sudo apt-get install libtiff4-dev

sudo apt-get install ffmpeg

sudo apt-get install libavformat-dev

sudo apt-get install libswscale-dev

sudo apt-get install libgstreamer0.10-dev

sudo apt-get install libgstreamermm-0.10-dev

sudo apt-get install libdc1394-22-dev

sudo apt-get install libv4l-dev

sudo apt-get install libopenexr-dev

sudo apt-get install libxine-dev

sudo apt-get install libunicap2-dev

sudo apt-get install libucil2-dev

별문제 없이 설치 되는 걸로 보아 그냥 이렇게 해도 된다. (나도 참 무식하다 ㅋ)

sudo apt-get install cmake libtbb2 libtbb-dev  libgtk2.0-dev libjpeg62-dev libjasper-dev libtiff4-dev ffmpeg libavformat-dev libswscale-dev libgstreamer0.10-dev 

libgstreamermm-0.10-dev libdc1394-22-dev libv4l-dev libopenexr-dev libxine-dev libunicap2-dev libucil2-dev

mkdir release

sudo make install

sudo ldconfig

pkg-config --cflags opencv

pkg-config --libs opencv

sudo apt-get purge openjdk

sudo add-apt-repository ppa:webupd8team/java

sudo apt-get update

sudo apt get install oracle-java7-installer

sudo gedit /usr/share/applications/eclipse.desktop

[Desktop Entry]

Encoding=UTF-8

Name=Eclipse

Comment=Eclipse IDE

Exec=/home/jslee/eclipse/eclipse

Icon=/home/jslee/eclipse/icon.xpm

Terminal=false

Type=Application

Categories=GNOME;Application;Development;

StartupNotify=true

C: IplImage* cvCreateImage(CvSize size, int depth, int channels)

Parameters:

size – Image width and height

depth – Bit depth of image elements. See IplImage for valid depths.

channels – Number of channels per pixel. See IplImage for details. This function only creates images with interleaved channels.

link:

http://docs.opencv.org/modules/core/doc/old_basic_structures.html?highlight=cvcreateimage#IplImage* cvCreateImage(CvSize size, int depth, int channels)

Converts an image from one color space to another.

C++: void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0 )

Python: cv2.cvtColor(src, code[, dst[, dstCn]]) → dst

C: void cvCvtColor(const CvArr* src, CvArr* dst, int code)

Python: cv.CvtColor(src, dst, code) → None

Parameters:

src – input image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision floating-point.

dst – output image of the same size and depth as src.

code – color space conversion code (see the description below).

dstCn – number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code ..

link:

http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=cvcvtcolor#void cvCvtColor(const CvArr* src, CvArr* dst, int code)