Computer Science

.

마이다스아이티의 수장이신 이형우 대표님의 CEO강연회를 들으러 성대 수원캠퍼스를 다

녀왔습니다.

우선 마이다스아이티란 기업에 대해서 간단히 요약드리자면,

건설 구조해석 소프트웨어 분야 세계 1위

기계 구조해석 소프트웨어 국내 시장 판매 1위

건축엔지니어링 분야 국내 점유율 1위

World Class 300 최우수 선정 기업

최근 5년간 평균 매출 성장률 24%

이 밖에도 세계 86개국에 소프트웨어 프로그램을 수출 중 이며,

회사의 복지와 연봉 또한 동종업계 최상위 수준이라고 합니다.

더 많지만...관심있으신분은 마이다스사이트를  http://www.midasit.com 방문하셔서 보시기 바랍니다. ㅎㅎ

이것이 바로 판교에 있는 마이다스아이티 건물입니다. 밤에 보면 진짜 멋있습니다. 반짝반짝 불이 꺼지지 않는 건물...ㅎㅎㅎ

대표님 사진인데 직접 못찍어서 인터넷에서 찾아서 올리는.....ㅎㅎ

본론으로 넘어 가겠습니다.

오늘 이형우 대표님의 강연회 주제는 성공인생을 여는 패스워드 였습니다.

대표님의 첫 인상은 굉장히 선하셨습니다. 그리고 부산사투리를 쓰셔서 그런지 더 친근하게 들리더군요.

그리고, 입사하게 되면 어학연수 보내주신다고 하셨습니다. 부산으로 ㅋㅋㅋ

가장 먼저 말씀해주신 것은 대표님의 성장기를 말씀 해주셨습니다. 처음에는 대우조선에 입사하셔서 복사왕이 되시고 우연히 찾아온 기회에서 번역을 맡게 되고 기회를 놓치지 않고 열심히 한 결과 선배들에게 강의까지 하시게 되셨다고 합니다. 그러다 입사 1년만에 설계분야 프로젝트 매니저가 되셨는데 그렇게 된 게 지금 마이다스아이티 핵심프로그램의 시작이라고 합니다.

아마 여기서 저희에게 말씀하고 싶었던 것은 어떠한 상황에서도 좋은 생각(지혜)을 하라고 하신 것 같습니다. 긍정적인 마인드로 매 순간 최선을 다하면 기회는 찾아 온다는 말씀 이신 것 같습니다.

다음은 가장 중요한 인생에서 성공하는 법을 말씀해 주셨습니다.

인생성공법 - 목표 -> 계획 -> 실행

분명한 목표를 갖고 구체적인 계획을 새우며 그것을 실행하면 성공 할 수 있다고 하셨습니다.

물론, 저것을 이루기 위해선 필요한 것이 있습니다. 성공한 사람들의 공통점은

끊임없는 동기부여라고 합니다. 평범에서 비범으로 가는 길이죠.

그래서 스스로 동기부여 하는 법 3가지를 말씀해 주셨습니다.

첫째, 비전 가지기 – (실행 가능한 것) 단계적, 구체적이어야 한다.

둘째, 강점 찾기 - 장점을 활성화시켜라.

셋째, 기회 찾기 – 기회와 위기가 없다 -> 상황만 있다. 기회는 누구에게나 찾아오지만 누구에게나 보이는 것은 아니다. 준비된 자만이 볼 수 있다.

위에 세가지를 지켜 끊임없는 동기부여를 해봐야겠습니다.

다음은, 성공의 예로 일본유명인을 예를 들어 주셨습니다.

마쓰시타 고노스케(파나소닉 설립자)의 성공비결

가난 -> 경험

허약 -> 운동으로 건강

무학 -> 모든 사람을 스승으로 여겨 배운다.

인간의 가장 훌륭한 스승은 ‘시련’ 이다.

마지막으로 성공적인 인생 라이프

헌신 -> 신뢰 -> 기회 -> 재미 -> 몰입 -> 아이디어 -> 성과 ->더 큰 기회 -> 더 큰 재미 -> 더 큰 몰입 -> 더 큰 아이디어 -> 더 큰 성과

요건 기념품! ㅎㅎㅎ 카드 USB~!

저번주에 구글러 김태원씨의 강연회를 듣고 왔습니다.

가수 김태원 아닙니다...ㅋ

요분 입니다~! 

주제는 새로운관점으로 생각하라 라는 주제였습니다.

시간이 지나 다는 기억 못하지만

기억나는 얘기가 3가지가 있어서 정리하겠습니다.

1. 관점을 깨라!

우리나라 사람들은 주입식 교육에 영향일까요? 고정관념이라는 것이 심하다고 생각됩니다.

예를 들어? 무인자동차가 있습니다.

무인자동차는 어느 회사에서 만들까요?

????????

???????

자동차 회사를 생각하시지 않았나요?

답은 구글입니다.

여기에서 관점은 자동차가 아니라 무인에 있습니다.

하지만 대부분의 사람들은 이렇게 생각하죠.

상위개념 - 자동차

하위개념 - 무인자동차

이렇게 위에서 큰 범위부터 아래로 내려오면서 자신의 생각을 좁혀오면서 생각의 틀을 만들어버리죠.

자신의 지식에 갇힌 사람이 되지말고 관점을 여러관점에서 개념화 시키지 고 생각한다면

새로운 무언가를 발견 할 수 있지 않을까요?

2. 약한 유대의 강점

예를 들어, 제가 무언가 새로운 문제를 해결해야 됩니다. 하지만, 처음 접해보는 것이고 어떻게 풀어야 할지 모를 때 우리는

가장 먼저 어떻게하나요? 가장 가까운 사람들(강한 유대)에게 물어보겠죠?이 사람들은 알 까요?

강한유대를 가진 사람들은 비슷한환경, 비슷한생각을 하고 자란 사람들입니다. 아마도 비슷한 생각을 하고 있겠죠.

약한 유대는 어떨까요? 약한유대를 가진 사람들은 다른 정보를 가지고 있을 확률이 더 높지 않을까요.

바로 이것이 구현된 대표적인 예가 SNS입니다.

약한 유대의 강점이란 SNS의 강점이라고 생각 할 수도 있을 것 같습니다.

3. 인문학의 중요성과 애플

잡스 - 인문학과 기술이 만나는 접점이 애플을 만들었다.

이렇게 말했다고 합니다.

감성마케팅을 의미하는 건가 봅니다...애플의 제품들은 모두 직관적이죠.

처음 아이폰과 아이패드를 접하는 사람도 쉽게 사용할 수 있는

직관적인 제품의 중심에는 인문학적인 기술이 있었다고 생각됩니다.

우리는 물건을 살 때 리뷰 X - > 블로거 X - > 지인 추천 O

처음에 리뷰를 봅니다. 그리고 전문 블로거의 글을 보기도 하죠.

하지만, 우리가 가장 신뢰하는건 지인이 추천해주는 제품이죠.

IT전문가라면 생각해봐야 될 문제는 바로 이것입니다.

지인추천(아날로그적 신뢰) -> 이것을 어떻게 디지털화 시킬 수 있는지

아날로그적 신뢰를 디지털 신뢰로 체계화 시키고 만들 수 있다면 이보다 완벽한 시장이 있을까요?

애플을 예를 들어보겠습니다.

1. 아이폰을 출시 했습니다.

2. 고객은 만족을 합니다.

3. 고객 스스로가 지인들에게 홍보를 합니다.

4. 홍보를 원활하게 할 수 있는 아이튠즈랑 앱스토어를 만들어 사용자들끼리 공유 할 수 있게 만들었습니다. -  생태게 완성

마지막에 시장을 생성하여 애플 생테계를 완성시켰습니다.

가장 기업이 바라는 것 입니다.

고객 스스로 홍보하고 판매를 하게 만드는 생태계

애플이 어떻게 이렇게 할 수 있었나 스스로 생각을 해봐야 할 것 같습니다.

직관적이고 인문학이 묻어나는 제품과 잘 다듬어진 시장생성이 답이 아닐까 생각해봅니다..

머리가 잘 정리가 안되서 뒤죽박죽 정리해보았습니다...정말 여태 들었던 강연들중에서 생각을 많이 하게

만든 강연인 것 같습니다. 감동받았음 ㅎㅎㅎ 김태원씨가 쓴 책도 읽어봐야겠군요...그럼 이만 글 줄이겠습니다.

MyFrame

MyFrame

MyActionHandle

MyFrame

MyFrameTest

*** 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);

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

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




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

* 간단하지만 속도가 좀 느린 방법
cvGetReal2D(srcimg, i, j);             //높이가 i, 폭이 j
cvSetReal2D(srcimg, i, j, value);    //value는 설정할 값

* 약간 복잡하지만 속도가 빠른 방법 (추가)

for(h=0; h<img->height; ++h)

{

     BYTE* pData = (BYTE*)(img->imageData + h*imgData->widthStep);

     for(w=0; w<img->width; ++w)

     {

          // gray image

          BYTE valGray = pData[w];    

          // color image (BGR 순서입니다.)

          BYTE valB = pData[w*3];

          BYTE valG = pData[w*3+1];

          BYTE valR = pData[w*3+2];

     }

}




*** 이미지 불러오기, 저장하기
//불러오기
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를 저장




*** 창 만들고 닫기 등등
//생성
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 );             //그 흑백이미지를 캐니로 변환




*** 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 );  //도로 합치기




*** 창으로 부터 키 입력 받기
...
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 로 추출된 점의 개수 나온다.  추출되는 점의 개수를 입력으로 제한함과 동시에 출력도...




*** 캠 입력받기

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

// 또다른 방법 (추가)
VidFormat vidFmt = { 1600, 1200, 7.5 };     // 캠 영상의 실제 크기 및 Frame Rate
    int nSelected = cvcamGetCamerasCount();
    if( nSelected != 0 )
    {
        CRect rtWndCam;
        int nDispWidth, nDispHeight;
  CWnd* pWndCam = GetDlgItem(IDC_STATIC_CAM);
        pWndCam->GetWindowRect(&rtWndCam);
        nDispWidth = rtWndCam.Width();
        nDispHeight = rtWndCam.Height();

        cvcamSetProperty(0, CVCAM_PROP_ENABLE, CVCAMTRUE);
  cvcamSetProperty(0, CVCAM_PROP_SETFORMAT, &vidFmt); // 미리 설정된 값으로 고정
//   cvcamGetProperty(0, CVCAM_VIDEOFORMAT, NULL);  // 시작할때 선택 가능
        cvcamSetProperty(0, CVCAM_PROP_RENDER, CVCAMTRUE);
        cvcamSetProperty(0, CVCAM_PROP_WINDOW, &pWndCam->m_hWnd);
        cvcamSetProperty(0, CVCAM_RNDWIDTH, &nDispWidth);
        cvcamSetProperty(0, CVCAM_RNDHEIGHT, &nDispHeight);
        cvcamSetProperty(0, CVCAM_PROP_CALLBACK, CallBackCam);

        cvcamInit();
        cvcamStart();
    }
    else
    {
        MessageBox("카메라가 연결되어 있지 않습니다.");
    }

*** Optical Flow
voidcvCalcOpticalFlowPyrLK(
    const CvArr* prev,   // 첫 번째 이미지
    const CvArr* curr,   // 두 번째 이미지
    CvArr* prev_pyr,   // 첫 번째 이미지의 피라미드
    CvArr* curr_pyr,   // 두 번째 이미지의 피라미드
    const CvPoint2D32f* prev_features,   // 첫 번째 이미지에서 원래 점의 위치
    CvPoint2D32f* curr_features,   // 두 번째 이미지에서 찾은 점의 위치
    int count,   // 찾으려는 점의 갯수
    CvSize win_size,   // 탐색 윈도우의 크기
    int level,   // 피라미드의 레벨 지정
    char* status,  // status=1:이동된 위치를 찾은 경우, status=0:이동된 위치를 찾지 못한 경우
    float* track_error,  // NULL
    CvTermCriteria criteria,   // 종료조건
    int flags);   // CV_LKFLOW_INITIAL_GUESSES 등




*** 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;




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

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

cvEqualizeHist( Src, Equalized );




*** OpenCV 외 유용한 코드들

//파일에서 불러오기
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);

//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;
    }

}