모과이의꿈

출처 : http://www.aishack.in/2010/03/the-hough-transform/

(허프 번환에 대해서 제일 정리가 잘된거 같아 링크함)

The Hough transform is an incredible tool that lets you identify lines. Not just lines, but other shapes as well. In this article, I’ll talk about the mechanics behind the Hough transform. It will involve a bit of math, but just elementary concepts you learned in school.

In this article, we’ll work with lines only, though the technique can be easily extended to other shapes.

Why the Hough Transform?

Lets say you take the snapshot of pole. You figure out edge pixels (using the Canny edge detector, the Sobel edge detector, or any other thing). Now you want a geometrical representation of the pole’s edge.You want to know its slope, its intercept, etc. But right now the “edge” is just a sequence of pixels.

You can loop through all pixels, and some how figure out the slope and intercept. But that is one difficult task. Images are never perfect.

So you want some mechanism that give more weightage to pixels that are already in a line. This is exactly what the Hough Transform does.

It lets each point on the image “vote”. And because of the mathematical properties of the transform, this “voting” allows us to figure out prominent lines in the image.

From lines to points

A lines is a collection of points. And managing a collection of points is tougher than managing a single point. Obviously. So the first thing we learn is how to represent a line as a single point, without losing any information about it.

This is done through the m-c space.

As shown in the above picture, every line has two quantities associated with it, the slope and the intercept. With these two numbers, you can describe a line completely.

So the parameter space, or the mc space was devised. Every line in the xy space is equivalent to a single point in the mc space. Neat eh?

From points to lines

Now onto the next step. Consider a point (say, (xa, ya) )in the xy space. What would its representation in the mc space be?

For starters, you could guess that infinite lines pass through a point. So, for every line passing through (xa, ya), there would be a point in the mc space.

And you’re correct there, because of the following:

1. Any line passing through (xa, ya): ya = mxa + c
2. Rearranging: c = – xam + ya
3. The above is the equation of a line in the mc space.

So, a point in the xy space is equivalent to a line in the mc space.

How does this help us?

The Hough transform is all about doing what we just learned: converting points in the xy space to lines in the mc space.

You taken an edge detected image, and for every point that is non black, you draw lines in the mc place. Obviously, some lines will intersect. These intersections mark are the parameters of the line.

The following picture will clarify the idea:

The points 1, 2, 3, and 4 are represented as various lines in the mc space. And the intersection of these lines is equivalent to the original line.

Great!

Now you know the basic idea of how the Hough transform works. But there’s one big flaw in the We’ll discuss how to resolve this issue in the next article.

// moguwai1. 부분스크린샷//

Rect rect(248,373,40,60);

Mat subimage=undistortedThreshed(rect);

// reSize

resize(subimage,subimage,Size(200,200));

// (src,dst,size)

// FileSave

imwrite("pic0.png", subimage);; //Show image

출처 : http://kimhj8574.egloos.com/4734597

*** IplImage 관련,  생성과 해제 등
//생성
IplImage *srcimg_R  = NULL;
srcimg_R  = cvCreateImage(cvSize(m_width,m_height), 8, 3);   //cvSize(640,480) 같은 것도 됨
srcimg_R  = cvCreateImage(cvGetSize(src_color), 8,3);  //요것도 됨.  다른 IplImage 사이즈 받아와서

//요런것도 됨
CvSize img_size;   
img_size.height = ImageHeight;
img_size.width  = ImageWidth;

IplImage* BGR_image = cvCreateImage(img_size, IPL_DEPTH_8U, 3); 

//이미지 복사하기
src = cvCloneImage(src_img);  //src가 비어있어야 함.  아니면 메모리 계속 쌓인다
cvCopy(src_img, src_img2);

//컬러 이미지 각 소스별로 분리하거나 합치거나 할 때
cvCvtPixToPlane( src_hlsimg, Hue, Intensity, Saturation, NULL );  //HLS 이미지 각 속성별로 나눔
cvCvtPlaneToPix( Hue, Intensity, Saturation, NULL, Equ_hls );  //다시 합친다

//0으로 초기화
cvZero(src_img);

//해제
if(srcimg_R)
  cvReleaseImage(&srcimg_R);




*** IplImage의 ROI 설정하기
//설정한 ROI 부분을 전체 이미지 인 것처럼 다룬다
//cvSetImageROI( IplImage* img, CvRect rect )
//rect는 순서대로 ROI의 왼쪽 위점의 좌표(offset), ROI의 width, height이다.
cvSetImageROI(src, cvRect(CenterX-ROI_width/2, CenterY-ROI_height/2, ROI_width, ROI_height));

//설정한 ROI 해제하기
cvResetImageROI( IplImage* img );

if(inputimg->roi != 0x00)  //ROI가 설정되어 있다면

inputimg->roi->width  //ROI의 속성 접근하기
inputimg->roi->height...

//특징
// - Haar 등에 ROI 지정해서 넣으면 그 안쪽에서만 연산(마치 ROI가 전체이미지인듯)
// - cvSvaeImage 등을 수행하면 ROI 안쪽만 저장된다.  cvResize 등도 마찬가지




*** IplImage 안의 이미지 화소 조절하기

...
cvGetReal2D(srcimg, i, j);             //높이가 i, 폭이 j
cvSetReal2D(srcimg, i, j, value);    //value는 설정할 값
...




*** 이미지 불러오기, 저장하기
//불러오기
TmpLImg = cvLoadImage("img_InElevator_1_L.bmp");    //간단하게, TmpLImg는 IplImage
//복잡하게
if ((TmpLImg = cvLoadImage("img_InElevator_1_L.bmp")) == 0)  // load left image
{
   printf("%s", "left image file read has failed!! \n");
   return 0;
}

//저장하기
char file_name[20];
sprintf(file_name,"img_R.bmp");            //파일이름 맹글기
cvSaveImage(file_name,srcimg_R);   //srcimg_R 이라는 IplImage를 저장 




***이미지 위아래나 좌우 뒤집기, 반전
cvFlip(src, dst, 0);   //0은 수직방향 반전, 1은 수평방향 반전, -1은 양방향 다 반전




*** 캠 입력받기

IplImage *src;       //source 이미지니까 src로 이름지음
//capture for cam
 CvCapture* capture = cvCaptureFromCAM(0);

 //get init scene
 cvGrabFrame(capture);
 src=cvRetrieveFrame(capture);

......
cvGrabFrame(capture);
src=cvRetrieveFrame(capture);
......

cvReleaseCapture( &capture );

//다른 방법
IplImage *src;
CvCapture* capture = cvCaptureFromCAM(0);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH,640);    //잘 안됨
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT,480); 

...
src = cvQueryFrame( capture );.
...




***AVI등 동영상 파일에서 불러오기

//동영상파일로부터받아오기
CvCapture* input_video = 0;
input_video = cvCreateFileCapture( "z4m.avi");

//받아온 프레임 사이즈
CvSize frame_size;
int height =(int) cvGetCaptureProperty( input_video, CV_CAP_PROP_FRAME_HEIGHT );
int width  =(int) cvGetCaptureProperty( input_video, CV_CAP_PROP_FRAME_WIDTH );
int fps     =(int) cvGetCaptureProperty(input_video, CV_CAP_PROP_FPS);
printf("width : %d, height : %d, fps : %d\n", width, height, fps);  

//연산에 사용될 IplImage 구조체
IplImage *src;

if( (src=cvQueryFrame(input_video)) != 0)
{
    printf("file read success!!\n");
}

while(1)
{
    src=cvQueryFrame(input_video); 
}

cvReleaseCapture( &input_video );  //IplImage 메모리 제거는 하지 않는다.(생성도 안했으니)





*** 창 만들고 닫기 등등
//생성
cvNamedWindow("Right Original", CV_WINDOW_AUTOSIZE);

//창 움직이기 - uv 좌표로 배치함
cvMoveWindow("source_color",610,0);

//보이기
cvShowImage( "Right Original", srcimg_R );

//창 닫기
cvDestroyAllWindows();  //모든 OpenCV 윈도우 닫기

//특정 윈도우만 닫기
cvDestroyWindow("Right Original");




*** canny edge detect 사용하기
...
IplImage *canny_R   = NULL;
canny_R    = cvCreateImage(cvSize(m_width,m_height), 8, 1);
...
cvCvtColor(srcimg_R, grayimg_R, CV_BGR2GRAY);   //원본 컬러이미지를 흑백으로 변환하고

cvCanny( grayimg_R, canny_R, 40, 130, 3 );  //그 흑백이미지를 캐니로 변환




*** Harris edge detector
IplImage *harris = cvCreateImage(cvSize(WIDTH,HEIGHT), IPL_DEPTH_32F, 1);
cvCornerHarris(src_gray, harris, 3, 9, 0.07); 


***Smoothing 연산
//Gaussian filtering
cvSmooth(src, Gaussed_image, CV_GAUSSIAN, 3);  //src는 gray영상, 두번째 매개변수도 IplImage임, 3은 마스크 크기

//DoG(Difference of Gaussian)
cvSmooth(src_gray, GaussImg1, CV_GAUSSIAN, 3);
cvSmooth(src_gray, GaussImg2, CV_GAUSSIAN, 27);
cvSub(GaussImg1, GaussImg2, dst);






*** HLS 이미지로 변환하기
...
IplImage* src_hlsimg = cvCreateImage(cvSize(m_width,m_height), 8, 3);  //HLS 저장할 곳
//각 속성들 저장할 곳 선언
IplImage* Hue         = cvCreateImage(cvSize(m_width,m_height), 8, 1);
IplImage* Intensity   = cvCreateImage(cvSize(m_width,m_height), 8, 1);
IplImage* Saturation = cvCreateImage(cvSize(m_width,m_height), 8, 1);

cvCvtColor(srcimg, src_hlsimg, CV_BGR2HLS);   //src_hlsimg IplImage 구조체에 HLS 이미지 담긴다
cvCvtPixToPlane( src_hlsimg, Hue, Intensity, Saturation, NULL );  //HLS 이미지 각 속성별로 나눔
cvCvtPlaneToPix( Hue, Intensity, Saturation, NULL, hsvVideo2 );  //도로 합치기




*** 모폴로지 연산 Morphology

IplConvKernel* kernel;

kernel= cvCreateStructuringElementEx( 3, 3, 0, 0, CV_SHAPE_RECT, NULL );

cvMorphologyEx( temp_eyeimg, temp_eyeimg, NULL,kernel, CV_MOP_CLOSE , 1 );

*** 창으로 부터 키 입력 받기
...
pressed_key=cvWaitKey(0) ;
  if(pressed_key=='q')    //q 키가 누르면 빠져나가기
    break;
  else if(pressed_key=='c')  //캡쳐 키 누르면 캡쳐
  {
    timer=time(NULL);  //현재시간저장
    t=localtime(&timer); //지역시간
    sprintf(file_name,"img_%4d%02d%02d%02d%02d%2d.bmp",t->tm_year + 1900, t->tm_mon +1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); //파일이름 맹글기

    cvSaveImage(file_name, src_color);

    //확인메시지출력
    printf("%s file saved is success!!\n",file_name);
  }




*** 이미지 크기 줄이기

//생성
pEviMonitor = cvCreateImage(cvSize(m_pImgWidth, m_pImgHeight), IPL_DEPTH_8U, 1);
pEviMonitor2 = cvCreateImage(cvSize(m_pImgWidth/2, m_pImgHeight/2), IPL_DEPTH_8U, 1);  //  1/2 크기로 생성

//크기 줄이기
cvResize(pEviMonitor, pEviMonitor2, CV_INTER_LINEAR);  // For Resize




*** 화면에 글자 쓰기

char s_output_result[50];
CvFont font;
...
sprintf(s_output_result,"sum vector x:%1.3f  y:%1.3f",sumvector_x,sumvector_y );    //우선 sprintf로 문자열 생성
cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 0.5, 0.5, 0, 1);  //이런 저런 설정.
cvPutText(src_color, s_output_result ,cvPoint(15,20),&font,cvScalar(0,255,0));   //cvPoint로 글자 시작 위치 설정(uv)
//void cvInitFont(CvFont* font, int font_face, double hscale, double vscale, double italic_scale, int thickness)




*** 트랙바 생성

int hue_threshold=139;  //Hue 값의 피부색 threshold

cvNamedWindow( "HLS_image", CV_WINDOW_AUTOSIZE );
cvCreateTrackbar("Hue","HLS_image",&hue_threshold,255, NULL );  //중요한 부분은 요거




*** 마우스 입력

void on_mouse( int event, int x, int y, int flags, void* param );
......

cvSetMouseCallback( "LKTracker", on_mouse, NULL );
......

void on_mouse( int event, int x, int y, int flags, void* param )
{
    if( !image )
        return;

    if( image->origin )
        y = image->height - y;

    if( event == CV_EVENT_LBUTTONDOWN )
    {
        pt = cvPoint(x,y);
        add_remove_pt = 1;
    }
}




*** 인클루드 하는 것들

#include <cv.h>          //영상처리를 위한 헤더
#include <highgui.h>   //카메라로 영상을 입력받거나 이미지를 읽어들이고 화면에 보여주기 위한 헤더




*** good feature to track

IplImage *eig_image = NULL; 
IplImage *temp_image = NULL; 
eig_image  = cvCreateImage(cvSize(width,height), 32, 1);
temp_image = cvCreateImage(cvSize(width,height), 32, 1);

CvPoint2D32f frame1_features[4000];  //추출된 점들 저장하는 장소

int number_of_features; 
number_of_features = 400;  //추출되는 점의 개수를 제한

//안됨.  버전마다 매개변수 다른듯
//cvGoodFeaturesToTrack(src_gray, eig_image, temp_image, frame1_features, &number_of_features, .01, .01, NULL);
cvGoodFeaturesToTrack(src_gray, eig_image, temp_image, frame1_features, &number_of_features, 0.01, 5, 0, 3, 0, 0.04 );
//&number_of_features 로 추출된 점의 개수 나온다.  추출되는 점의 개수를 입력으로 제한함과 동시에 출력도...

//draw
for(int i=0; i<number_of_features; ++i) 
    cvCircle( result_img, cvPointFrom32f(frame1_features[i]), 1, CV_RGB(255,0,0), 3, 8, 0);

*** Line Fitting  (polar 코디네이트가 아니라 단점 있음)

int count = 0;        // total number of points   
float *line;     
 
CvPoint  left, right;    

//CvMat point_mat = cvMat( 1, count, CV_32SC2, mid_points );     
//cvFitLine( &point_mat, CV_DIST_L2 , 0, // line[0]:vector_x, line[1]:vector_y                
// 0.01, 0.01,  line );        // line[2]:x_n, line[3]:y_n     
//
long double a, b, c, d, e, f; 
////b가 기울기, a가 절편 
//b = line[1]/ line[0];        
//a = line[3]- b*line[2];        
b=((float)right.y-(float)left.y)/((float)right.x-(float)right.y);

//left.x=mid_points[0].x;
//left.y=b*left.x+a;

//right.x=mid_points[count-1].x;
//right.y=b*right.x+a;

//CvPoint center;     
//center.x = line[2];     
//center.y = line[3];     // can draw from left to right directly     
//cvLine( processed_image, center, left, CV_RGB(255,255,255), 1, 8 );     
cvLine( Draw_results, left, right, CV_RGB(255,0,0), 1, 8 );     




*** Mean-Shift Segmentation

//입출력 IplImage, spatial과 color radius 매개변수, level of scale pyramid(2 또는 3 적당) 
cvPyrMeanShiftFiltering(src_color, src_result, 2, 40, 3);




*** 체스보드 마크 탐지하기

int i;
int nCornerNum = 3 * 3; // number of corners in the chessboard (3 * 3)
int MAX_COUNT = nCornerNum;   // 5000

CvSize pattern_size = cvSize( COL_CHESS_CORNER_NUM, ROW_CHESS_CORNER_NUM );

 
CvPoint2D32f *left_corners = new CvPoint2D32f[nCornerNum];
CvPoint2D32f *right_corners = new CvPoint2D32f[nCornerNum];

int iLeft_corner_count, iRight_corner_count;
 
// Get the number of left and right corners
int iFoundLeft  = cvFindChessboardCorners(pLeftImg, pattern_size, left_corners, &iLeft_corner_count, CV_CALIB_CB_ADAPTIVE_THRESH);
int iFoundRight = cvFindChessboardCorners(pRightImg, pattern_size, right_corners, &iRight_corner_count, CV_CALIB_CB_ADAPTIVE_THRESH);
//////////////////////////////////////////////////////////////////////////

//printf("\n--------------  Marker Results -----------------------------\n");
//printf("Number of Left Corners: %d\n", iLeft_corner_count);

cvDrawChessboardCorners(pLeftImg, pattern_size, left_corners, iLeft_corner_count, iFoundLeft);
cvDrawChessboardCorners(pRightImg, pattern_size, right_corners, iRight_corner_count, iFoundRight);
 /-
 for (i = 0; i < iLeft_corner_count; i++)
 {   
  DrawCorner(pLeftImg, cvPointFrom32f(left_corners[i]));
  //printf("(%d,%d)\t", cvPointFrom32f(left_corners[i]).x, cvPointFrom32f(left_corners[i]).y);
 }
 *-

 //printf("\nNumber of right Corners: %d\n", iRight_corner_count);
 //for(i=0; i<iRight_corner_count; i++)
 //{
 // DrawCorner(pRightImg, cvPointFrom32f(right_corners[i]));
 // //printf("(%d,%d)\t", cvPointFrom32f(right_corners[i]).x, cvPointFrom32f(right_corners[i]).y);
 //}

float *plane = new float[4]; // return value
for (i=0; i<4; i++)    // Initialization, even though the plane equation is wrong 
{
    plane[i] = 1;  
}
 
// Calculate the plane equation based on the chessboard
if( iLeft_corner_count == iRight_corner_count && iLeft_corner_count == nCornerNum) // Left Corners and right corners should be same
{
    CvPoint *leftPoints = new CvPoint[nCornerNum];
    CvPoint *rightPoints = new CvPoint[nCornerNum];
    for(i=0; i<nCornerNum; i++)
    {
        leftPoints[i] = cvPointFrom32f(left_corners[i]);
        rightPoints[i] = cvPointFrom32f(right_corners[i]);
    }
  
    plane = planeEquationfrom2DPoints(leftPoints, rightPoints, nCornerNum, baseLine, focal, u0, v0);

    // output the plane equation result
    printf("\n-------------------------  Plane Equation ------------------------\n");
    for(i=0; i<4; i++)
    {
        printf("%.4f\t", plane[i]);
    }
    printf("\n");
    //----------------------------------------------------------

    delete [] leftPoints;
    delete [] rightPoints;
}
else
    printf("No Enough Corners For Marker \n");  // should modify

//if (left_corners)
// cvFree(&left_corners);
//if (right_corners)
// cvFree(&right_corners);
 
if (left_corners)
    delete [] left_corners;
if (right_corners)
    delete [] right_corners;
return plane;





*** 히스토그램 관련
CvHistogram* hist;
float min_value, max_value;  //히스토그램 최대값 최소값 저장용
int hist_size = 255;  //히스토그램 축들 개수

hist = cvCreateHist( 1, &hist_size, CV_HIST_UNIFORM); //1차원의, 각 속성 크기 hist_size인 히스토그램생성
cvCalcHist( &Hue, hist, 0, 0);                                       //Hue가 1차원 IplImage -> 실질적 입력
cvGetMinMaxHistValue(hist, &min_value, &max_value, 0, 0);   //히스토그램 최소최대값 얻기, 최대최소값의 위치
printf("hist min max:%f  %f\n",min_value, max_value);
cvZero(Hue_hist);

int axis_base = 210;  //그릴 때, 아래 축이 어느정도에 위치하는가
CvFont font;  //축에 글자 쓰기용
cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 0.3, 0.3, 0, 1);
char text[50];

for ( int i = 0; i < 255; ++i)
{
    int hist_value = cvRound( cvQueryHistValue_1D(hist,i)*255/max_value);  //히스토그램 값 normalization
    cvLine(Hue_hist, cvPoint(i+20, axis_base), cvPoint(i+20, abs(axis_base - hist_value) ), CV_RGB(255,255,255), 1);

    if ( (i % 20) == 0 )
    {
        sprintf( text, "%d", i);
        cvPutText( Hue_hist, text, cvPoint(i+20, axis_base+10), &font, CV_RGB(255,255,255));    
    }
}
if(hist)   //히스토그램 제거
    
cvReleaseHist(&hist);






*** 히스토그램 평활화 (histogram equalization)

IplImage* Src          = cvCreateImage(cvSize(width,height), 8, 1);   //원본 이미지
IplImage* Equalized = cvCreateImage(cvSize(width,height), 8, 1);   //평활화 된 이미지
cvEqualizeHist( Src, Equalized );





*** 이미지 회전시키기
CvPoint2D32f rot_center = cvPoint2D32f(ROI_width/2 , ROI_height/2);//회전중심설정// 그에 따른 매트릭스 만들기
CvMat *rot_mat = cvCreateMat( 2, 3, CV_32FC1);
//매트릭스 계산 
cv2DRotationMatrix( 
    rot_center, // Source Image의 센터를 정한다.
    Rotation_Angle,  // 이것은 각도 + 값은 시계 반대 반대 방향을 의미한다.
    1,  // 이미지 크기(scale)... 
    rot_mat); // 결과를 저장하는 매트릭스 이다.
   
//원본 이미지에 ROI 적용하기
cvSetImageROI(src, cvRect(CenterX-ROI_width/2, CenterY-ROI_height/2, CenterX+ROI_width/2, CenterY+ROI_height/2));
//변환하기
cvWarpAffine(src, 
                dst, 
                rot_mat, 
                CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,
                cvScalarAll(0)); // 선형보간




*** OpenCV 외 유용한 코드들

//파일에서 불러오기
char buffer[BUFFERSIZE], * temp, * label, ct [] = " ,\t\n";    //BUFFERSIZE = 1024
static int filenum = 0;

FILE *fp = fopen(".\img.txt", "r");

if(fp == NULL) 
    return false;
while (fgets(buffer,BUFFERSIZE,fp))
{
    label = strtok(buffer,ct);
    if(label == NULL) 
        continue;
    pDPT[p_index*NUMOFDIMESION] =  (float)atof(label);
    pDPT[p_index*NUMOFDIMESION + 1] = (float)atof(strtok(NULL,ct));
    pDPT[p_index*NUMOFDIMESION + 2] = (float)atof(strtok(NULL,ct));
    pBGR[c_index*NUMOFDIMESION] = (unsigned char)atoi(strtok(NULL,ct));
    pBGR[c_index*NUMOFDIMESION +1] = (unsigned char)atoi(strtok(NULL,ct));
    pBGR[c_index*NUMOFDIMESION +2] = (unsigned char)atoi(strtok(NULL,ct));
    pGray[c_index] = pBGR[c_index*NUMOFDIMESION];
    strtok(NULL,ct);
    strtok(NULL,ct);
    temp = strtok(NULL,ct);
    if(atoi(&temp[1]) <= 0)
    {
        // zero disparity or invalid 3D point
        pDPT[p_index*NUMOFDIMESION] =  INVALID_DEPTH_INFO;
        pDPT[p_index*NUMOFDIMESION + 1] = INVALID_DEPTH_INFO;
        pDPT[p_index*NUMOFDIMESION + 2] = INVALID_DEPTH_INFO;
    }
    p_index++;
    c_index++;
}fclose(fp);

//조금 다른 예, 다른 문자로 어떤 정보인지 표시된거
//3DM 파일 읽어들이기
while (fgets(buffer,2000,fp))
{
    label = strtok(buffer,ct);
    if(label == NULL) continue;
    if(!strcmp("ImageWidth",label))
    {
        m_imagewidth = atoi(strtok(NULL,ct));///samplingratio;
    }
    else if(!strcmp("ImageHeight",label))
    {
        m_imageheight = atoi(strtok(NULL,ct));///samplingratio;
    }  
    else if(!strcmp("F",label))
    {
        double x,y;
        double x3,y3,z3;
        x  = atof(strtok(NULL,ct));
        y  = atof(strtok(NULL,ct));
        idx3DSIFT.push_back(m_imagewidth * (int)y + (int)x);
        x3  = (double)atof(strtok(NULL,ct));
        y3  = (double)atof(strtok(NULL,ct)); 
        z3  = (double)atof(strtok(NULL,ct));
        x3DPoints.push_back((float)x3);
        y3DPoints.push_back((float)y3);
        z3DPoints.push_back((float)z3);
    } 
}
fclose(fp);

//또 조금 다른 예
while (fgets(buffer,2000,fp))
{
    label = strtok(buffer,ct);
    if(label == NULL) continue;
    if(!strcmp("ImageWidth",label))
    {
        m_imagewidth = atoi(strtok(NULL,ct));///samplingratio;
    }
    else if(!strcmp("ImageHeight",label))
    {
        m_imageheight = atoi(strtok(NULL,ct));///samplingratio;
    } 
    else if(!strcmp("F",label))
    {
        double x,y;
        double x3,y3,z3;
        x  = atof(strtok(NULL,ct));
        y  = atof(strtok(NULL,ct));
        idx3DSIFT.push_back(m_imagewidth * (int)y + (int)x);
        x3  = (double)atof(strtok(NULL,ct));
        y3  = (double)atof(strtok(NULL,ct)); 
        z3  = (double)atof(strtok(NULL,ct));
        x3DPoints.push_back((float)x3);
        y3DPoints.push_back((float)y3);
        z3DPoints.push_back((float)z3);
    } 
}
fclose(fp);



//3D만 가져올 때
char buffer[1024];
char *label;
char ct [] = " ,\t\n";
int index=0;
FILE *fp = fopen(".\img.txt", "r");

if(fp == NULL) 
    return;

while (fgets(buffer,1024,fp))
 {
  label = strtok(buffer,ct);
  if(label == NULL) 
   continue;
  p_3Dpt[index*3    ] = (float)atof(label);
  p_3Dpt[index*3 + 1] = (float)atof(strtok(NULL,ct));
  p_3Dpt[index*3 + 2] = (float)atof(strtok(NULL,ct));
  index++;
  if(index>=307200)
   break;
 }

fclose(fp);



//메모리, 용량 절약형 가져올 때
FILE *fp;
fp = fopen(file_name,"rt");

if(!fp)
{
  printf("\ncan not open 3dmfile\n");
  return false;
}

while (fgets(buffer,2000,fp))
{
  label = strtok(buffer,ct

  if(label == NULL) continue

  if(!strcmp("ImageWidth",label))
  {
    //m_imagewidth = atoi(strtok(NULL,ct));///samplingratio;
  }
  else if(!strcmp("ImageHeight",label))
  {
    //m_imageheight = atoi(strtok(NULL,ct));///samplingratio;
  } 
  else if(!strcmp("F",label))
  {
    double x,y;
    double x3,y3,z3;
    x  = atof(strtok(NULL,ct));
    y  = atof(strtok(NULL,ct));
    
    x3  = (double)atof(strtok(NULL,ct));
    y3  =  (double)atof(strtok(NULL,ct)); 
    z3  = (double)atof(strtok(NULL,ct));
    m_p3Dpt[3*(GetWidth() * (int)y + (int)x)  ] = x3;
    m_p3Dpt[3*(GetWidth() * (int)y + (int)x)+1] = y3;
    m_p3Dpt[3*(GetWidth() * (int)y + (int)x)+2] = z3;
    //y3  = -(double)atof(strtok(NULL,ct));
    // SVS ver 3.2 used mm scale
    //x3DPoints.push_back((float)x3*scale);
    //y3DPoints.push_back((float)y3*scale);
    //z3DPoints.push_back((float)z3*scale);
    // SVS ver 4.4 use m scale (model is saved by using m scale)
    //x3DPoints.push_back((float)x3);
    //y3DPoints.push_back((float)y3);
    //z3DPoints.push_back((float)z3);
    //if(idxDB == WCCup) printf("\nx=%f,\ty=%f,\tz=%f",x3,y3,z3);
  } 
}
fclose(fp);



//파일로 저장하기
FILE *fp = fopen("@@_FilterResult.txt", "at+");
fprintf(fp, "%d %f\n", nFrameNum, pEstimatedObjectPose[11]);
fclose(fp);

//메모리 카피
memcpy(src_color->imageData, m_pColorImage, sizeof(unsigned char)*width*height*3); 

//3D를 2D로 그리기 (대충)
for(int i=0;i<width;++i)
{
    for(int j=0;j<height;++j)
    {
        if((m_p3Dpt[3*(i+width*j)+2]>0.5)&(m_p3Dpt[3*(i+width*j)+2]<2.0))
            view_3D->imageData[i+width*j]=((m_p3Dpt[3*(i+width*j)+2]-0.5)/1.5)*255;
        else
            view_3D->imageData[i+width*j]=0;
    }}


//디버그 못하는 상황에서 파일로 쓰기, mfc나 wxwidgets 써서 printf 못쓸때 유용
{
  FILE *fp = fopen("#print.txt", "at+");
  fprintf(fp, "%d, a:%2.2f\n", i,spPlanes[i].planeparameter[0]);
  fclose(fp);
}

*** GUI 그리는거 관련
cvRectangle( temp_eyeimg, cvPoint(minX1,minY1), cvPoint(maxX1,maxY1), brightness ,1,8,0);
cvLine( Draw_results, left, right, CV_RGB(255,0,0), 1, 8 );     //8은 8connected, 4는 4connected
cvCircle( forDisplay, pt1, 1, CV_RGB(255,0,0), 1, 8, 0);

IPL 아키텍처의 중요한 개념으로 ROI( region of interest ) 가 있습니다. 모든 것의 영상 처리함수는 영상 전체뿐 아니라 영상의 일부를 대상으로 해서 실행 시킬 수도 있습니다.

  실행하고 싶은 처리에 따라서, 아래의 영역설정을 할 수 있습니다.

COI( Channel of interest )

COI로서 영상으로 주어질 수 있는 1개, 또는 모든 채널을 설정할 수 있습니다. 디폴트에서는 영상의 모든 채널이 처리 대상이다.

IplROI 구조체

typedef struct _IplROI{

  unsigned int coi;

  int xOffset;

  int yOffset;

  int width;

  int height;

}IplROI;

인수

coi : channel of interest

      0이라면 모든 채널이 처리대상이 된다.

xOffset,yOffset : ROI를 나타내는 장방형의 위치를 표시하는 offset

width, height : ROI를 나타내는 장방형의 크기

출처 : http://devmonster.tistory.com/12

1. OpenCV 다운로드

http://sourceforge.net/projects/opencvlibrary/

위의 URL로 접속하여 Download 받는다.

(현재 최신버전은 OpenCV 2.4.8이다.)

경로는 편리한 곳으로 설정하고 Extract

설치가 종료되면 아래와 같은 다운로드 창이 사라진다.

원하는 경로에 [opencv]라는 폴더가 생성된 것을 알 수 있다.

2. [컴퓨터]→[속성]→[고급 시스템 설정]→[환경 변수]→[새로만들기]

3. 새 시스템 변수 등록

변수 이름(N):  OPENCV_BUILD

변수 값(V):     C:\opencv\build

4. Path 등록

변수 값(V):     ;%OPENCV_BUILD%\x86\vc10\bin;

5. Visual Studio 2010 프로젝트 생성

6. [프로젝트 속성]→[VC++ 디렉터리]→[포함 디렉터리]→[편집]

C:\opencv\build\include 입력

7. [프로젝트 속성]→[VC++ 디렉터리]→[라이브러리 디렉터리]→[편집]  

C:\opencv\build\x86\vc10\lib 입력

8. [링커]→[입력]→[추가 종속성]→[편집]

opencv_calib3d248d.lib

opencv_contrib248d.lib

opencv_core248d.lib

opencv_features2d248d.lib

opencv_flann248d.lib

opencv_gpu248d.lib

opencv_highgui248d.lib

opencv_imgproc248d.lib

opencv_legacy248d.lib

opencv_ml248d.lib

opencv_objdetect248d.lib

opencv_ts248d.lib

opencv_video248d.lib

(※ 목록  Ctrl+C,V해서 사용하자!)

비록 구글에서 조금만 검색하면 바로 나오지만, 간단히 메모해 놓습니다. 

영상 관련 개인 공부용으로 작성하는 글이며, 다음 페이지에 있는 내용 입니다. ^^;

(http://www.ippbook.co.kr/xe/223)

A.

accumulator plane : 축적 평면

accumulator volume : 축적 공간

AdaBoost : 에이다 부스트

adaptive : 적응형, 적응적

algorithm : 알고르즘

aliasing : 에일리어싱

alpha blend : 알파 블렌드

alternative split : 대체 분기

anchor point : 고정점

anti-aliasing : 앤티 에일리어싱

aperture problem : 어퍼쳐 문제, 틈 문제, 구멍 문제, 틈새 문제

application : 응용 프로그램

area process : 영영 처리

aspect ratio : 영상 비

autocorrelation matrix : 자기 상관 행렬

average : 평균

B.

background differencing : 배경 차이

background model : 배경 모델

background substraction : 배경 제거, 배경 분리

barrel distortion : 술통형 왜곡, 배럴 왜곡

baseline : 기준선, 기본선, 기선

basis function : 기저 함수

Bayes classifier : 베이즈 분류기

Bayesian network : 베이시안 네트워크

Bhattacharyya distance : 바타차야 거리

bias : 평향, 바이어스

bicubic interpolation : 3차 회선 보간법

bilateral filter : 양방향 필터

bilinear interpolation : 양선형 보간법

bilinear transformation : 양선형 변환

bin : 빈

bird's eye view : 조감도, 조안 시점

blend : 혼합하다, 섞는다

blob : 덩어리, 블럽

blurring : 블러링, 흐리게하기

bounding box : 바운딩 박스, 경계 상자

boosted cascade object detector : 부스트된 직렬 객체 검출기

boosted rejection cascade : 부스트된 거절 캐스케이드

bootstrapping : 부트스트래핑

Bresenham algorithm : 브레제남 알고리즘

brightness : 밝기

brightness constancy : 밝기 항상성

C.

camera calibration : 카메라 보정

Canny edge detector : 캐니 엣지 검출기

categorical : 범주적

category : 카테고리, 범주

center of projection : 중심 모멘트

chessboard : 체스판

Chi-square : 카이-제곱

chrominance : 색상

classifier : 분류, 분류기

closed-form solution : 폐쇄형 해

closed contour : 폐외곽선

clustering : 군집화

codebook : 코드북

codebook entry : 코드북 항목

color similarity : 색상 유사도

color gamut : 색상 진역

color space : 색상 공간

compositing : 합성 과정

compression : 압축

condensation algorithm : 콘덴세이션 알고리즘

confusion matrix : 혼동 행렬

connected component : 연결된 구성 요소

cone : 콘

container class template : 컨테이너 클래스 템플릿

continuous tone : 연속된 색조

contour : 외곽선

contrast : 대비

contrast stretching : 대비 확장

control input : 제어 입력

convex : 컨벡스, 볼록

convex hull : 컨벡스 헐

convex polygon : 컨벡스 다각형

convolution coefficient : 컨볼루션 계수

convolution kernel : 컨볼루션 커널

convolution mask : 컨볼루션 마스크

corner : 코너, 모서리

correction phase : 교정 단계

correlation : 상관관계

correspondence : 대응점

cost : 비용

cross-validation : 교차-검증

cubic spline : 큐빅 스플라인

D.

decoder : 복호기, 해석기, 디코더

decision tree : 결정 트리

decision stump : 결정 그루터기

Delaunay triangle : 들로네 삼각형

Delaunay triangulation : 들로네 삼각망

deferred learning : 지연 학습

depth map : 깊이 지도

depth perception : 깊이 지각

deque : 디큐, 덱

difference image : 차영상

dilation : 팽창

dithering : 디더링, 뭉갬 효과의 일종(AA)

discriminative algorithm : 구별 알고리즘

disparity : 시차

disparity map : 시차 지도

distance norm : 거리 놈

distortion : 왜곡

distortion map : 왜곡 지도

dense : 밀집

difference norm : 차이 놈

dominant point : 우세 점

downsampling : 다운샘플링

dynamic programming : 동적 프로그래밍

E.

edge : 엣지, 경계

edge detector : 엣지 검출기

edge gradient : 엣지 그래디언트

edge-preserving smoothing : 엣지 보존 스무딩

eigen face : 고유 얼굴

eigen object : 고유 객체

embedded : 내장된

embedded hidden Markov model : 임베디드 은닉 마르코프 모델

encoder : 인코더

ensemble : 앙상블

entropy coding : 엔트로피 코딩

epipolar : 에피폴라

epipolar geometry : 에피폴라 기하

epipolar line : 에피폴라 직선

erosion : 침식

error : 오류, 오차

essential matrix : 필수 행렬

estimation : 추정

estimator : 추정자

Euclidean distance : 유클리디언 거리

expectation maximization : 기대값-최대화, EM

extended Kalman filter : 확장 칼만 필터, EKF

extrinsic parameter : 외부 파라미터

F.

facet : 면

false negative : 거짓-음성, 거짓-부정

false positive ; 거짓-양성, 거짓-부정

feature : 특징

feature point : 특징점

filter : 필터

fitting : 적합, 피팅

floodfill : 플러드필, 범람 채우기

focal length : 초첨 거리

Fourier transform : 푸리에 변환

fractal : 프렉탈

frame : 프레임

frame buffer : 프레임 버퍼

frame grabber : 프레임 획득기

frame rate : 프레임 률

Freeman chain code : 프리만 체인 코드

frequency domain : 주파수 영역

frequency transform : 주파수 변환

frontal parallel : 정면 평행

fundamental matrix : 기본 행렬

G.

gamma : 감마

gamma correction : 감마 보정

Gaussian : 가우시안

Gaussian mixture model : 가우시안 혼합 모델

generative algorithm : 생성 알고리즘

generative model : 생성 모델

generic container class : 제너릭 컨테이너 클래스

geometric process : 기하학적 처리

gesture : 제스쳐

gradient : 그래디언트

gradient descent (method) : 그래디언트 하강 (방법)

graphical model : 그래프 모델

grayscale : 그레이 스케일

H.

Harr : 하르

Harr-like : 유사-하르

halftoning : 간색

hidden Markov model : 은닉 마르코프 모델

hidden variable : 숨은 변수

high pass filter : 고주파 통과 필터

histogram : 히스토그램

histogram equalization : 히스토그램 균등화

homogenous coordinate : 동차 좌표계

homography : 호모그래피

Horn-Schunk optical flow : 혼-생크 옵티컬 플로우

Hough transform : 허프 변환

Hough line transform : 허프 직선 변환

Hough circle transform : 허프 원 변환

hue : 색상

Huffman coding : 허프만 코딩

hyperplane : 초평면

I.

identification : 식별

image analysis : 영상 분석

image compression : 영상 압축

image enhancement : 영상 향상, 영상 신장

image patch : 영상 패치, 부분 영상

image plane : 영상 평면

image pyramid : 영상 피라미드

image stablization : 영상 안정화

imager : 영상 센서

impulse noise : 임펄스 잡음

index : 인덱스

information fusion : 정보 융합

innovation : 혁신

inpainting : 인페인팅

integral image : 적분 영상

intensity : 명도, 밝기

interleave(d) : 인터리브 (방식)

interpolation : 보간

intrinsic parameter : 내부 파라미터

J.

Jacobian (matrix) : 자코비안 (행렬)

K.

Kalman filter : 칼만 필터

key frame : 키 프레임

L.

Laplacian : 라플라시안

layer : 레이어

laser range finder : 레이저 거리계

leaf node : 리프 노드

learning : 학습

least-square method : 최소자승법

least-square error : 최소자승 오류

lightness : 밝기

likelihood : 우도

line fitting : 직선 적합

link strength : 결합 강도

local : 지역적, 국지적

lookup table : 룩업 테이블

loss : 손실

lossless encoding : 무손실 인코딩

lossy encoding : 손실 인코딩

low pass filter : 저주파 통과 필터

Lucas-Kanade optical flow : 루카스-카나데 옵티컬 플로우

M.

magnification : 확대

Mahalanobis distance : 마할라노비스 거리

Mahattan distance : 맨하튼 거리

mapping : 매핑, 사상

Markov random field : 마르코프 랜덤 필드

matching : 매칭, 정합

maximum filter : 최대값 필터

mean-shift (algorithm) : 평균 이동 (알고리즘)

measurment : 측정(치)

median filter : 중간값 필터

memory storage : 메모리 스토리지

MIT Media Lab : MIT 미디어 랩

minimum filter : 최소값 필터

misclassification : 오분류

missing feature : 상실된 특징

mode : 모드, 최빈값

model : 모델

modeling : 모델링

moire patters : 모아레 패턴

monotone polygon : 모노톤 다각형

morphing : 모핑

morphological transformation : 모폴로지 변환

morphological gradient : 모폴로지 그래디언트

morphology : 모폴로지

motion : 움직임, 모션

motion history image : 움직임 기록 영상

motion template : 모션 템플릿

N.

native Bayes (classifier) : 순수 베이즈 (분류기)

node : 노드

noise : 잡음

nonrigid body : 비강체

nonuniform histogram : 불균등 히스토그램

norm : 놈

normal Bayes (classifier) 정상 베이즈 (분류기)

normalized moments : 정규화 모멘트

numeric : 수치적

O.

occlusion : 폐색

ordered : 순차적

operating point : 동작점

optical axis : 광축

optical flow : 옵티컬 플로우, 광류

orthographic projection : 정사 투영

outier : 이상치

overconstrained : 과제약

overfitting : 과적합

overflow : 오버플로우

P.

palette : 팔레트

pan : 팬

particle filter : 파티클 필터

perspective transform : 투시 변환

perspective projection : 투시 투영

physical world : 실세계(real world)

pinhole camera : 핀홀 카메라, 바늘 구멍 카메라

pinhole plane : 핀홀 평면

pixel : 픽셀, 화소

planar homography : 평면 호모 그래피

point of projection : 투영점

prediction : 예측

principal point : 주점

principal ray : 주선

precision : 정확률

process noise : 프로세스 잡음

progressive probabilistic Hough transform : 진보된 확률적 허프 변환

projection : 투영, 사영

projective transform : 투영 변환

proximity : 근접도

pruning : 가지치기

pseudo code : 의사 코드, 유사 코드

punishment : 벌칙, 처벌

Q.

quad-edge : 쿼드-엣지

quantization : 양자화

R.

radial distortion : 방사 왜곡

radian : 레디언

random tree : 랜덤 트리

range finder : 거리계

rank : 랭크, 계수

rank deficient : 계수 부족

raster : 래스터

real world : 실세계(physical world)

recall : 재현률

rectification : 조정, 렉티피케이션

reflection : 반사율

regression : 희귀

reinforcement learning : 강화 학습

rejection cascade : 거절 캐스케이드

rendering : 렌더링

resampling : 재샘플링

resolution : 해상도

retina : 망막

rigid body : 강체

risk : 위험

rods : 간상체

root node : 루트 노드

row-aligned : 행-정렬(된)

running average : 이동 평균

running total : 누적 합계

S.

sampling : 샘플링

saturation : 채도

scaling : 스케일링

Scale Invariant Feature Transform : 크기 불변 특징 변환, SIFT

scan : 스캔

Scharr filter : 샤르 필터

semisupervised learning : 반교사 학습

sequence : 시퀀스

sequence writer : 시퀀스 라이터

sequence reader : 시퀀스 리더

sharpening : 샤프닝

shot noise : 샷 잡음

signature : 시그니처

silhouette : 실루엣

smoothing : 스무딩

sparse : 희소

spatial coherence : 공간 일관성

spatial domain : 공간 영역

spatial frequency : 공간 주파수

stale : 실효된

state : 상태

standard deviation : 표준 편차

stereo : 스테레오

stereo correspondence : 스테레오 대응

structure from motion : 움직임 기반 구조, 모션 기반 구조

structure element : 구성 요소

subdivision : 구획, 세분

subpixel : 서브 픽셀

subregion : 부분 영역

super pixel : 수퍼 픽셀

supervised learning : 교사 학습

surrogate split : 대리 분기

T.

template : 템플릿

template matching : 템플릿 매칭

temporal persistence : 시간 지속성

test set : 실험 집합

threshold : 임계값

tilt : 틸트

time stamp : 타임스탬프

time step : 시간 단계

top-down : 하향식

top hat : 탑-햇

total norm : 전체 놈

tracking : 추적, 트래킹

tradeoff : 트레이드 오프, 적절한 타협

training set : 훈련 집합

transfer matrix : 전이 행렬

translation : 이동

triangulation : 삼각화, 삼각법

true color : 트루 컬러

true negative : 참-음성, 참-부정

true positive : 참-양성, 참-긍정

U.

uncertainty : 불확실성

underfitting : 부적합

undistortion : 왜곡 제거, 왜곡 펴기

uniform histogram : 균등 시스토그램

uniform noise : 균일 잡음, 정규 잡음

unscented particle : 언센티드 파티클 필터(UPF)

unsharp mask : 언샤프 마스크

unsupervised learning : 비가 학습

update gain : 갱신 이득

upsampling : 업샘플링

V.

validation set : 검증 집합

variable importance : 변수 중요도 

variance : 분산, 변이

vector graphics : 벡터 그래픽스

vector quantization : 벡터 양자화

visual acuity : 시각적 차이

video : 비디오, 동영상

volume rendering : 볼륨 렌더링

voronoi tessellation : 보로노이 테셀레이ㅕㄴ

voxel : 복셀

W.

warping : 와핑

wavelet : 웨이블릿

weak-perspective approximation : 약한-투시 근사화

whiteout : 화이트아웃

white noise : 백색 잡음

white point : 백색점 

windowing function : 윈도우 함수

wrapping function : 포장함수

X.

Y.

Z.

Zernike moments : 저니키 모멘트

zoom : 줌

zoom in : 줌-인

zoom out : 줌-아웃