C++ 이퀄라이제이션 된 이미지 스트레칭

Question

(2) 이미지에서 (3)을 만들어야합니다.

1. 원본 이미지 : http://i.imgur.com/X5MKF6z.jpg
2. 평준화 이미지 : http://i.imgur.com/oFBVUJp.png
3. 평준화와 스트레치 이미지 : 나는 equalizeHist을 사용할 수도 OpenCV의와 http://i.imgur.com/V7jeaRQ.png

() 이퀄라이제이션과 스트레칭을 모두 수행합니다.

따라서 OPENCV를 사용하지 않고 평형화 이미지에서 어떻게 스트레칭을 할 수 있습니까? 균등화 부분은 아래에서 수행됩니다.

#include <iostream> 
#include <opencv2/highgui/highgui.hpp> 
#include <opencv2/imgproc/imgproc.hpp> 
#include <opencv/highgui.h> 
#include <cstring> 
using std::cout; 
using std::cin; 
using std::endl; 

using namespace cv; 

void imhist(Mat image, int histogram[]) 
{ 

    // initialize all intensity values to 0 
    for (int i = 0; i < 256; i++) 
    { 
     histogram[i] = 0; 
    } 

    // calculate the no of pixels for each intensity values 
    for (int y = 0; y < image.rows; y++) 
     for (int x = 0; x < image.cols; x++) 
      histogram[(int)image.at<uchar>(y, x)]++; 

} 

void cumhist(int histogram[], int cumhistogram[]) 
{ 
    cumhistogram[0] = histogram[0]; 

    for (int i = 1; i < 256; i++) 
    { 
     cumhistogram[i] = histogram[i] + cumhistogram[i - 1]; 
    } 
} 

int main() 
{ 
    // Load the image 
    Mat image = imread("y1.jpg", CV_LOAD_IMAGE_GRAYSCALE); 

    // Generate the histogram 
    int histogram[256]; 
    imhist(image, histogram); 


    // Caluculate the size of image 
    int size = image.rows * image.cols; 
    float alpha = 255.0/size; 

    // Calculate the probability of each intensity 
    float PrRk[256]; 
    for (int i = 0; i < 256; i++) 
    { 
     PrRk[i] = (double)histogram[i]/size; 
    } 

    // Generate cumulative frequency histogram 
    int cumhistogram[256]; 
    cumhist(histogram, cumhistogram); 

    // Scale the histogram 
    int Sk[256]; 
    for (int i = 0; i < 256; i++) 
    { 
     Sk[i] = cvRound((double)cumhistogram[i] * alpha); 
    } 

    // Generate the equlized image 
    Mat new_image = image.clone(); 

    for (int y = 0; y < image.rows; y++) 
     for (int x = 0; x < image.cols; x++) 
      new_image.at<uchar>(y, x) = saturate_cast<uchar>(Sk[image.at<uchar>(y, x)]); 
    ////////////////////////////////////////// 

    // // Generate the histogram stretched image 
    Mat str_image = new_image.clone(); 

    //for (int a = 0; a < str_image.rows; a++) 
    // for (int b = 0; b < str_image.cols; b++) 

    // Display the original Image 
    namedWindow("Original Image"); 
    imshow("Original Image", image); 

    // Display equilized image 
    namedWindow("Equalized Image"); 
    imshow("Equalized Image", new_image); 


    waitKey(); 
    return 0; 
} 

Answer 1

정상적인 방법은 가장 어두운 픽셀과 가장 밝은 픽셀을 찾는 것입니다. 충분히

darkest=pixel[0,0] // assume first pixel is darkest for now, and overwrite later 
brightest=pixel[0,0] // assume first pixel is lightest for now, and overwrite later 
for all pixels 
    if this pixel < darkest 
     darkest = this pixel 
    else if this pixel > brightest 
     brightest = this pixel 
    endif 
end for 

간단한 :이 같은 의사 코드, 모든 픽셀을 통해 그을음 루프 반복하는에서이 작업을 수행 할 수 있습니다. 그래서, 가장 어둡고 밝은 것이 각각 80과 220이라고 가정합시다. 이제이 범위 80.2.220을 전체 범위 0..255로 늘려야합니다.

따라서 이미지의 모든 픽셀에서 80을 빼서 막대 그래프의 왼쪽 끝에서 0으로 이동하므로 범위가 0..140이됩니다. 이제 모든 픽셀에 255/140을 곱하여 오른쪽 끝을 255로 늘려야합니다. 물론 픽셀 배열을 통해 단일 패스로 두 가지 산술 연산을 모두 수행 할 수 있습니다.

for all pixels 
    newvalue = int((current value - darkest)*255/(brightest-darkest)) 
end for