'Integral Image'에 해당되는 글 2건

  1. 2012.02.04 Integral Image을 이용한 Adaptive Threshold
  2. 2008.07.14 Adaptive Binarization (1)
Adaptive threshold 방법을 적용하는 데 있어서 윈도우 계산의 로드를 줄이는 방법은 integral image을 이용하면 된다(물론 메모리의 소요가 부가적으로 발생하지만, 현재의 기기에서는 메모리는 별로 문제가 안된다).

아래의 코드는 integral 이미지를 이용해서 주어진 moving 윈도우 내의 픽셀합을 구하고 그것의 평균 (= local average)을 기준으로 영상을 이진화 시키는 함수다 (정확히는 "평균값-3" 이다. 여기서 3은 바코드 인식 공개라이브러리인 zbar에서 쓰는 기준을 잡았다. zbar 라이브러리에서는 moving average를 구하여 임계값으로 사용하는데, 윈도우가 이동하면서 나가는 픽셀과 들어오는 픽셀을 업데이트 하는 과정이  이 라이브러리에서는 정확히 구현이 되어있지는 않다. 그러나, 근사적으로는 맞게 구현되어 있으므로 코드는 대부분의 경우에 원하는데로 잘 동작을 한다. 적분영상을 이용하면, 윈도우가 이동하면서 픽셀정보를 업데이트 하는 복잡한 과정이 필요없이 적분영상의 단순 합/차만 수행하면 된다)

"윈도우 평균-3" 대신 보다 합리적인 기준을 잡으려면, 보통은 윈도우의 표준편차을 이용할 수 있다. 그러나 이 경우에는 합의 제곱에 대한 적분영상이 하나 더 필요하고, 얼마의 편차를 허용할 것인지를 정해주어야 한다. 이 기준에 맞게 구현된 코드는 http://kipl.tistory.com/30 에서 찾을 수 있다.

2차원 바코드가 아닌 일차원 바코들 영상을 이진화할 때는 이 만큼 복잡한(?) 알고리즘을 쓸 필요가 없다. 일차원 바코드는 한 스캔라인의 정보만으로도 보통 인식이 가능하므로 라인단위의 이진화면 충분히다. 이 경우에도 이동평균을 사용하면 매우 간단하게, 그리고 adaptive한 임계값을 구할수 있는데, 라인기준이므로 적분영상이 따로 필요하지 않다.

void makeIntegralImage(BYTE *image, int width, int height, int* intImage) {

더보기

/*
** moving window의 중심에 해당픽셀을 놓을 필요는 없다; 
*/
void thresholdByIntegralImage(BYTE *image, int width, int height, int wsz,
                              BYTE *matrix) { 
    std::vector<int> intImage(width * height);
    makeIntegralImage(image, width, height, &intImage[0]);
    const int winArea = wsz * wsz ;
    /*const int wsz = 10;*/
    for (int y = 0, offset = 0; y < height; y++, offset += width) {
        int top = y - (wsz>>1) ;
        if (top < 0 ) top = 0;
        else if (top > height - wsz) top = height - wsz;
        int bottom = top + wsz - 1;
        // y-range = [top, bottom];
        for (int x = 0; x < width; x++) {
            int left = x - (wsz>>1);
            if (left < 0) left = 0;
            else if (left > width - wsz) left = width - wsz;
            int right = left + wsz - 1;
            // xrange = [left, right];
            //
            int sum1 = (left > 0  && top > 0) ? intImage[(top - 1) * width + left - 1] : 0;
            int sum2 = (left > 0) ? intImage[bottom * width + left - 1] : 0;
            int sum3 = (top > 0) ? intImage[(top - 1) * width + right] : 0;
            //
            int graySum = intImage[bottom * width + right] - sum3 - sum2 + sum1;
            // overflow ? 
            // Threshold T = (window_mean - 3); why 3?
            if ((image[offset + x] + 3) * winArea <= graySum) {
                matrix[offset + x] = 0xFF; //inverted!
            } else {
                matrix[offset + x] = 0x00;
            }
        }
    }
}



'Image Recognition' 카테고리의 다른 글

Least Square Estimation of Perspective Transformation  (4) 2012.02.15
Perspective Transformation  (2) 2012.02.14
Integral Image을 이용한 Adaptive Threshold  (0) 2012.02.04
Peak Finder  (1) 2012.02.02
QR-code : decoder  (0) 2012.01.26
QR-code : detector  (0) 2012.01.12
Posted by helloktk

이미지를 이진화시키기 위해서 여러가지 알고리즘이 사용된다. 이미지 전체에 대해서 하나의 임계값을 이용하여서 이진화 시키는 알고리즘은 간단하고 빠르기 때문에 많이 이용이 된다. 그러나 이미지를 형성할 때 조명조건이 균일하지 않은 경우에는 이 방법으로는 원하는 결과를 얻을 수 없다. 이런 경우에는 각각의 픽셀 주위의 그레이값을 참조하여서 임계치를 결정하여야 한다. 간단한 방법은 윈도우내의 그레이값의 평균을 참조하는 것이다. 이보다 좀더 개선된 알고리즘은 평균값을 참조하되, 그레이값의 편차를 한번 더 고려해 주는 것이다. 이렇게 하여서 잡은 국소적인 임계치는 

128 은 그레이값이 갖을 수 있는 최대편차를 의미한다. 이 경우에는 단순 평균값으로 취한다는 의미이다. 그 외의 경우는 표준편차와 128의 차이(항상 음수다)에 비례하는 값으로 윈도우 평균값을 오프셋한 값을 임계치로 잡는다. factor는 일반적으로 정해지지 않고, 실험적으로 [0.2, 0.5]사이의 값이 취해진다. (문서처럼 배경이 흰색인 경우는 factor>0이지만, 만약에 반대의 경우, 즉 검정 배경에 흰색글씨를 처리하는 경우는 음수의 값을 취하는 것이 맞다)
 
국소적인 이진화 알고리즘은  매 픽셀마다 윈도우를 잡아서 계산해야하는 과정으로 인해서 계산비용이 많이 든다. 만약에 충분한 메모리를 갖춘 시스템의 경우에는 적분이미지(integral image)를 이용하면 윈도우 계산에 소요되는 비용을 줄일 수는 있다.

윈도우 크기와 factor는 결정하는 기준은 무었일까? 이것은 해결하고자 하는 문제의 특성에, 예를 들면 스캔된 문서를 이진화시키는 경우에는 윈도우에 충분한 글자가 들어 있어야 한다..등등, 많이 의존한다.

#define integral_image(x, y) (intimage[(y)*width+(x)])
#define integral_sqimg(x, y) (intsqimg[(y)*width+(x)])

void make_int_img12(BYTE *gray, int width, int height, *int intimage, int *intsqimg) {

더보기

//
void adap_binariztion(BYTE *gray, int width, int height,
          int w       /*window size = 15*/,
          double k  /*factor           = 0.2*/,
          BYTE *bimage)
{
    int whalf=w>>1; //half of adaptive window;
    int diff, sqdiff;
    // make integral image && square integral image;
    // if image is sufficiently large, use int64 or floating point number;
    std::vector<int> intimage(width * height) ;
    std::vector<int> intsqimg(width * height) ;

    //make integral image and its square integral image;
    make_int_img12(gray, width, height, &intimage[0], &intsqimg[0]);  
    //algorithm main;
    for(int j=0; j<height; j++){
        for(int i=0; i<width; i++){
            //clip windows
            int xmin = max(0,i-whalf);
            int ymin = max(0,j-whalf);
            int xmax = min(width-1,i+whalf);
            int ymax = min(height-1,j+whalf);
            int area = (xmax-xmin+1)*(ymax-ymin+1);
            // calculate window mean and std deviation;
            if(!xmin && !ymin){     // origin
                diff   = integral_image(xmax,ymax);
                sqdiff = integral_sqimg(xmax,ymax);
            }
            else if(!xmin && ymin){ // first column
                diff   = integral_image(xmax,ymax) - integral_image(xmax,ymin-1);
                sqdiff = integral_sqimg(xmax,ymax) - integral_sqimg(xmax,ymin-1);
            }
            else if(xmin && !ymin){ // first row
                diff   = integral_image(xmax,ymax) - integral_image(xmin-1,ymax);
                sqdiff = integral_sqimg(xmax,ymax) - integral_sqimg(xmin-1,ymax);
            }
            else{ // rest of the image
                int diagsum    = integral_image(xmax,ymax) + integral_image(xmin-1,ymin-1);
                int idiagsum   = integral_image(xmax,ymin-1) + integral_image(xmin-1,ymax);
                diff           = diagsum - idiagsum;
                int sqdiagsum  = integral_sqimg(xmax,ymax) + integral_sqimg(xmin-1,ymin-1);
                int sqidiagsum = integral_sqimg(xmax,ymin-1) + integral_sqimg(xmin-1,ymax);
                sqdiff         = sqdiagsum - sqidiagsum;
            }
            // threshold = window_mean *( 1 + factor * (std_dev/128.-1));
            // 128 = max_allowed_std_deviation in the gray image;
            double mean = double(diff)/double(area);
            double std  = sqrt((sqdiff - double(diff)*diff/double(area))/double(area-1));
            double threshold = mean*(1.0 + k*((std/128.0) - 1.));
            if(gray[j * width + i] < threshold)
                bimage[j * width + i] = 0;
            else
                bimage[j * width + i] = 255;
        }
    }  
}

사용자 삽입 이미지

'Image Recognition > Fundamental' 카테고리의 다른 글

Fant's Resampling  (0) 2008.12.17
Bright Preserving Histogram Equalization with Maximum Entropy  (0) 2008.07.31
Adaptive Binarization  (1) 2008.07.14
Histogram Equalization  (0) 2008.06.22
FFT2D  (0) 2008.06.10
Otsu Algorithm  (6) 2008.05.30
Posted by helloktk