'Programming/OpenCV'에 해당되는 글 17건

opencv 를 이용하여 이미지에 글씨를 써서 디스플레이를 하는 경우가 종종 있었다.

이 와중에 또 출력은 한글과 영어를 둘 다 써야해서 이전에 정리한 방법으로 꾸역꾸역 쓰고 있었다.

이전 방법 : [Function] IplImage 에 한글text 삽입하기 (https://jangjy.tistory.com/60 [살다보니..])

한글을 사용하려면 위 방법을 사용하는 것 말고는 방법을 찾지 못했다.

하지만 이 방식의 경우 구버전의 IplImage를 사용하면서 opencv 버전이 올라가면 점점 사용이 불가능해져

opencv 버전을 강제로 3.4.0 버전을 사용하게 만든 주범이었다.

반대로 putText를 사용하면 폰트 변경은 가능하나 한글 출력이 불가능했고..

DC에 draw 하는 방식 또한 맘에 들지 않았다..

그러다 freetype 이라는 녀석을 이용하여 출력이 가능함을 알고 이와 관련한 내용을 정리.

대부분의 내용은 황선규님의 블로그에 정리된 내용을 참고하였다. (kkokkal.tistory.com/1325)

주요 내용을 정리하자면

• opencv3.2 부터 freetype 모듈을 contrib 프로젝트를 통해 지원했다는것
• 이를 위해서는 freetype과 harfbuzz 라이브러리를 미리 컴파일 한 후 opencv에서 포함하여 재빌드 해야한다는 것. 

이 두가지가 주요 골자였다. 추후 재사용을 위해 주요 내용을 메모..

1. freetype 라이브러리 빌드.

freetype 은 폰트 렌더링 라이브러리 라고 한다. 이런 라이브러리도 오늘 처음 알았다..

https://download.savannah.gnu.org/releases/freetype/

여기서 다운로드 받은 후 빌드. 

다만 이때 WITH_ZLIB, WITH_BZip2, WITH_PNG 옵션을 Off로 설정하지 않으면 opencv 빌드 단계에서 에러가 발생한다고 한다.

CMake-GUI 로 열었더니 해당 항목이 안보여서 원글에서 사용한대로 명령어를 사용하여 generate 했다.

cmake -DWITH_ZLIB=OFF -DWITH_BZip2=OFF -DWITH_PNG=OFF -G "Visual Studio 14 2015 Win64" [source root path]

INSTALL 빌드 시 C:\Program Files\freetype 에 파일이 복사되므로 generate 된 솔루션은 관리자 권환으로 실행 후 ALL_BUILD와 INSTALL 을 모두 빌드 해준다.

이후 환경변수에 이름은 FREETYPE_DIR, 값은 C:\Program Files\freetype 로 추가

2. Harfbuzz 라이브러리 빌드

이녀석은 오픈타입 텍스트 쉐이핑 엔진이라 한다.. 마찬가지로 다운로드 후 빌드..

https://www.freedesktop.org/software/harfbuzz/release/

이녀석은 CMake-GUI 를 통해 만들었고 HB_HAVE_FREETYPE 옵션만 체크하고 나머지는 기본값으로.

마찬가지로 관리자 권한으로 실행 후 ALL_BUILD와 INSTALL 을 모두 빌드.

INSTALL 결과는 C:\Program Files(x86)\harfbuzz 에 복사되었다.

이후 환경변수 이름은 HARFBUZZ_DIR, 값은 C:\Program Files(x86)\harfbuzz 로 추가

3. opencv 빌드.

opencv / opencv-contrib 를 모두 다운로드 받고 압축 해제

generate 하기 전에 contrib의 모듈 중 freetype 모듈의 CMakeList.txt 파일을 수정.

수정 방법은  https://gist.github.com/UnaNancyOwen/14c72a3f10a46d41c359ab6ea307a1d2 를 참고하여 수정 했다고 했는데 다운로드 받은 opencv 버전에 따라 코드가 조금 다를 수는 있을 것 같다. 

나같은 경우도 코드 구조가 약간 달라 맞춰서 수정할까 하다가 황선규님께서 수정하신 내용을 그대로 사

용했다.

EXTRA MODULE PATH 에 contrib\module 경로 추가 해주고.. BUILD_opencv_freetype 체크하고,

BUILD_opencv_world 체크.

generate 후 솔루션은 마찬가지로 ALL_BUILD와 INSTALL 을 모두 빌드

이후 기존의 opencv 와 마찬가지로 include lib 경로 잡고 사용하면 된다.

4. freetype 사용법

#include "opencv2/opencv.hpp"
// freetype 헤더를 추가로 include
#include "opencv2/freetype.hpp"
 
using namespace cv;
// namespace도 추가해주기
using namespace cv::freetype;
using namespace std;


// FreeType2 객체 선언
Ptr<Freetype2> ft2; 

// FreeType2 객체 초기화
ft2 = createFreeType2();

// ft2객체 폰트 불러오기 
// 참고 코드에서는 바탕체를 사용했는데 이상하게 정상 동작하지 않았음.
// 원하는 폰트 동작여부 확인하고 사용하자
ft2->loadFontData("c:\\windows\\fonts\\HMFMMUEX.TTC", 0);

// 문자 출력 방법.
// 한글을 사용할때는 u8을 앞에 써서 utf-8 인코딩을 명시해줘야한다.
// 변수에 담긴 한글은 어떻게 처리하는지 조금 더 찾아보고 수정 예정.
ft2->putText(tImg, "한글변환테스트", Point(1300, 400), 20, Scalar(0, 100, 255), -1, LINE_AA, false);
ft2->putText(tImg, u8"u8 한글테스트", Point(1300, 500), 20, Scalar(0, 100, 255), -1, LINE_AA, false);
string st = "English test";
ft2->putText(tImg, st, Point(1300, 600), 20, Scalar(0, 100, 255), -1, LINE_AA, false);

> 출력결과

인코딩 명시하지 않으면 한글은 출력이 제대로 되지 않았다.

또한 변수에 담긴 한글은 어떻게 처리하는지 아직 확인하지 못함..

(원문 댓글에 값을 바로 넣는것은 확인 되나 포맷팅을 사용할 경우 어떻게 쓰는지 테스트 필요. 이는 확인 후 수정 예정.)

21.05.06. 수정.  link : jangjy.tistory.com/400

CW2A 기능을 이용하여 간단하게 사용 가능.

한글도 잘 출력 되는것을 확인.

OpenCV에서 제공하는 기능 중 FileStorage라는 놈을 이용하여 xml을 읽고 쓰기가 가능하다.

대부분의 기능은 iostream과 유사한 형태로 사용 가능해서 바로 쓸 수 있지만 두가지 기능은 알아야 한다.

1. Sequence Collection ( "[", "]" )

이 놈은 데이터를 리스트 형태로 관리해 주는 놈으로써 [ ] 를 이용하여 출력한다.

2. Mapping Collection ( "{", "}" )

이 놈은 계층을 관리 해 주는 놈으로써 { } 를 이용하여 출력한다. 

이 두 기능도 직관적이라 사용이 어렵진 않다. 

샘플 코드

FileStorage fs("_sample.xml", FileStorage::WRITE);
time_t date;
time(&date);

fs << "Date" << asctime(localtime(&date));
fs << "ID" << "USER ID";
fs << "Originfilelist" << "[";
fs << "F:/test_video/kinect1/originvideo.mkv";
fs << "F:/test_video/kinect2/originvideo.mkv";
fs << "F:/test_video/kinect3/originvideo.mkv";
fs << "]";

fs << "Sample" << "{";
fs << "Sourcefile" << "F:/test_video/kinect1/originvideo.mkv";
fs << "Filename" << "2_1-r.mkv";
fs << "FilePath" << "F:/test_video/parsing/kinect1/2_1-r.mkv";
fs << "OriginTime" << "00:33:39-00:33:46";
fs << "Memo" << " ";
fs << "Function" << "{";
fs << "Name" << "Function1";
fs << "score" << "N" << "}";
fs << "Function" << "{";
fs << "Name" << "Function2";
fs << "score" << "N";
fs << "}";
fs << "}";

xml 결과

<?xml version="1.0"?>
<opencv_storage>
<Date>"Wed Oct  7 10:01:54 2020&#x0a;"</Date>
<ID>"USER ID"</ID>
<Originfilelist>
  F:/test_video/kinect1/originvideo.mkv
  F:/test_video/kinect2/originvideo.mkv
  F:/test_video/kinect3/originvideo.mkv</Originfilelist>
<Sample>
  <Sourcefile>F:/test_video/kinect1/originvideo.mkv</Sourcefile>
  <Filename>"2_1-r.mkv"</Filename>
  <FilePath>F:/test_video/parsing/kinect1/2_1-r.mkv</FilePath>
  <OriginTime>"00:33:39-00:33:46"</OriginTime>
  <Memo>" "</Memo>
  <Function>
    <Name>Function1</Name>
    <score>N</score></Function>
  <Function>
    <Name>Function2</Name>
    <score>N</score></Function></Sample>
</opencv_storage>

(20.11.26. 수정) 위 샘플은 xml 작성규칙에 맞지 않음.

동일 이름의 노드 생성은 규칙에 어긋나기 때문에 위와 같이 생성은 되지만

filestorage를 이용하여 다시 읽을때 문제가 발생한다.

동일이름의 노드 생성은 하지 않도록 하자.

일반적으로 OpenCV를 이용하여 영상을 읽을 때 imread 나 cvLoadImage를 이용하여 읽어온다.

직접 읽어 올 경우는 내부적으로 다 처리를 해 주겠지만 jpeg 같은 decoding 되지 않은 파일을 포인터로 받아서

사용하고자 할 때는 decoding 작업이 필요하게 된다.

이 또한 OpenCV에서 제공하니 가져다 쓰기만 하면 되지..

다음에 기억 안날거 같으니까 적어둬야지..

1. int nBufferLength;
2. unsigned char pBuffer;
3.  
4. Mat EncodedData = Mat(1, nBufferLength, pBuffer);
5. Mat DecodedImage = imdecode(EncodedData, 1);

imdecode 가 이 글의 핵심 부분이고 알아서 디코딩 작업을 처리 해 주는듯.

두번째 파라미터는 imread 의 flag와 동일한 파라미터.

프로그램에서 영상 데이터를 unsigned char* 형의 버퍼로 가지고 이용하는 경우가 종종 있다.

이 데이터 형을 IplImage 형으로 변환하려면 아래와 같은 방법으로 변환 가능하다.

unsigned char *buffer= ...;

IplImage *img = cvCreateImage(cvSize(w,h),8,channels);
cvSetData( img , buffer , w*channels);

Mat 형식으로 변환하기 위해서는 

Mat temp = Mat( H, W, CV_8UC1 );

temp.data = buffer;

와 같은 형태로 변환 가능.

OpenCV에 포함되어 있는 기본적인 HOG 특징을 뽑아주는 함수이다.

기본 사람검출을 위한 파라미터를 이용해서 간단한 테스트만 해봤다.

나중에 이걸 쓸일이 있을지는 모르겠지만 일단 저장..

아마 다음에 hog를 쓴다면 아마 구현해서 쓰겠지... 

1. Mat img;
2.  
3. img = imread( "C:\\Users\\Administrator\\Pictures\\test.jpg" );
4.  
5. HOGDescriptor hog;
6. hog.setSVMDetector( HOGDescriptor::getDefaultPeopleDetector() );
7. vector<Rect> detected;
8.  
9. double time = double( GetTickCount() );
10.  
11. hog.detectMultiScale( img, detected, 0, Size(9,9), Size(26,20), 1.05, 2 );
12. time = double( GetTickCount() ) - time;
13.  
14. int detectedCNT = detected.size();
15.  
16. for( int i=0; i<detectedCNT; i++ )
17. {
18.         Rect people = detected[i];
19.         rectangle( img, people, Scalar(0,0,255), 2 );
20. }
21.  
22. imshow( "Result", img )

그래도 별다른 작업없이 기본 파라미터만 이용해서 

사검출 결과가 나오니 간단한 테스트용으로는 사용 할 만 하겠지?

아래사진은 작년 경주에서 찍은 사진.. 옆에 형은 초상권.. 으로인한 모자이크 처리 해드립니다.

성능은 뭐 예상대로 별로다. 어거지로 끼워 맞춘 느낌.. 

아래는 외국사이트에서 본 hog feature 시각화해서 보여주는 소스란다.

아직 확인은 안해봤지만 나중에 참고하도록 하자.

// HOGDescriptor visual_imagealizer
// adapted for arbitrary size of feature sets and training images
Mat get_hogdescriptor_visual_image(Mat& origImg,
                                   vector<float>& descriptorValues,
                                   Size winSize,
                                   Size cellSize,                                   
                                   int scaleFactor,
                                   double viz_factor)
{   
    Mat visual_image;
    resize(origImg, visual_image, Size(origImg.cols*scaleFactor, origImg.rows*scaleFactor));
 
    int gradientBinSize = 9;
    // dividing 180° into 9 bins, how large (in rad) is one bin?
    float radRangeForOneBin = 3.14/(float)gradientBinSize; 
 
    // prepare data structure: 9 orientation / gradient strenghts for each cell
	int cells_in_x_dir = winSize.width / cellSize.width;
    int cells_in_y_dir = winSize.height / cellSize.height;
    int totalnrofcells = cells_in_x_dir * cells_in_y_dir;
    float*** gradientStrengths = new float**[cells_in_y_dir];
    int** cellUpdateCounter   = new int*[cells_in_y_dir];
    for (int y=0; y<cells_in_y_dir; y++)
    {
        gradientStrengths[y] = new float*[cells_in_x_dir];
        cellUpdateCounter[y] = new int[cells_in_x_dir];
        for (int x=0; x<cells_in_x_dir; x++)
        {
            gradientStrengths[y][x] = new float[gradientBinSize];
            cellUpdateCounter[y][x] = 0;
 
            for (int bin=0; bin<gradientBinSize; bin++)
                gradientStrengths[y][x][bin] = 0.0;
        }
    }
 
    // nr of blocks = nr of cells - 1
    // since there is a new block on each cell (overlapping blocks!) but the last one
    int blocks_in_x_dir = cells_in_x_dir - 1;
    int blocks_in_y_dir = cells_in_y_dir - 1;
 
    // compute gradient strengths per cell
    int descriptorDataIdx = 0;
    int cellx = 0;
    int celly = 0;
 
    for (int blockx=0; blockx<blocks_in_x_dir; blockx++)
    {
        for (int blocky=0; blocky<blocks_in_y_dir; blocky++)            
        {
            // 4 cells per block ...
            for (int cellNr=0; cellNr<4; cellNr++)
            {
                // compute corresponding cell nr
                int cellx = blockx;
                int celly = blocky;
                if (cellNr==1) celly++;
                if (cellNr==2) cellx++;
                if (cellNr==3)
                {
                    cellx++;
                    celly++;
                }
 
                for (int bin=0; bin<gradientBinSize; bin++)
                {
                    float gradientStrength = descriptorValues[ descriptorDataIdx ];
                    descriptorDataIdx++;
 
                    gradientStrengths[celly][cellx][bin] += gradientStrength;
 
                } // for (all bins)
 
 
                // note: overlapping blocks lead to multiple updates of this sum!
                // we therefore keep track how often a cell was updated,
                // to compute average gradient strengths
                cellUpdateCounter[celly][cellx]++;
 
            } // for (all cells)
 
 
        } // for (all block x pos)
    } // for (all block y pos)
 
 
    // compute average gradient strengths
    for (int celly=0; celly<cells_in_y_dir; celly++)
    {
        for (int cellx=0; cellx<cells_in_x_dir; cellx++)
        {
 
            float NrUpdatesForThisCell = (float)cellUpdateCounter[celly][cellx];
 
            // compute average gradient strenghts for each gradient bin direction
            for (int bin=0; bin<gradientBinSize; bin++)
            {
                gradientStrengths[celly][cellx][bin] /= NrUpdatesForThisCell;
            }
        }
    }
 
 
    cout << "descriptorDataIdx = " << descriptorDataIdx << endl;
 
    // draw cells
    for (int celly=0; celly<cells_in_y_dir; celly++)
    {
        for (int cellx=0; cellx<cells_in_x_dir; cellx++)
        {
            int drawX = cellx * cellSize.width;
            int drawY = celly * cellSize.height;
 
            int mx = drawX + cellSize.width/2;
            int my = drawY + cellSize.height/2;
 
            rectangle(visual_image,
                      Point(drawX*scaleFactor,drawY*scaleFactor),
                      Point((drawX+cellSize.width)*scaleFactor,
                      (drawY+cellSize.height)*scaleFactor),
                      CV_RGB(100,100,100),
                      1);
 
            // draw in each cell all 9 gradient strengths
            for (int bin=0; bin<gradientBinSize; bin++)
            {
                float currentGradStrength = gradientStrengths[celly][cellx][bin];
 
                // no line to draw?
                if (currentGradStrength==0)
                    continue;
 
                float currRad = bin * radRangeForOneBin + radRangeForOneBin/2;
 
                float dirVecX = cos( currRad );
                float dirVecY = sin( currRad );
                float maxVecLen = cellSize.width/2;
                float scale = viz_factor; // just a visual_imagealization scale,
                                          // to see the lines better
 
                // compute line coordinates
                float x1 = mx - dirVecX * currentGradStrength * maxVecLen * scale;
                float y1 = my - dirVecY * currentGradStrength * maxVecLen * scale;
                float x2 = mx + dirVecX * currentGradStrength * maxVecLen * scale;
                float y2 = my + dirVecY * currentGradStrength * maxVecLen * scale;
 
                // draw gradient visual_imagealization
                line(visual_image,
                     Point(x1*scaleFactor,y1*scaleFactor),
                     Point(x2*scaleFactor,y2*scaleFactor),
                     CV_RGB(0,0,255),
                     1);
 
            } // for (all bins)
 
        } // for (cellx)
    } // for (celly)
 
 
    // don't forget to free memory allocated by helper data structures!
    for (int y=0; y<cells_in_y_dir; y++)
    {
      for (int x=0; x<cells_in_x_dir; x++)
      {
           delete[] gradientStrengths[y][x];            
      }
      delete[] gradientStrengths[y];
      delete[] cellUpdateCounter[y];
    }
    delete[] gradientStrengths;
    delete[] cellUpdateCounter;
 
    return visual_image;
 
}

영상 처리를 하다보면 영상 회전이 필요할 경우가 많다. 

opencv의 워프어파인 변환 함수를 이용하여 영상을 회전하는 방법이다.

특수각일경우에 대한 추가 처리를 해주면 연산 속도는 조금 더 빨라진다.

이방법이 좋은 방법은 아니지만 간단하게 회전 영상을 구할때 사용하면 괜찮다.

1. Mat RotateImage(Mat img, int angle, double x, double y)
2. {
3.         // 영상 중심기준 회전
4.         //CvPoint2D32f center = cvPoint2D32f(img.cols/2, img.rows/2);
5.        
6.         // 사용자 지정위치 (x,y) 기준 회전
7.         CvPoint2D32f center = cvPoint2D32f(x, y);
8.         CvMat* rotation = cvCreateMat(2, 3 , CV_32FC1);
9.         cv2DRotationMatrix(center, double(angle), 1.0, rotation);
10.  
11.         cvWarpAffine(&IplImage(img), &IplImage(img), rotation);
12.  
13.         cvReleaseMat(&rotation);
14.  
15.         return img;
16. }

//========= header 에 추가 =========================

void setPutText( IplImage* src_image, IplImage* dst_image, char* text, CvPoint textPos, CvScalar color);

HBITMAP setTextToBitmap( char* text, CvScalar color);

IplImage* setBitmapToIplImage( HBITMAP hBitmap );

//========== 소스코드 ===============================

void CbrailleDlg::setPutText(IplImage* src_image, IplImage* dst_image, char* text, CvPoint textPos, CvScalar color)

{

// 명암도 영상에 대한 처리는 안함 칼라만 처리 일단..

if( src_image->nChannels != 1 )

cvCopy( src_image, dst_image );

int width = src_image->width;

int height = src_image->height;

if( (textPos.y > src_image->height) || (textPos.x > src_image->width) )

{

cvCopy( src_image, dst_image );

}

CvScalar var = {0,0,0,0};

HBITMAP hBitmap = setTextToBitmap(text, color);

IplImage* text_image = setBitmapToIplImage( hBitmap );

for( int nRow = textPos.y; nRow<(textPos.y + text_image->height); nRow++)

{

for( int nCol = textPos.x; nCol<(textPos.x + text_image->width); nCol++)

{

if( nRow >= height || nCol >= width) continue;

var = cvGet2D(text_image, nRow-textPos.y, nCol-textPos.x);

if( var.val[0] == color.val[0] && var.val[1] == color.val[1] && var.val[2] == color.val[2] )

cvSet2D(dst_image, nRow, nCol, var);

}

}

free(text_image->imageData);

cvReleaseImage( &text_image );

DeleteObject( hBitmap );

}

HBITMAP CbrailleDlg::setTextToBitmap( char* text, CvScalar color)

{

int textLength = (int)strlen(text);

if( textLength <= 0 ) return NULL;

HDC hTextDC = CreateCompatibleDC(NULL);

HFONT hOldFont = (HFONT)SelectObject( hTextDC, (HFONT)GetStockObject(SYSTEM_FONT) );

HBITMAP hDstBMP = NULL;

RECT textArea = {0, 0, 0, 0};

DrawText(hTextDC, (LPCTSTR)text, textLength, &textArea, DT_CALCRECT);

if( (textArea.right > textArea.left) && (textArea.bottom > textArea.top) )

{

BITMAPINFOHEADER bitmapInfoHeader;

memset( &bitmapInfoHeader, 0x0, sizeof(BITMAPINFOHEADER) );

void* lpvBits = NULL;

bitmapInfoHeader.biSize = sizeof(bitmapInfoHeader);

bitmapInfoHeader.biWidth = textArea.right-textArea.left;

bitmapInfoHeader.biHeight = textArea.bottom-textArea.top;

bitmapInfoHeader.biPlanes = 1;

bitmapInfoHeader.biBitCount = 32;

bitmapInfoHeader.biCompression = BI_RGB;

hDstBMP = CreateDIBSection( hTextDC, (LPBITMAPINFO)&bitmapInfoHeader, 0, (LPVOID*)&lpvBits, NULL, 0 );

HBITMAP hOldBMP = (HBITMAP)SelectObject( hTextDC, hDstBMP );

if( hOldBMP != NULL)

{

int TEXT_RED = (int)color.val[2];

int TEXT_GREEN = (int)color.val[1];

int TEXT_BLUE = (int)color.val[0];

SetTextColor( hTextDC, RGB(TEXT_RED, TEXT_GREEN, TEXT_BLUE) ); //text color

SetBkColor( hTextDC, 0x00EFFEFF ); //Background color

SetBkMode( hTextDC, OPAQUE ); // 투명

DrawText( hTextDC, (LPCTSTR)text, textLength, &textArea, DT_NOCLIP);

}

::SelectObject( hTextDC, hOldBMP );

}

::SelectObject( hTextDC, hOldFont );

if( hTextDC) { ::DeleteDC( hTextDC ); }

if( hOldFont) { ::DeleteObject( hOldFont ); }

return hDstBMP;

}

IplImage* CbrailleDlg::setBitmapToIplImage( HBITMAP hBitmap )

{

BITMAP bitmap;

GetObject( hBitmap, sizeof( BITMAP ), (LPSTR)&bitmap );

int nChannels = (bitmap.bmBitsPixel == 1)? 1: bitmap.bmBitsPixel*0.125;

int depth = (bitmap.bmBitsPixel == 1)? IPL_DEPTH_1U : IPL_DEPTH_8U;

IplImage* mImage = cvCreateImageHeader( cvSize(bitmap.bmWidth, bitmap.bmHeight), depth, nChannels );

mImage->imageData = (char*)malloc(bitmap.bmHeight * bitmap.bmWidth * nChannels * sizeof(char) );

memcpy(mImage->imageData, (char*)(bitmap.bmBits), bitmap.bmHeight * bitmap.bmWidth * nChannels );

cvFlip( mImage, mImage, 0 );

return mImage;

}

//================사용 예 ==========================

CString str;

str.Format( _T("한글") );

setPutText( &IplImage(m_Image), &IplImage(m_Image), (LPSTR)(LPCTSTR)str, cvPoint(10,10), CV_RGB(255,255,100) ); 

화면에 무언갈 띄운다던가. 선을그리고 텍스트를 그리고

사각형을 그리고 원을그리고 이미지를 올리고 뭐 등등 이러한 여러가지 작업들을

DC 에 벌려 놓은 다음 그 DC를 파일로 저장 한다거나 IplImage로 혹은 cv::Mat 으로 

가져와서 다른 작업을 하고싶다거나.. 할때 변환을 해주는 함수.

해당 DC의 CDC 를 파라미터로 넘겨주면 해당 DC를 IplImage로 반환 해준다.

이렇게 사각형 박스안에 그림을 그리고 나서 

DCtoIplImage 함수를 불러주면 

뿅 하고 IplImage를 반환 해준다.

이를 확인하기 위해 NamedWindow를 통해 화면에 나타낸 것.

이런 작업을 위한 함수.

IplImage* CtestDlg::DCtoIplImage(CDC* pDC)

{

CRect rect;

    pDC->GetWindow()->GetClientRect(rect);

    int cx = rect.right - rect.left;

    int cy = rect.bottom - rect.top;

    if(cx <= 0 || cy <= 0) return NULL;

    HDC hMemDC;

    hMemDC = CreateCompatibleDC(pDC->m_hDC);

    BITMAPINFO    bmi;

    BITMAPINFOHEADER* bmih = &(bmi.bmiHeader);

    LPVOID        pBits;

    HBITMAP        hBitmap;

    ZeroMemory(bmih, sizeof(BITMAPINFOHEADER));

    bmih->biSize        = sizeof(BITMAPINFOHEADER);

    bmih->biBitCount    = 24;

    bmih->biWidth        = cx;

    bmih->biHeight        = cy;

    bmih->biPlanes        = 1;

    hBitmap = CreateDIBSection(pDC->m_hDC, &bmi, DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);

    SelectObject(hMemDC, hBitmap);

    BitBlt(hMemDC, 0, 0, cx, cy, pDC->m_hDC, rect.left, rect.top, SRCCOPY);

    DeleteDC(hMemDC);

    hMemDC = NULL;

    bool bMustRelease = false;

    const int nDepth = IPL_DEPTH_8U;

    const int nChannels = 3;

    if(hMemDC == NULL)

    {

        hMemDC = ::GetDC(NULL);

        bMustRelease = true;

    }

    IplImage* img = NULL;

    if(GetDIBits(hMemDC, hBitmap, 0, 0, NULL, &bmi, DIB_RGB_COLORS))

    {

        int nHeight = (bmih->biHeight > 0) ? bmih->biHeight : -bmih->biHeight;

        img = cvCreateImage(cvSize(bmih->biWidth, nHeight), nDepth, nChannels);

        img->origin = (bmih->biHeight > 0);

        bmih->biBitCount = (WORD)(img->nChannels * 8);

        bmih->biCompression = BI_RGB;

        GetDIBits(hMemDC, hBitmap, 0, nHeight, img->imageData, &bmi, DIB_RGB_COLORS);

    }

    if(bMustRelease) ::ReleaseDC(NULL, hMemDC);

    DeleteObject(hBitmap);

    return img;

}

아래 내용은 다크pgmr ( http://darkpgmr.tistory.com/46 ) 님의 블로그에서 복사한 내용입니다.

내용에 내가 필요료 하는 것들 추가로 기록할 예정입니다.

====================================================================================

using namespace cv;

1. 이미지 읽기 & 저장

Mat img_color = imread("sample.jpg"); // color load

Mat img_gray = imread("sample.jpg", 0);// gray load

imwrite("fname.jpg", img);

2. 이미지 생성, 복사, 형변환, 색상변환, roi 설정

int w = 320;// width

int h = 240;// height

// 생성

Mat img(h,w,CV_8UC1);                    //1채널 unsigned char

Mat img(h,w,CV_8UC3);                    //3채널 unsigned char

Mat img = Mat::zeros(h,w,CV_32FC1);//1채널 float

Mat img = Mat::ones(h,w,CV_64FC3);//3채널 double

unsigned char * img_buffer;            // 이미지버퍼 포인터

Mat img(h, w, CV_8UC3, img_buffer);//메모리 공유

// 원소 초기화

Mat img(h,w,CV_8UC1);

img = Scalar(3);                 // img 모든 원소값 3으로 초기화

// 참조, 복사

Mat img2 = img;                 // 메모리 공유

Mat img2 = img.clone(); // 별도 메모리

Mat img2; img.copyTo(img2);//별도 메모리

// 형변환 복사

Mat img1(h,w,CV_32FC1);

Mat img2;

img1.convertTo(img2, CV_8U);

// gray-color 변환

cvtColor(color, gray, CV_BGR2GRAY);

cvtColor(gray, color, CV_GRAY2BGR);

// roi 설정

Rect roi;

Mat sub_img = img(roi);                //메모리공유

Mat sub_img = img(roi).clone();    //별도메모리

3. 영상 크기변경 및 상하좌우 반전

// 크기 변경

Mat dst;

resize(img, dst, Size(new_w,new_h));

resize(img, dst, Size(), 0.5, 0.5);    //scalex, scaley

// 영상 반전(flip)

flip(img, dst, 0);        // vertical flip

flip(img, dst, 1);        // horizontal flip

flip(img, dst, -1);       // vertial & horizontal flip

4. 이미지에 그리기 (drawing)

Rect rc(x,y,w,h);

Scalar color(B,G,R);

int thickness=1;         // line thickness

line(img, Point(x1,y1), Point(x2,y2), color, thickness);

rectangle(img, rc, color, thickness);

rectangle(img, rc.tl(), rc.br(), color, thickness);

rectangle(img, rc, color, CV_FILLED); // filled rectangle

Point center(rc.x+rc.width/2, rc.y+rc.height/2);

Size radius(rc.width/2, rc.height/2);

double rot_deg = 0;     // rotation of ellipse

double s_deg = 0;     // start angle of arc

double e_deg = 360;     // end angle of arc

ellipse(img,center,radius,rot_deg,s_deg,e_deg,color,thickness);

ellipse(img,center,radius,rot_deg,s_deg,e_deg,color,CV_FILLED);

int circle_radius = 10;

circle(img, center, circle_radius, color, thickness);

circle(img, center, circle_radius, color, CV_FILLED);

putText(img, "text", Point(x,y), FONT_HERSHEY_SIMPLEX, 1., color, thickness);

putText(img, "text", Point(x,y), FONT_HERSHEY_DUPLEX, 1., color, thickness);

5. 이미지 디스플레이하기 (display)

namedWindow("name");                                 // auto resized

namedWindow("name",CV_WINDOW_NORMAL); // manual resize

imshow("name", img);

char ch = waitKey();     // 무한 대기

char ch = waitKey(10);    // 10 msec 대기

if(ch == 27) ...             // ESC key

if(ch == 32) ...             // SPACE key

destroyWindow("name");

destroyAllWindows();

6. 웹캠 연결하기

VideoCapture vc(0);

if (!vc.isOpened()) return; // 연결실패

vc.set(CV_CAP_PROP_FRAME_WIDTH, 640);

vc.set(CV_CAP_PROP_FRAME_HEIGHT, 480);

Mat img;

while(1){

vc >> img;

if(img.empty()) break;

imshow("cam",img);

if(waitKey(10)==27) break; //ESC

}

destroyAllWindows();

7. avi 비디오 파일 읽어오기

VideoCapture vc("sample.avi");

if (!vc.isOpened()) return; // 불러오기 실패

Mat img;

while(1){

vc >> img;

if(img.emplty()) break;

imshow("video",img);

if(waitKey(10)==27) break; //ESC

}

destroyAllWindows();

8. avi 비디오 녹화하기

double fps = 15;

int fourcc = CV_FOURCC('X','V','I','D'); // codec

bool isColor = true;

VideoWriter *video = new VideoWriter;

if(!video->open("result.avi", fourcc, fps, Size(img_w, img_h), isColor)){

delete video;

return;

}

Mat img;

while(1){

// ...

*video << img;

// ...

}

delete video;

9. Mat <--> IplImage

Mat --> IplImage

Mat matimg;

IplImage* iplimh;

iplimg = &IplImage(matimg);

IplImage --> Mat

IplImage* iplimg;

Mat matimg;

matimg(iplimg);

OpenCV에서 주로 사용하는 함수들

자주 쓰는 함수가 잘 정리되어있는것 같아서 

나중에 필요할때 찾아보려 저장.

  IplImage* cam_image =  캠에서 입력받은 영상이나 뭐든 여튼 이미지

  IplImage* output = cvCreateImage(cvGetSize(cam_image), 8, 1);     //edge출력을위한 1채널 영상

IplImage* gray = cvCreateImage(cvGetSize(cam_image), 8, 1);         //edge검출을위한 1채널 영상

        IplImage* color_output = cvCreateImage(cvGetSize(cam_image), 8, 3); //hough 출력을위한 3채널 영상

CvMemStorage* storage = cvCreateMemStorage(0);

CvSeq* lines = 0;

cvCvtColor(cam_image, gray,CV_RGB2GRAY);

cvCanny(gray, output, 50,200, 3);

cvCvtColor(output, color_output, CV_GRAY2RGB);

//CV_HOUGH_PROBABILISTIC MODE

lines = cvHoughLines2(output, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 50, 30, 3);

for(int i=0; i<lines->total; i++)

{

CvPoint* line = (CvPoint*)cvGetSeqElem(lines, i);

cvLine(color_output, line[0], line[1], CV_RGB(255, 0, 0), 2, 8);

}

cvNamedWindow("Hough");

cvShowImage("Hough", color_output);

cvReleaseImage(&output);

cvReleaseImage(&gray);

cvReleaseImage(&color_output);

========================================================================================================================

cvHoughLines2 함수 파라미터에 대한 설명이다

cvNamedWindow("test");

CvCapture* capture = cvCreateFileCapture("test.avi");

IplImage* frame;

char c;

while(1)

{

cvGrabFrame(capture);

frame = cvRetrieveFrame(capture);

if(!frame) break;

cvShowImage("test", frame);

c = cvWaitKey(33);

if( c == 27) break;

}

cvReleaseCapture(&capture);

cvDestroyAllWindows();

=================================================================

가장 기본적인 동영상 재생 함수.

추가적으로 영상의 전체 프레임 수를 얻고싶으면 

int TotalFrame= (int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_COUNT);

위 함수를 이용하여 구할 수 있다.