Opencv C++ 6. Grayscale transformation: linear transformation, grayscale inversion, logarithmic transformation, gamma transformation, (adaptive) histogram equalization

4. Grayscale inversion:

#include<iostream>
#include<opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main()
{
Mat image1, output_image, image1_gray; //Define input image, output image, grayscale image
image1 = imread("D://lena.png"); //Read image;
if (image1.empty())
{
cout << "Read error" << endl;
return -1;
}

cvtColor(image1, image1_gray, COLOR_BGR2GRAY); //Grayscale
imshow("image1_gray", image1_gray); //Display grayscale image

output_image = image1_gray.clone();
for (int i = 0; i < image1_gray.rows; i + + )
{
for (int j = 0; j < image1_gray.cols; j + + )
{
output_image.at<uchar>(i, j) = 255 - image1_gray.at<uchar>(i, j); //Grayscale inversion
}
}
imshow("output_image", output_image); //Display the inverted image


waitKey(0); //Pause, keep the image displayed, wait for the key to end
return 0;
}

The result is:

The original image is on the left and the reversed image is on the right

Function introduction:

cvtColor(image1, image1_gray, COLOR_BGR2GRAY);

The general syntax of the cvtColor function is as follows:

void cvtColor(InputArray src, OutputArray dst, int code, int dstCn = 0);

Here are some common code values and their meanings:

• CV_BGR2GRAY: BGR to grayscale conversion.
• CV_BGR2HSV: BGR to HSV (hue, saturation, lightness) conversion.
• CV_BGR2Lab: BGR to Lab conversion.
• CV_BGR2YUV: BGR to YUV conversion.
• CV_RGB2BGR: RGB to BGR conversion.
• CV_GRAY2BGR: Grayscale to BGR conversion.

What is selected in this code is CV_BGR2GRAY, which converts BGR into grayscale.

output_image = image1_gray.clone();
for (int i = 0; i < image1_gray.rows; i + + )
{
for (int j = 0; j < image1_gray.cols; j + + )
{
output_image.at<uchar>(i, j) = 255 - image1_gray.at<uchar>(i, j); //Grayscale inversion
}
}

1. output_image = image1_gray.clone();: First, create an output image output_image with the same size and type as the input image image1_gray, and It is initialized to be the same as the input image.

2. Next, the program uses nested loops to iterate over each pixel in the input image image1_gray.

3. output_image.at(i, j) = 255 - image1_gray.at(i, j);: In the inner loop, for each pixel (i, j ), which does the following:

   • image1_gray.at(i, j): Gets the grayscale value at pixel (i, j) from the input image. at(i, j) indicates that the pixel value is an unsigned character type (8-bit grayscale image).
   • 255 - image1_gray.at(i, j): Subtract 255 from the obtained gray value to achieve gray inversion. This causes lighter pixels to become darker and darker pixels to become lighter, inverting the appearance of the image.

Through this process, the grayscale value of each pixel in the input image is inverted, and the final result is stored in output_image. This operation can be used to create a negative effect or to convert a negative into a positive to achieve special effects on an image.

5. Gamma correction

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace cv;
using namespace std;

int main() {
    //Load image
    Mat image = imread("D://lena.png");

    if (image.empty()) {
        cout << "Unable to load image" << endl;
        return -1;
    }

    // gamma value
    double gamma = 2; // Greater than or equal to 0, less than 0 is black.

    // Gamma correction
    Mat gamma_corrected_image = Mat::zeros(image.size(), image.type());

    for (int y = 0; y < image.rows; y + + ) {
        for (int x = 0; x < image.cols; x + + ) {
            for (int c = 0; c < image.channels(); c + + ) {
                double pixel_value = image.at<Vec3b>(y, x)[c] / 255.0;
                double corrected_value = pow(pixel_value, gamma) * 255.0;
                gamma_corrected_image.at<Vec3b>(y, x)[c] = saturate_cast<uchar>(corrected_value);
            }
        }
    }

    // Display original image and gamma corrected image
    imshow("original image", image);
    imshow("Gamma corrected image", gamma_corrected_image);
    waitKey(0);

    return 0;
}

Rendering:

6. Logarithmic transformation

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <cmath>

using namespace cv;
using namespace std;

int main() {
    //Load image
    Mat image = imread("D://lena.png");

    if (image.empty()) {
        cout << "Unable to load image" << endl;
        return -1;
    }

    // Logarithmic transformation parameters
    double c = 1.0; // constant
    double gamma = 0.5; // Parameters of logarithmic transformation

    // Logarithmic transformation
    Mat log_transformed_image = Mat::zeros(image.size(), image.type());

    for (int y = 0; y < image.rows; y + + ) {
        for (int x = 0; x < image.cols; x + + ) {
            for (int c = 0; c < image.channels(); c + + ) {
                double pixel_value = image.at<Vec3b>(y, x)[c] / 255.0;
                double corrected_value = c * log(1 + pixel_value) / log(1 + gamma);
                log_transformed_image.at<Vec3b>(y, x)[c] = saturate_cast<uchar>(corrected_value * 255.0);
            }
        }
    }

    // Display the original image and the logarithmically transformed image
    imshow("original image", image);
    imshow("Logarithmically transformed image", log_transformed_image);
    waitKey(0);

    return 0;
}

Rendering:

7. Histogram equalization

In this example, we load an image and load it as a grayscale image using the IMREAD_GRAYSCALE mode. Then, we use the equalizeHist function to perform histogram equalization to enhance the contrast of the image.

Histogram equalization is a simple yet effective method that can improve the contrast of an image by making the pixel values in an image more evenly distributed. This example demonstrates how to use OpenCV to implement histogram equalization to improve the visual quality of images.

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace cv;
using namespace std;

int main() {
    //Load image
    Mat image = imread("D://lena.png", IMREAD_GRAYSCALE); // Load the image in grayscale mode

    if (image.empty()) {
        cout << "Unable to load image" << endl;
        return -1;
    }

    // Histogram equalization
    Mat equalized_image;
    equalizeHist(image, equalized_image);

    // Display the original image and the equalized image
    imshow("original image", image);
    imshow("image after histogram equalization", equalized_image);
    waitKey(0);

    return 0;
}

Rendering:

Why do we need to convert the image to grayscale mode before histogram equalization?

Histogram equalization is usually used for grayscale image processing, rather than color images, mainly for the following reasons:

1. Simplified processing: Histogram equalization is a very basic and common image enhancement technique. In grayscale images, each pixel has only one grayscale value, so the processing is relatively simple. When processing color images, histogram equalization needs to be performed on each channel separately, adding complexity.

2. Principle of histogram equalization: The core idea of histogram equalization is to stretch and expand the pixel value range of the image by redistributing pixel values to make the histogram of the image more uniform. In a grayscale image, this means adjusting the image's gray levels so that they are more evenly distributed between 0 and 255. In color images, this operation needs to be done separately for each channel.

3. Color information redundancy: Color images contain more information, including color and brightness information. In some cases, only the brightness information needs to be equalized since the color information may not need to be changed. By converting a color image to grayscale, you can better control the effects of equalization to maintain the overall appearance of the image.

4. Common applications: Histogram equalization is commonly used in applications such as medical image processing, computer vision, and image enhancement, which often use grayscale images. Therefore, in these scenarios, histogram equalization is often applied directly to grayscale images to improve contrast.

Although histogram equalization is usually used for grayscale images, there are also extended methods for color images, such as equalizing the luminance channel while leaving the color information unchanged. This type of method is often called color histogram equalization or color equalization. In this case, luminance information is processed, while color information is preserved.

8. Adaptive histogram equalization

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace cv;
using namespace std;

int main() {
    //Load image
    Mat image = imread("D://lena.png", IMREAD_GRAYSCALE); // Load the image in grayscale mode

    if (image.empty()) {
        cout << "Unable to load image" << endl;
        return -1;
    }

    // Adaptive histogram equalization
    Mat adaptive_equalized_image;
    equalizeHist(image, adaptive_equalized_image);

    // Display the original image and the image after adaptive histogram equalization
    imshow("original image", image);
    imshow("Image after adaptive histogram equalization", adaptive_equalized_image);
    waitKey(0);

    return 0;
}

In this example, we load an image and load it as a grayscale image using the IMREAD_GRAYSCALE mode. We then use the equalizeHist function to perform adaptive histogram equalization to enhance the contrast of the image.

Adaptive histogram equalization is an improved histogram equalization method that applies equalization separately to different image areas to cope with lighting differences. This example demonstrates how to use OpenCV to implement adaptive histogram equalization to improve the visual quality of images.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- --------