virtual studio 구현: gradient filtering

일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

2010. 4. 4. 17:33 Computer Vision

패턴 격자 무늬의 꼭지점 찾기

ref. swPark_2000rti.pdf

2010/04/04 - [Visual Information Processing Lab] - OpenCV: cvFilter2D() 연습 코드
2010/04/03 - [Visual Information Processing Lab] - Image Filtering

1) 1차 DoG filter 만들기: x방향과 y방향의 local maxima를 찾는다.

swPark_2000rti.pdf 440쪽:
"To find the edge of the grid, a first-order Derivative of Gaussian (DoG) filter with a kernel h = [-1, -7, -15, 0, 15, 7, 1] is used."

1차 DoG 필터 테스트:

입력 영상

흑백 영상

수평 방향 1차 DoG 필터링한 영상

수직 방향 1차 DoG 필터링한 영상

2) 다음 이미지에서 보다 확실히 나타나는, 2가지 문제를 해결해야 함

입력 영상

흑백 영상

x방향 DoG 필터링한 영상

y방향 DoG 필터링한 영상

(1) 패턴 격자에서 흑->백으로 넘어갈 때에만 edge 검출 (백->흑인 경우에는 무효)
(2) 검출된 edge 영역이 너무 두터움 (Non-Maxima Suppression을 해 주어야 한다고 함)

필터링 함수가 실제로 어떻게 이미지에 (색상/세기)값을 넣는지 볼 수 있을까 하여 cvFilter() 함수의 정의를 찾아 보니, 다음 부분이 나옴.

opencv/opencv/src/cv/cvfilter.cpp

CV_IMPL void
cvFilter2D( const CvArr* srcarr, CvArr* dstarr, const CvMat* _kernel, CvPoint anchor )
{
    cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
    cv::Mat kernel = cv::cvarrToMat(_kernel);

    CV_Assert( src.size() == dst.size() && src.channels() == dst.channels() );

    cv::filter2D( src, dst, dst.depth(), kernel, anchor, 0, cv::BORDER_REPLICATE );
}

본론인 "cv::filter2D"에 대하여 같은 파일 안에 다음의 정의가 있음.

template<typename ST, class CastOp, class VecOp> struct Filter2D : public BaseFilter
{
    typedef typename CastOp::type1 KT;
    typedef typename CastOp::rtype DT;

    Filter2D( const Mat& _kernel, Point _anchor,
        double _delta, const CastOp& _castOp=CastOp(),
        const VecOp& _vecOp=VecOp() )
    {
        anchor = _anchor;
        ksize = _kernel.size();
        delta = saturate_cast<KT>(_delta);
        castOp0 = _castOp;
        vecOp = _vecOp;
        CV_Assert( _kernel.type() == DataType<KT>::type );
        preprocess2DKernel( _kernel, coords, coeffs );
        ptrs.resize( coords.size() );
    }

    void operator()(const uchar** src, uchar* dst, int dststep, int count, int width, int cn)
    {
        KT _delta = delta;
        const Point* pt = &coords[0];
        const KT* kf = (const KT*)&coeffs[0];
        const ST** kp = (const ST**)&ptrs[0];
        int i, k, nz = (int)coords.size();
        CastOp castOp = castOp0;

        width *= cn;
        for( ; count > 0; count--, dst += dststep, src++ )
        {
            DT* D = (DT*)dst;

            for( k = 0; k < nz; k++ )
                kp[k] = (const ST*)src[pt[k].y] + pt[k].x*cn;

            i = vecOp((const uchar**)kp, dst, width);

            for( ; i <= width - 4; i += 4 )
            {
                KT s0 = _delta, s1 = _delta, s2 = _delta, s3 = _delta;

                for( k = 0; k < nz; k++ )
                {
                    const ST* sptr = kp[k] + i;
                    KT f = kf[k];
                    s0 += f*sptr[0];
                    s1 += f*sptr[1];
                    s2 += f*sptr[2];
                    s3 += f*sptr[3];
                }

                D[i] = castOp(s0); D[i+1] = castOp(s1);
                D[i+2] = castOp(s2); D[i+3] = castOp(s3);
            }

            for( ; i < width; i++ )
            {
                KT s0 = _delta;
                for( k = 0; k < nz; k++ )
                    s0 += kf[k]*kp[k][i];
                D[i] = castOp(s0);
            }
        }
    }

    Vector<Point> coords;
    Vector<uchar> coeffs;
    Vector<uchar*> ptrs;
    KT delta;
    CastOp castOp0;
    VecOp vecOp;
};

Try #1.
-1) 필터링의 결과 이미지의 bit depth를 "8"이 아니라 "IPL_DEPTH_32F"로 바꾼 다음, 음수로 나온 gradient 값을 양수로 바꾸어 준다.
그런데, 입력 영상을 담을 메모리를 별도로 생성하지 않고, 다음과 같이 비디오 프레임 캡처 시 만들어 주므로 인위적으로 설정해 줄 수 없다.

iplInput = cvRetrieveFrame(capture);

그래서 cvConvert() 함수를 이용한다. 정의는 다음과 같다.

OpenCV.framework/Versions/A/Headers/cxcore.h

#define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )

void cvConvertScale(const CvArr* src, CvArr* dst, double scale=1, double shift=0)¶

Converts one array to another with optional linear transformation.

#define cvCvtScale cvConvertScale

#define cvScale  cvConvertScale

#define cvConvert(src, dst )  cvConvertScale((src), (dst), 1, 0 )

Parameters:	src – Source array dst – Destination array scale – Scale factor shift – Value added to the scaled source array elements

-2) Non Maximum Suppression (NMS)
이웃 화소들의 세기값을 비교하여 해당 픽셀이 최대값이 아니면 "0"으로 하여 지워 준다

입력 영상

x방향 DoG filtering하고 NMS한 영상

y방향 DoG filtering하고 NMS한 영상

Szeliski, Computer Vision: Algorithms and Applications, 214쪽

Szeliski, Computer Vision: Algorithms and Applications, 215쪽

ref.
http://research.microsoft.com/en-us/um/people/szeliski/Book/
2010/04/06 - [Visual Information Processing Lab] - Non Maximum Suppression (NMS)

Try #2.
Sobel 마스크 이용

3) gradient의 방향 판별

: 검출된 edge의 Gx, Gy의 절대값을 비교하여 vertical인지 horizontal인지 direction을 판별한다.
이로부터 그 점이 수평선 위의 점인지 수직선 위의 점인지를 구별하여 다음 단계인 line fitting에 적용한다.

ref. 2010/02/23 - [Visual Information Processing Lab] - virtual studio 구현: workflow

/* Test: feature point extraction in implementing virtual studio
: using Gaussin gradient filter, first-order Derivative of Gaussian (DoG) filter
with a kernel h = [-1, -7, -15, 0, 15, 7, 1]
ref. swPark_2000rti.pdf:440p
camera: Logitech QuickCam Pro 4000
2010, lym & kyu
*/

// + non maximum suppression

#include <OpenCV/OpenCV.h>
#include <iostream>
using namespace std;

// non-maximum suppression (NMS)
void nonMaximumSuppression ( IplImage* image, int kernel, int threshold )
{
    for ( int y = 0; y < image->height; y++ )
    {
        //        cout << "y = " << y << endl;
        for ( int x = 0; x < image->width; x++ )
        {
            float intensity = CV_IMAGE_ELEM( image, float, y, x );
            if ( intensity > threshold ) {
                float neighbor;
                int flag = 0;

                for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
                {
                    if ( y+ky < 0 || y+ky >= image->height ) { // border check
                        continue;
                    }
                    for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
                    {
                        if ( x+kx < 0 || x+kx >= image->width ) { // border check
                            continue;
                        }
                        neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
                        if ( intensity < neighbor ) {
                            CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
                            flag = 1;
                            break;
                        }
                    }
                    if ( 1 == flag ) {
                        break;
                    }
                }
            }

            else {
                CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
            }
        }
    }
}

// non-maximum suppression (NMS)
void nonMaximumSuppression2 ( IplImage* image, IplImage* image2, int kernel)
{
    float neighbor, neighbor2;
    for ( int y = 0; y < image->height; y++ )
    {
        //        cout << "y = " << y << endl;
        for ( int x = 0; x < image->width; x++ )
        {
            float intensity = CV_IMAGE_ELEM( image, float, y, x );
            //            if ( intensity > threshold ) {
            if (intensity > 0) {
                int flag = 0;

                for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
                {
                    if ( y+ky < 0 || y+ky >= image->height ) { // border check
                        continue;
                    }
                    for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
                    {
                        if ( x+kx < 0 || x+kx >= image->width ) { // border check
                            continue;
                        }
                        neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
                        neighbor2 = CV_IMAGE_ELEM( image2, float, y+ky, x+kx );
                        //                        if ( intensity < neighbor ) {
                        if ( intensity < neighbor || intensity < neighbor2) {
                            CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
                            flag = 1;
                            break;
                        }
                    }
                    if ( 1 == flag ) {
                        break;
                    }
                }
            }

            else {
                CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
            }
        }
    }
}

// in the gradient direction
void selectEdges( IplImage* image1, IplImage* image2 )
{
    for ( int y = 0; y < image1->height; y++ )
    {
        //        cout << "y = " << y << endl;
        for ( int x = 0; x < image1->width; x++ )
        {

            if( x == image1->width - 1 ) {
                x = x;
            }

            float intensity1 = CV_IMAGE_ELEM( image1, float, y, x );
            if ( intensity1 > 0.0 ) { // if the pixel is a edge point surviving NMS
                float intensity2 = CV_IMAGE_ELEM( image2, float, y, x );
                // compare it with the gradient value in the other direction
                if ( intensity1 < intensity2 ) {
                    CV_IMAGE_ELEM( image1, float, y, x ) = 0.0;
                }
            }
        }
    }
}

int main()
{
    IplImage* iplInput = 0; // input image
    IplImage* iplGray = 0; // grey image converted from input image
    IplImage *iplTemp = 0; // converted image from input image with a change of bit depth
    //    IplImage* iplDoG = 0; // filtered image by DoG
    IplImage* iplDoGx = 0, *iplDoGxClone; // filtered image by DoG in x-direction
    IplImage* iplDoGy = 0, *iplDoGyClone; // filtered image by DoG in y-direction

    double minValx, maxValx;
    double minValy, maxValy;
    double minValt, maxValt;

    //    double threshold = 100.0;
    double threshold = 0.0;
    int kernel = 1;

    double h[] = { -1, -7, -15, 0, 15, 7, 1 };

    CvMat DoGx = cvMat( 1, 7, CV_64FC1, h );
    CvMat* DoGy = cvCreateMat( 7, 1, CV_64FC1 );
    cvTranspose( &DoGx, DoGy ); // transpose(&DoGx) -> DoGy

    char title_fx[200], title_fy[200];
    sprintf(title_fx, "filtered image by DoGx");
    sprintf(title_fy, "filtered image by DoGy");

    cvNamedWindow("input");
    cvNamedWindow( "temp" );
    cvNamedWindow(title_fx);
    cvNamedWindow(title_fy);
    //    cvNamedWindow(title_f);

    char title_ex[200], title_ey[200];
    sprintf(title_ex, "edges in x direction");
    sprintf(title_ey, "edges in y direction");

    cvNamedWindow(title_ex);
    cvNamedWindow(title_ey);
    //    cvNamedWindow(title_e);


    // initialize capture from a camera
    CvCapture* capture = cvCaptureFromCAM(0); // capture from video device #0
    int count = 0; // number of grabbed frames

    while(1) {
        // get video frames from the camera
        //        if (0) {
        if ( !cvGrabFrame(capture) ) {
            printf("Could not grab a frame\n\7");
            exit(0);
        }
        else {
            cvGrabFrame( capture ); // capture a frame
            iplInput = cvRetrieveFrame(capture); // retrieve the caputred frame
            //            iplInput = cvLoadImage("P:/input.bmp"); // retrieve the caputred frame

            if(iplInput) {
                if(0 == count) {
                    // create an image header and allocate the image data
                    /*                   iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
                    iplDoGx = cvCreateImage(cvGetSize(iplInput), 8, 1);
                    iplDoGy = cvCreateImage(cvGetSize(iplInput), 8, 1);
                    */
                    iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
                    iplTemp = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
                    iplDoGx = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
                    iplDoGy = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
                    iplDoGyClone = cvCloneImage(iplDoGy), iplDoGxClone = cvCloneImage(iplDoGx);

                }
                // convert the input color image to gray one
                cvCvtColor(iplInput, iplGray, CV_BGR2GRAY); // convert an image from one color space to another
                // convert one array to another with optional linear transformation
                cvConvert(iplGray, iplTemp);
                // increase the frame number
                count++;
            }
            cvShowImage( "input", iplInput );
            // convolve an image with the kernel
            // void cvFilter2D(const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1)
            cvFilter2D( iplTemp, iplDoGx, &DoGx ); // convolve an image with the DoG kernel in x-direction
            cvFilter2D( iplTemp, iplDoGy, DoGy ); // convolve an image with the DoG kernel in y-direction
            // ref. http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvabs#cvAbsDiffS
            cvAbs(iplDoGx, iplDoGx);            cvAbs(iplDoGy, iplDoGy);

            // normalize the pixel values
            // http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvminmax#cvMinMaxLoc
            // void cvMinMaxLoc(const CvArr* arr, double* minVal, double* maxVal, CvPoint* minLoc=NULL, CvPoint* maxLoc=NULL, const CvArr* mask=NULL)¶
            cvMinMaxLoc( iplDoGx, &minValx, &maxValx );
            cvMinMaxLoc( iplDoGy, &minValy, &maxValy );
            cvMinMaxLoc( iplTemp, &minValt, &maxValt );
            cvScale( iplDoGx, iplDoGx, 1.0 / maxValx );
            cvScale( iplDoGy, iplDoGy, 1.0 / maxValy );
            cvScale( iplTemp, iplTemp, 1.0 / maxValt );

            // display windows
            cvShowImage( "temp", iplTemp );
            cvShowImage( title_fx, iplDoGx );
            cvShowImage( title_fy, iplDoGy );

            // save images to files
            cvSaveImage("input.bmp", iplInput);
            cvSaveImage("gray.bmp", iplGray);
            cvSaveImage("temp.bmp", iplTemp);
            cvSaveImage("DoGx.bmp", iplDoGx);
            cvSaveImage("DoGy.bmp", iplDoGy);

            // non-Maximum suppression (NMS)
            // void NonMaximumSuppression ( IplImage* image, int kernel, int threshold )
//            nonMaximumSuppression ( iplDoGx, kernel, threshold ); nonMaximumSuppression ( iplDoGy, kernel, threshold );
//           cvCopyImage(iplDoGy, iplDoGyClone), cvCopyImage(iplDoGx, iplDoGxClone);
            cvCopy(iplDoGy, iplDoGyClone), cvCopy(iplDoGx, iplDoGxClone);

            nonMaximumSuppression2 ( iplDoGx, iplDoGyClone, kernel );
            nonMaximumSuppression2 ( iplDoGy, iplDoGxClone, kernel );

            // normalize the pixel values
            // http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvminmax#cvMinMaxLoc
            // void cvMinMaxLoc(const CvArr* arr, double* minVal, double* maxVal, CvPoint* minLoc=NULL, CvPoint* maxLoc=NULL, const CvArr* mask=NULL)¶
            cvMinMaxLoc( iplDoGx, &minValx, &maxValx );
            cvMinMaxLoc( iplDoGy, &minValy, &maxValy );
            cvMinMaxLoc( iplTemp, &minValt, &maxValt );
            cvScale( iplDoGx, iplDoGx, 1.0 / maxValx );
            cvScale( iplDoGy, iplDoGy, 1.0 / maxValy );
            cvScale( iplTemp, iplTemp, 1.0 / maxValt );

            // display windows
            cvShowImage( "temp", iplTemp );
            cvShowImage( title_ex, iplDoGx );
            cvShowImage( title_ey, iplDoGy );

            // save images to files
            cvSaveImage("input.bmp", iplInput);
            cvSaveImage("gray.bmp", iplGray);
            cvSaveImage("temp.bmp", iplTemp);
            cvSaveImage("edgeX.bmp", iplDoGx);
            cvSaveImage("edgeY.bmp", iplDoGy);

            if( cvWaitKey(10) >= 0 )
                break;
        }
    }

    cvReleaseCapture( &capture ); // release the capture source
    cvDestroyWindow( "input" );
    cvDestroyWindow( "temp" );
    cvDestroyWindow(title_fx);
    cvDestroyWindow(title_fy);
    cvDestroyWindow(title_ex);
    cvDestroyWindow(title_ey);

    return 0;
}

입력 영상

수직선 상의 edges만 검출한 영상

수평선 상의 edges만 검출한 영상

입력 영상

수직선 상의 edges만 검출한 영상

수평선 상의 edges만 검출한 영상

잘 됨 ^^

저작자표시 비영리 동일조건

'Computer Vision' 카테고리의 다른 글

OpenCV: cvFitLine() 연습 코드 (0)	2010.04.06
virtual studio 구현: line fitting test (0)	2010.04.06
OpenCV: cvFilter2D() 연습 코드 (0)	2010.04.04
Image Filtering (0)	2010.04.03
OpenCV: cvSobel() 연습 코드 (3)	2010.04.03

posted by maetel

돛단배

Tag

Notice

Recent Post

Recent Comment

Recent Trackback

Archive

My Link

calendar

Category