OpenCV – Water's Home

Opencv Tutorial

Posted on April 28, 2020August 26, 2020 by admin

Matplotlib RGB & OpenCV BGR

Posted on January 9, 2019 by admin

Matplotlib RGB & OpenCV BGR

```
import matplotlib.pyplot as plt
```
```
import numpy as np
```
```
import cv2
```
```
 
```
```
img = np.array([
```

    [[255, 0, 0], [0, 255, 0], [0, 0, 255]],

    [[255, 255, 0], [255, 0, 255], [0, 255, 255]],

    [[255, 255, 255], [128, 128, 128], [0, 0, 0]],

```
], dtype=np.uint8)
```
```
 
```
```
plt.imsave('img_pyplot.png', img)
```
```
cv2.imwrite('img_cv2.jpg', img)
```

QT + OpenCV Example

Posted on December 30, 2018 by admin

Source

```
#include <QCoreApplication>
```
```
 
```
```
#include <opencv2/opencv.hpp>
```
```
 
```
```
int main(int argc, char *argv[])
```
```
{
```
```
    //QCoreApplication a(argc, argv);
```
```
 
```
```
    using namespace cv;
```

    Mat image = imread("/Users/water/Downloads/Share.jpg");

```
    imshow("Output", image);
```
```
 
```
```
    waitKey(1000);
```
```
 
```
```
    return 0;
```
```
 
```
```
    //return a.exec();
```
```
}
```

pro

```
QT -= gui
```
```
 
```
```
CONFIG += c++11 console
```
```
CONFIG -= app_bundle
```
```
 
```

# The following define makes your compiler emit warnings if you use

# any Qt feature that has been marked deprecated (the exact warnings

# depend on your compiler). Please consult the documentation of the

# deprecated API in order to know how to port your code away from it.

```
DEFINES += QT_DEPRECATED_WARNINGS
```
```
 
```

# You can also make your code fail to compile if it uses deprecated APIs.

# In order to do so, uncomment the following line.

# You can also select to disable deprecated APIs only up to a certain version of Qt.

#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

```
 
```
```
SOURCES += \
```
```
        main.cpp
```
```
 
```
```
# Default rules for deployment.
```
```
qnx: target.path = /tmp/$${TARGET}/bin
```

else: unix:!android: target.path = /opt/$${TARGET}/bin

!isEmpty(target.path): INSTALLS += target

```
 
```
```
INCLUDEPATH += /usr/local/include
```

INCLUDEPATH += /usr/local/include/opencv

INCLUDEPATH += /usr/local/include/opencv2

```
LIBS += -L/usr/local/lib \
```
```
 -lopencv_core \
```
```
 -lopencv_highgui \
```
```
 -lopencv_imgproc \
```
```
  -lopencv_imgcodecs \
```

OpenCV3 On ARM

Posted on May 3, 2018 by admin

Source Code Dir

CMake-GUI Configure

Configure/Generate

Unix Makefiles
Specify options for cross-compiling

Choose ARM – LINUX

Operating System : arm-linux
C Compilers :
C++ Compilers :
Target Root : The Cross Compiler BIN Directory

CMAKE_INSTALL_PREFIX

make & make install

```
make
```
```
make install
```

Maybe Need It !

The END

```
tar jcvf opencv-arm.tar.bz2 opencv-arm/
```

Lucas-Kanade & Farneback

Posted on May 3, 2018 by admin

LucasKanade Tracker

        // Check if there are points to track

```
        if(!trackingPoints[0].empty())
```
```
        {
```

            // Status vector to indicate whether the flow for the corresponding features has been found

```
            vector<uchar> statusVector;
```
```
 
```

            // Error vector to indicate the error for the corresponding feature

```
            vector<float> errorVector;
```
```
 
```

            // Check if previous image is empty

```
            if(prevGrayImage.empty())
```
```
            {
```

                curGrayImage.copyTo(prevGrayImage);

```
            }
```
```
 
```

            // Calculate the optical flow using Lucas-Kanade algorithm

            calcOpticalFlowPyrLK(prevGrayImage, curGrayImage, trackingPoints[0], trackingPoints[1], statusVector, errorVector, windowSize, 3, terminationCriteria, 0, 0.001);

```
 
```
```
            int count = 0;
```
```
 
```

            // Minimum distance between any two tracking points

```
            int minDist = 7;
```
```
 
```

            for(int i=0; i < trackingPoints[1].size(); i++)

```
            {
```
```
                if(pointTrackingFlag)
```
```
                {
```

                    // If the new point is within 'minDist' distance from an existing point, it will not be tracked

                    if(norm(currentPoint - trackingPoints[1][i]) <= minDist)

```
                    {
```

                        pointTrackingFlag = false;

```
                        continue;
```
```
                    }
```
```
                }
```
```
 
```

                // Check if the status vector is good

```
                if(!statusVector[i])
```
```
                    continue;
```
```
 
```

                trackingPoints[1][count++] = trackingPoints[1][i];

```
 
```

                // Draw a filled circle for each of the tracking points

```
                int radius = 8;
```
```
                int thickness = 2;
```
```
                int lineType = 8;
```

                circle(image, trackingPoints[1][i], radius, Scalar(0,255,0), thickness, lineType);

```
            }
```
```
 
```

            trackingPoints[1].resize(count);

```
        }
```
```
 
```

        // Refining the location of the feature points

        if(pointTrackingFlag && trackingPoints[1].size() < maxNumPoints)

```
        {
```
```
            vector<Point2f> tempPoints;
```

            tempPoints.push_back(currentPoint);

```
 
```

            // Function to refine the location of the corners to subpixel accuracy.

            // Here, 'pixel' refers to the image patch of size 'windowSize' and not the actual image pixel

            cornerSubPix(curGrayImage, tempPoints, windowSize, cvSize(-1,-1), terminationCriteria);

```
 
```

            trackingPoints[1].push_back(tempPoints[0]);

```
            pointTrackingFlag = false;
```
```
        }
```

Farneback Tracker

```
        // Check if the image is valid
```
```
        if(prevGray.data)
```
```
        {
```

            // Initialize parameters for the optical flow algorithm

```
            float pyrScale = 0.5;
```
```
            int numLevels = 3;
```
```
            int windowSize = 15;
```
```
            int numIterations = 3;
```
```
            int neighborhoodSize = 5;
```
```
            float stdDeviation = 1.2;
```
```
 
```

            // Calculate optical flow map using Farneback algorithm

            calcOpticalFlowFarneback(prevGray, curGray, flowImage, pyrScale, numLevels, windowSize, numIterations, neighborhoodSize, stdDeviation, OPTFLOW_USE_INITIAL_FLOW);

```
 
```
```
            // Convert to 3-channel RGB
```

            cvtColor(prevGray, flowImageGray, COLOR_GRAY2BGR);

```
 
```

            // Draw the optical flow map

            drawOpticalFlow(flowImage, flowImageGray);

```
 
```
```
            // Display the output image
```

            imshow(windowName, flowImageGray);

```
        }
```

Other Morphological Operators

Posted on May 3, 2018 by admin

Opening

Mat performOpening(Mat inputImage, int morphologyElement, int morphologySize)

```
{
```
```
    Mat outputImage, tempImage;
```
```
    int morphologyType;
```
```
 
```
```
    if(morphologyElement == 0)
```
```
        morphologyType = MORPH_RECT;
```
```
 
```
```
    else if(morphologyElement == 1)
```
```
        morphologyType = MORPH_CROSS;
```
```
 
```
```
    else if(morphologyElement == 2)
```
```
        morphologyType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(morphologyType, Size(2*morphologySize + 1, 2*morphologySize + 1), Point(morphologySize, morphologySize));

```
 
```

    // Apply morphological opening to the image using the structuring element

    erode(inputImage, tempImage, element);

    dilate(tempImage, outputImage, element);

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

Closing

Mat performClosing(Mat inputImage, int morphologyElement, int morphologySize)

```
{
```
```
    Mat outputImage, tempImage;
```
```
    int morphologyType;
```
```
 
```
```
    if(morphologyElement == 0)
```
```
        morphologyType = MORPH_RECT;
```
```
 
```
```
    else if(morphologyElement == 1)
```
```
        morphologyType = MORPH_CROSS;
```
```
 
```
```
    else if(morphologyElement == 2)
```
```
        morphologyType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(morphologyType, Size(2*morphologySize + 1, 2*morphologySize + 1), Point(morphologySize, morphologySize));

```
 
```

    // Apply morphological opening to the image using the structuring element

    dilate(inputImage, tempImage, element);

    erode(tempImage, outputImage, element);

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

Morphological Gradient

Mat performMorphologicalGradient(Mat inputImage, int morphologyElement, int morphologySize)

```
{
```

    Mat outputImage, tempImage1, tempImage2;

```
    int morphologyType;
```
```
 
```
```
    if(morphologyElement == 0)
```
```
        morphologyType = MORPH_RECT;
```
```
 
```
```
    else if(morphologyElement == 1)
```
```
        morphologyType = MORPH_CROSS;
```
```
 
```
```
    else if(morphologyElement == 2)
```
```
        morphologyType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(morphologyType, Size(2*morphologySize + 1, 2*morphologySize + 1), Point(morphologySize, morphologySize));

```
 
```

    // Apply morphological gradient to the image using the structuring element

    dilate(inputImage, tempImage1, element);

    erode(inputImage, tempImage2, element);

```
 
```
```
    // Return the output image
```
```
    return tempImage1 - tempImage2;
```
```
}
```

TopHat

Mat performTopHat(Mat inputImage, int morphologyElement, int morphologySize)

```
{
```
```
    Mat outputImage;
```
```
    int morphologyType;
```
```
 
```
```
    if(morphologyElement == 0)
```
```
        morphologyType = MORPH_RECT;
```
```
 
```
```
    else if(morphologyElement == 1)
```
```
        morphologyType = MORPH_CROSS;
```
```
 
```
```
    else if(morphologyElement == 2)
```
```
        morphologyType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(morphologyType, Size(2*morphologySize + 1, 2*morphologySize + 1), Point(morphologySize, morphologySize));

```
 
```

    // Apply top hat operation to the image using the structuring element

    outputImage = inputImage - performOpening(inputImage, morphologyElement, morphologySize);

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

BlackHat

Mat performBlackHat(Mat inputImage, int morphologyElement, int morphologySize)

```
{
```
```
    Mat outputImage;
```
```
    int morphologyType;
```
```
 
```
```
    if(morphologyElement == 0)
```
```
        morphologyType = MORPH_RECT;
```
```
 
```
```
    else if(morphologyElement == 1)
```
```
        morphologyType = MORPH_CROSS;
```
```
 
```
```
    else if(morphologyElement == 2)
```
```
        morphologyType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(morphologyType, Size(2*morphologySize + 1, 2*morphologySize + 1), Point(morphologySize, morphologySize));

```
 
```

    // Apply black hat operation to the image using the structuring element

    outputImage = performClosing(inputImage, morphologyElement, morphologySize) - inputImage;

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

Slimming/Thickening The Shapes

Posted on May 3, 2018 by admin

Erosion

Mat performErosion(Mat inputImage, int erosionElement, int erosionSize)

```
{
```
```
    Mat outputImage;
```
```
    int erosionType;
```
```
 
```
```
    if(erosionElement == 0)
```
```
        erosionType = MORPH_RECT;
```
```
 
```
```
    else if(erosionElement == 1)
```
```
        erosionType = MORPH_CROSS;
```
```
 
```
```
    else if(erosionElement == 2)
```
```
        erosionType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for erosion

    Mat element = getStructuringElement(erosionType, Size(2*erosionSize + 1, 2*erosionSize + 1), Point(erosionSize, erosionSize));

```
 
```

    // Erode the image using the structuring element

    erode(inputImage, outputImage, element);

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

Dilation

Mat performDilation(Mat inputImage, int dilationElement, int dilationSize)

```
{
```
```
    Mat outputImage;
```
```
    int dilationType;
```
```
 
```
```
    if(dilationElement == 0)
```
```
        dilationType = MORPH_RECT;
```
```
 
```
```
    else if(dilationElement == 1)
```
```
        dilationType = MORPH_CROSS;
```
```
 
```
```
    else if(dilationElement == 2)
```
```
        dilationType = MORPH_ELLIPSE;
```
```
 
```

    // Create the structuring element for dilation

    Mat element = getStructuringElement(dilationType, Size(2*dilationSize + 1, 2*dilationSize + 1), Point(dilationSize, dilationSize));

```
 
```

    // Dilate the image using the structuring element

    dilate(inputImage, outputImage, element);

```
 
```
```
    // Return the output image
```
```
    return outputImage;
```
```
}
```

Background Subtraction VS Frame Differencing

Posted on May 3, 2018 by admin

Background Subtraction

    // Create MOG Background Subtractor object

    pMOG= cv::bgsegm::createBackgroundSubtractorMOG();//new BackgroundSubtractorMOG();

```
 
```

    // Create MOG2 Background Subtractor object

    pMOG2 = createBackgroundSubtractorMOG2(20, 16, true);//new BackgroundSubtractorMOG2();

```
 
```
```
        // Capture the current frame
```
```
        cap >> frame;
```
```
 
```
```
        // Resize the frame
```

        resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

```
 
```

        // Update the MOG background model based on the current frame

```
        pMOG->apply(frame, fgMaskMOG);
```
```
 
```

        // Update the MOG2 background model based on the current frame

        pMOG2->apply(frame, fgMaskMOG2);

```
 
```
```
        // Show the current frame
```
```
        //imshow("Frame", frame);
```
```
 
```
```
        // Show the MOG foreground mask
```

        //imshow("FG Mask MOG", fgMaskMOG);

```
 
```

        // Show the MOG2 foreground mask

        imshow("FG Mask MOG 2", fgMaskMOG2);

Frame Differencing

Mat frameDiff(Mat prevFrame, Mat curFrame, Mat nextFrame)

```
{
```

    Mat diffFrames1, diffFrames2, output;

```
 
```

    // Compute absolute difference between current frame and the next frame

    absdiff(nextFrame, curFrame, diffFrames1);

```
 
```

    // Compute absolute difference between current frame and the previous frame

    absdiff(curFrame, prevFrame, diffFrames2);

```
 
```

    // Bitwise "AND" operation between the above two diff images

    bitwise_and(diffFrames1, diffFrames2, output);

```
 
```
```
    return output;
```
```
}
```

Tracking Your Ears

Posted on May 3, 2018 by admin

Tracking Your Ears (Two Ears, \(^o^)/~)

```
        // Capture the current frame
```
```
        cap >> frame;
```
```
 
```
```
        // Resize the frame
```

        resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

```
 
```
```
        // Convert to grayscale
```

        cvtColor(frame, frameGray, CV_BGR2GRAY);

```
 
```
```
        // Equalize the histogram
```

        equalizeHist(frameGray, frameGray);

```
 
```
```
        // Detect left ear
```

        leftEarCascade.detectMultiScale(frameGray, leftEars, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );

```
 
```
```
        // Detect right ear
```

        rightEarCascade.detectMultiScale(frameGray, rightEars, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );

```
 
```

        // Draw green rectangle around the left ear

        for(int i = 0; i < leftEars.size(); i++)

```
        {
```

            Rect leftEarRect(leftEars[i].x, leftEars[i].y, leftEars[i].width, leftEars[i].height);

            rectangle(frame, leftEarRect, Scalar(0,255,0), 4);

```
        }
```
```
 
```

        // Draw green rectangle around the right ear

        for(int i = 0; i < rightEars.size(); i++)

```
        {
```

            Rect rightEarRect(rightEars[i].x, rightEars[i].y, rightEars[i].width, rightEars[i].height);

            rectangle(frame, rightEarRect, Scalar(0,255,0), 4);

```
        }
```

Overlaying A Facemask

Posted on May 3, 2018 by admin

Detect Faces

```
        // Capture the current frame
```
```
        cap >> frame;
```
```
 
```
```
        // Resize the frame
```

        resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA);

```
 
```
```
        // Convert to grayscale
```

        cvtColor(frame, frameGray, CV_BGR2GRAY);

```
 
```
```
        // Equalize the histogram
```

        equalizeHist(frameGray, frameGray);

```
 
```
```
        // Detect faces
```

        faceCascade.detectMultiScale(frameGray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );

Add Mask Image

        // Draw green rectangle around the face

        for(int i = 0; i < faces.size(); i++)

```
        {
```

            //Rect faceRect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);

```
 
```

            // Custom parameters to make the mask fit your face. You may have to play around with them to make sure it works.

            int x = faces[i].x - int(0.1*faces[i].width);

            int y = faces[i].y - int(0.1*faces[i].height); // 0.0*faces[i].height

            int w = int(1.1 * faces[i].width);

            int h = int(1.3 * faces[i].height);

```
 
```

            // Extract region of interest (ROI) covering your face

            frameROI = frame(Rect(x,y,w,h));

```
 
```

            // Resize the face mask image based on the dimensions of the above ROI

            resize(faceMask, faceMaskSmall, Size(w,h));

```
 
```

            // Convert the above image to grayscale

            cvtColor(faceMaskSmall, grayMaskSmall, CV_BGR2GRAY);

```
 
```

            // Threshold the above image to isolate the pixels associated only with the face mask

            threshold(grayMaskSmall, grayMaskSmallThresh, 230, 255, CV_THRESH_BINARY_INV);

```
 
```

            // Create mask by inverting the above image (because we don't want the background to affect the overlay)

            bitwise_not(grayMaskSmallThresh, grayMaskSmallThreshInv);

```
 
```

            // Use bitwise "AND" operator to extract precise boundary of face mask

            bitwise_and(faceMaskSmall, faceMaskSmall, maskedFace, grayMaskSmallThresh);

```
 
```

            // Use bitwise "AND" operator to overlay face mask

            bitwise_and(frameROI, frameROI, maskedFrame, grayMaskSmallThreshInv);

```
 
```

            // Add the above masked images and place it in the original frame ROI to create the final image

            add(maskedFace, maskedFrame, frame(Rect(x,y,w,h)));

```
        }
```