Computer Vision learning

Computer Vision is the field advanced from image processing not just image capturing, formation, or restoration but also to extract the information from it and often its extrapolation also. These information are often related to objects present in the frame. some of the application are :

1. Object detection
2. Object tracking
3. Image classification/Segmentation
4. Motion oriented transformations
5. Face , Iris, Smile detection
6. Depth and 3D construction
7. Optical Character recognition (OCR)

 and several others things and fields like computational photography, Automotives - autonomous vehicle controls and safety, Medical Imaging etc.

Resources to learn it : Book reference : Computer Vision: Algorithms and Applications by Richard Szeliski   , Best place to learn it.

All these above mentioned features are mainly based on relationship between image, geometry and photometry. They uses fundamental 2d and 3d primitives
into their algorithms.

OpenCV is open source computer vision library, it has very large number of algorithms implemented and utilities for several image operations activity.

Image in OpenCV : Image gets read as matrix and mat (image object) classes has methods required for image operations like read, write, display, access image properties like color, channel, shape, size, pixels manipulation. Mat has matrix header and pointer to the matrix containing pixels. the matrix header gets used in reference
counting when there is shared address matrix.

Image Read, Modify and Display :

Mat cv::imread(const string& filename, int flag = IMREAD_COLOR)

IMREAD_GRAYSCALE = 0
IMREAD_COLOR = 1
IMREAD_UNCHANGED = -1  , load as it is, including alpha

using namespace cv;
Mat img = imread(imagepath, 0);

where img is image object allocated automatically , imread loads the image into it. imread reads images in blue green red BGR format.

Image data type:

Modify:

img.at<uchar>(1,1)=128;

img(Range(0,1), Range(0,3)).setTo(128);

Display:

for float datatype - value range is from 0 to 1, for int its 0 to 255

Matplotlib and imshow:

1. plt::figure_size(600, 400);

    plt::imshow(img);

    auto imgPlot = displayImg(img);

    imgPlot

2.  imshow("image", img);

     waitKey(0);

     destroyAllWindows();

Others:

a. named window

void cv::namedWindow (const  string&  windowName, int flag = WINDOW_AUTOSIZE)

b.  waitKey

int cv::waitKey(int delay = 0)  , 0 waits for key press

c. destroyWindow

void cv::destroyWindow(const string&  windowName)

d. destroyAllWindow

void cv::destroyAllWindow()

Saving Image:

bool cv::imwrite(const string& filename, InputArray img, const vector<int>&

      params = std::vector<int>())

imwrite("../testImg.jpg", img);

Color space:

OpenCV reads a given image in the BGR format by default. So, you’ll need to change the color space of your image from BGR to RGB when reading images using OpenCV

cv::cvtColor(img,cv.COLOR_BGR2GRAY)

Color Images

img.size() -> y x x

img.Channels() -> 3

Channel Operations : Split and Merge

Mat Chnls[3]

split(img, Chnls);

can be seen using displayImage(Chnls[i]) or imshow(Chnls[i])

Accessing color pixels

img.at<Vec3b>(0,0); --> gets 3 bytes in vector format

[1,1,1] --> intensity values

Modifying ->

img.at<Vec3b>(0,0) = Vec3b(0,255,255); B, G, R --> G and R --> yellow

Region :

img(Range(0,2), Range(0,3).setTo(Scalar(255,0,0));

Alpha channel :

Mat img = imread(img, -1);

Mat imgChanl[4];

split(img, imgChanl); --> imgChanl[i] -> points to each channel , B, G, R , A intensity value ranging from 0 to 255

========================================================

Create, Crop Images:

Mat img = Mat(400, 600, CV_8UC4, Scalar(128,128,128,0));

Mat img1 = img.clone();

Cropping

Mat  crop = img(Range(100, 200), Range(100, 400));

y --> 100 to 200

x --> 200 to 400

Resizing an Image:

void cv::resize( InputArray src,  --> input image

      OutputArray dst,  --> output image

      Size dstSize,   --> output size

      double fx = 0,

      double fy = 0,

      int interpolation = INTER_LINEAR)  --> bilinear , better quality than nearest neighbor

fx, fy sampling factor in horizontal and vertical axis

interpolation are usually nearest neighbor, bilinear, bicubic 

Image Masking:

used to segment out area of interest and not.

Mat mask = Mat::zeroes(image.size(), image.type());

mask(Range(40,100), Range(120, 180)).setTo(255);

inRange function : 

void cv::inRange(InputArray src,

     InputArray lower,

     InputArray upper,

     OutputArray dst)

Mat mask;

inRange(image, Scalar(0,0,150), Scalar(100,100,255), mask);

Digital Imaging - "What to think of"

 We thought to implement something which can perceive human eyes , but then the technological race lead that very thing "Camera" to go beyond just perceiving. Digital Imaging field is very vast and fast developing, its been incredible part of our daily activities of capturing images and videos.

Lets see what is it take to get a quality image and video for us:

1) Imaging Light
2) Imaging Sensors
3) Imaging Device
4) Image Processing Pipeline
5) Imaging Framework and Application
6) Imaging Quality Details, Ideas, Perspective and Sharing
7) Vision, Computation and Analysis

to be continued ...

2D Image Convolution in C or C++

How to get the convolution output of an Image with the given filter/Kernel 

// in, out are m x n images (integer data)
// K is the kernel size (KxK) - currently needs to be an odd number, e.g. 3
// coeffs[K][K] is a 2D array of integer coefficients
// scale is a scaling factor to normalise the filter gain

for (i = K / 2; i < m - K / 2; ++i) // iterate through image
{
  for (j = K / 2; j < n - K / 2; ++j)
  {
    int sum = 0; // sum will be the sum of input data * coeff terms

    for (ii = - K / 2; ii <= K / 2; ++ii) // iterate over kernel
    {
      for (jj = - K / 2; jj <= K / 2; ++jj)
      {
        int data = in[i + ii][j +jj];
        int coeff = coeffs[ii + K / 2][jj + K / 2];

        sum += data * coeff;
      }
    }
    out[i][j] = sum;  //if normalization needed then divide sum by N or factor.
  }
}