Showing posts with label OpenCV. Show all posts
Showing posts with label OpenCV. Show all posts

Tuesday, July 12, 2022

Unsharp Filter OpenCV C++

 
Unsharp Filter OpenCV C++

Unsharp masking is an image sharpening technique, first implemented in darkroom photography, but now commonly used in digital image processing software. Its name derives from the fact that the technique uses a blurred, or "unsharp", negative image to create a mask of the original image. Wikipedia

Requirement

Implement C++ code to apply  unsharp filter for input image. 

Approach 

  • Blur the original Image
  • Subtract the blurred image from original image (Call this as mask)
  • Add the mask to the original

Source Code

/*
 * UnsharpFilter.cpp
 *
 *  Created on: Jul 12, 2022
 *      Author: viduranga
 */

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

using std::cin;
using std::cout;
using std::endl;

using namespace cv;

int kernel[5][5] = {1,4,7,4,1,
4,16,26,16,4,
7,26,41,26,7,
4,16,26,16,4,
1,4,7,4,1};

int accessPixel(unsigned char * arr, int col, int row, int k, int width, int height)
{
    int sum = 0;
    int sumKernel = 0;

    for (int j = -1; j <= 1; j++)
    {
        for (int i = -1; i <= 1; i++)
        {
            if ((row + j) >= 0 && (row + j) < height && (col + i) >= 0 && (col + i) < width)
            {
                int color = arr[(row + j) * 3 * width + (col + i) * 3 + k];
                sum += color * kernel[i + 1][j + 1];
                sumKernel += kernel[i + 1][j + 1];
            }
        }
    }

    return sum / sumKernel;
}

void guassian_blur2D(unsigned char * arr, unsigned char * result, int width, int height)
{
    for (int row = 0; row < height; row++)
    {
        for (int col = 0; col < width; col++)
        {
            for (int k = 0; k < 5; k++)
            {
                result[3 * row * width + 3 * col + k] = accessPixel(arr, col, row, k, width, height);
            }
        }
    }
}

int main(int argc, char** argv)
{
char* ImageFile = argv[1];
double threshold = 10, amount = 5;

Mat input_imge = imread(ImageFile);

if( argc != 2 || !input_imge.data )
{
   cout <<" No image data" <<endl;
   return -1;
}

Mat blurred_image = input_imge.clone();
guassian_blur2D(input_imge.data, blurred_image.data, input_imge.cols, input_imge.rows);
Mat lowConstrastMask = abs(input_imge - blurred_image) < threshold;
Mat sharpened = input_imge*(1+amount) + blurred_image*(-amount);
sharpened.copyTo(input_imge, lowConstrastMask);

imshow("Original Image", input_imge);
imshow("Mask Image",lowConstrastMask);
imshow("Blurred Image",blurred_image);
imshow("Unsharp Filter", sharpened);

waitKey(0);
return 0;
}

Output

Input Image
























Blurred Image
























Mask Image
























Unsharp Image



Sunday, June 26, 2022

How to get Intensity Histogram of an Image

 

How to get Intensity Histogram of an Image

This blog shows how to get intensity histogram of an image.

Language: C++
Libraries: OpenCV

I use Eclipse to develop the code. If you are new to OpenCV and Eclipse, Please follow my previous blogs.

How to install OpenCV

https://sltechgeekx.blogspot.com/2022/06/how-to-installing-opencv-from-source.html

How to Create a Project in Eclipse with OpenCV Libraries

https://sltechgeekx.blogspot.com/2022/06/how-to-convert-rgb-image-to-gray.html

Program Source Code

#include <opencv2/opencv.hpp>

using namespace cv;

int main(int argc, char** argv)
{
char* ImageFile = argv[1];
Mat input_image;  /* mat object for storing original_image */
input_image = imread( ImageFile, IMREAD_COLOR ); /* read ImageFile */

if( argc != 2 || !input_image.data )
{
   printf( " No image data \n " );
   return -1;
}

Mat gray_image; /* mat object for storing gray_image */
cvtColor( input_image, gray_image, COLOR_BGR2GRAY ); /* convert image from color to gray */

    int histogram[256]; /* allcoate memory for no of pixels for each intensity value */

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

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

    /* draw the histograms */
    int hist_w = 512; int hist_h = 400;
    int bin_w = cvRound((double) hist_w/256);

    Mat histImage(hist_h, hist_w, CV_8UC1, Scalar(255, 255, 255));

    /* find the maximum intensity element from histogram */
    int max = histogram[0];

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

    /* normalize the histogram between 0 and histImage.rows */
    for(int i = 0; i < 255; i++)
    {
        histogram[i] = floor(((double)histogram[i]/max)*histImage.rows);
    }

    /* draw the intensity line for histogram */
    for(int i = 0; i < 255; i++)
    {
        line(histImage, Point(bin_w*(i), hist_h),
                              Point(bin_w*(i), hist_h - histogram[i]),
             Scalar(0,0,0), 1, 8, 0);
    }

namedWindow( "Input Image in Gray", WINDOW_AUTOSIZE );   /* set window name Gray Image */
imshow( "Input Image in Gray", gray_image );   /* show window containing gray_image */

namedWindow("Intensity Histogram", WINDOW_AUTOSIZE);  /* set window name Intensity Histogram */
imshow("Intensity Histogram", histImage);   /* show window containing Intensity Histogram */

waitKey(0);      /* to exit */

return 0;
}

Program Output



Thursday, June 16, 2022

How to Convert RGB Image to Gray

How to Convert RGB Image to Gray

There are many many ways to convert RGB image to gray color. In this blog, I am wring a C++ code to do this. 

Prerequisites

  • Install OpenCV Libraries (https://sltechgeekx.blogspot.com/2022/06/how-to-installing-opencv-from-source.html)
  • Eclipse C++ development application  

Create New Project

Open Eclipse C/C++ and create a new C++ Project call “ConvertImageToGrayscale”

File -> New -> C++ Project

Include OpenCV Path

Right Click on the Project -> Properties -> C/C++ Build -> Settings -> Includes



Add opencv installed path


Include OpenCV Library Path

Include opencv libs to your project



Add New Source File

  • Add new folder call “src” to project
    • Right Click on the Project -> New -> Folder -> Enter the name
  • Add Source file call “ConvertImageToGrayscale.cpp” to that “src” folder.
    • Right Client on src folder -> New -> Source File -> Enter the Name


Source Code

/*
 *  ConvertImageToGrayscale.cpp
 *
 *  Created on: Jun 15, 2022
 *  Author: viduranga
 */

#include <opencv2/opencv.hpp>
#include <unistd.h>

#ifndef __has_include
  static_assert(false, "__has_include not supported");
#else
#  if __cplusplus >= 201703L && __has_include(<filesystem>)
#    include <filesystem>
     namespace fs = std::filesystem;
#  elif __has_include(<experimental/filesystem>)
#    include <experimental/filesystem>
     namespace fs = std::experimental::filesystem;
#  elif __has_include(<boost/filesystem.hpp>)
#    include <boost/filesystem.hpp>
     namespace fs = boost::filesystem;
#  endif
#endif

using namespace cv;
using fs::current_path;

int main(int argc, char** argv)
{
char* ImageFile = argv[1];
Mat original_image;  /* mat object for storing original_image */
original_image = imread( ImageFile, IMREAD_COLOR ); /* read ImageFile */

if( argc != 2 || !original_image.data )
{
   printf( " No image data \n " );
   return -1;
}

char *cwd = get_current_dir_name();  /* Get Current working Directory */
std::string CurrentWorkingDirectory(cwd);
std::string InputFilePath(ImageFile);
std::string input_filename = InputFilePath.substr(InputFilePath.find_last_of("/\\") + 1); /* Get Path of input file */
std::string input_folder_path = InputFilePath.substr(0,InputFilePath.find_last_of("\\/"));  /* Get Folder Path of input file */
std::string OutputFile;

if (input_filename != InputFilePath)
{
OutputFile = input_folder_path.append("/greyImage-");
}
else {
OutputFile = CurrentWorkingDirectory.append("/greyImage-");
}

OutputFile = OutputFile.append(input_filename);

Mat gray_image; /* mat object for storing gray_image */
cvtColor( original_image, gray_image, COLOR_BGR2GRAY ); /* convert image from color to gray */

imwrite( OutputFile, gray_image );

namedWindow( "Original Image", WINDOW_AUTOSIZE );  /* set window name for Original Image */
namedWindow( "Gray Image", WINDOW_AUTOSIZE );   /* set window name Gray Image */

imshow( "Original Image", original_image );   /* show window containing original_image */
imshow( "Gray Image", gray_image );   /* show window containing gray_image */

waitKey(0);      /* to exit */

return 0;
}

Build the Project and Run

Right Click on the Project -> Build Project


Run the executable file. You have put image file as command line argument.

Monday, June 13, 2022

How to Installing OpenCV from the Source



What is OpenCV

OpenCV (Open Source Computer Vision Library) is an open source computer vision and machine learning software library. OpenCV was built to provide a common infrastructure for computer vision applications and to accelerate the use of machine perception in the commercial products. 

Install the required dependencies

apt install build-essential cmake git pkg-config libgtk-3-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libxvidcore-dev libx264-dev libjpeg-dev libpng-dev libtiff-dev gfortran openexr libatlas-base-dev python3-dev python3-numpy libtbb2 libtbb-dev libdc1394-22-dev 

Clone the OpenCV’s and OpenCV contrib repositories

mkdir ~/opencv_build && cd ~/opencv_build
git clone https://github.com/opencv/opencv.git
git clone https://github.com/opencv/opencv_contrib.git 

Once the download is complete, create a temporary build directory, and switch to it

cd ~/opencv_build/opencv
mkdir build && cd build

Set up the OpenCV build with CMake

cmake -D CMAKE_BUILD_TYPE=RELEASE \
    -D CMAKE_INSTALL_PREFIX=/usr/local \
    -D INSTALL_C_EXAMPLES=ON \
    -D INSTALL_PYTHON_EXAMPLES=ON \
    -D OPENCV_GENERATE_PKGCONFIG=ON \
    -D OPENCV_EXTRA_MODULES_PATH=~/opencv_build/opencv_contrib/modules \
    -D BUILD_EXAMPLES=ON ..

When the CMake build system is finalized, you will see something like below



















Start the compilation process

make -j8

Modify the -j flag according to your processor. If you do not know the number of cores in your processor, you can find it by typing nproc.

The compilation may take several minutes or more, depending on your system configuration. Once it is completed you will see something like below:










Install OpenCV

make install











To verify whether OpenCV has been installed successfully, type the following command and you should see the OpenCV version

pkg-config --modversion opencv4