February 2018 – Water's Home

Harris Corner Detector & Shi-Tomasi Corner Detector

Posted on February 13, 2018 by admin

Harris Corner

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

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

```
 
```

        dst = Mat::zeros(frame.size(), CV_32FC1);

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

        cvtColor(frame, frameGray, COLOR_BGR2GRAY );

```
 
```
```
        // Detecting corners
```

        cornerHarris(frameGray, dst, blockSize, apertureSize, k, BORDER_DEFAULT);

```
 
```
```
        // Normalizing
```

        normalize(dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat());

        convertScaleAbs(dst_norm, dst_norm_scaled);

```
 
```

        // Drawing a circle around corners

        for(int j = 0; j < dst_norm.rows ; j++)

```
        {
```

            for(int i = 0; i < dst_norm.cols; i++)

```
            {
```

                if((int)dst_norm.at<float>(j,i) > thresh)

```
                {
```

                    circle(frame, Point(i, j), 8,  Scalar(0,255,0), 2, 8, 0);

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

Good Features To Track (Shi-Tomasi)

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

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

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

        cvtColor(frame, frameGray, COLOR_BGR2GRAY );

```
 
```

        // Initialize the parameters for Shi-Tomasi algorithm

```
        vector<Point2f> corners;
```
```
        double qualityThreshold = 0.02;
```
```
        double minDist = 15;
```
```
        int blockSize = 5;
```
```
        bool useHarrisDetector = false;
```
```
        double k = 0.07;
```
```
 
```
```
        // Clone the input frame
```
```
        Mat frameCopy;
```
```
        frameCopy = frame.clone();
```
```
 
```
```
        // Apply corner detection
```

        goodFeaturesToTrack(frameGray, corners, numCorners, qualityThreshold, minDist, Mat(), blockSize, useHarrisDetector, k);

```
 
```

        // Parameters for the circles to display the corners

        int radius = 8;      // radius of the cirles

        int thickness = 2;   // thickness of the circles

```
        int lineType = 8;
```
```
 
```

        // Draw the detected corners using circles

        for(size_t i = 0; i < corners.size(); i++)

```
        {
```

            Scalar color = Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255));

            circle(frameCopy, corners[i], radius, color, thickness, lineType, 0);

```
        }
```

Tracking Specific Color / Tracking Object

Posted on February 13, 2018 by admin

Tracking Specific Color

        // Define the range of "blue" color in HSV colorspace

        Scalar lowerLimit = Scalar(60,100,100);

        Scalar upperLimit = Scalar(180,255,255);

```
 
```

        // Threshold the HSV image to get only blue color

        inRange(hsvImage, lowerLimit, upperLimit, mask);

```
 
```

        // Compute bitwise-AND of input image and mask

        bitwise_and(frame, frame, outputImage, mask=mask);

```
 
```

        // Run median filter on the output to smoothen it

        medianBlur(outputImage, outputImage, 5);

Tracking Object

```
        if(trackingFlag)
```
```
        {
```

            // Check for all the values in 'hsvimage' that are within the specified range

            // and put the result in 'mask'

            inRange(hsvImage, Scalar(0, minSaturation, minValue), Scalar(180, 256, maxValue), mask);

```
 
```

            // Mix the specified channels

```
            int channels[] = {0, 0};
```

            hueImage.create(hsvImage.size(), hsvImage.depth());

            mixChannels(&hsvImage, 1, &hueImage, 1, channels, 1);

```
 
```
```
            if(trackingFlag < 0)
```
```
            {
```

                // Create images based on selected regions of interest

                Mat roi(hueImage, selectedRect), maskroi(mask, selectedRect);

```
 
```

                // Compute the histogram and normalize it

                calcHist(&roi, 1, 0, maskroi, hist, 1, &histSize, &histRanges);

                normalize(hist, hist, 0, 255, CV_MINMAX);

```
 
```

                trackingRect = selectedRect;

```
                trackingFlag = 1;
```
```
            }
```
```
 
```

            // Compute the histogram back projection

            calcBackProject(&hueImage, 1, 0, hist, backproj, &histRanges);

```
            backproj &= mask;
```

            RotatedRect rotatedTrackingRect = CamShift(backproj, trackingRect, TermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1));

```
 
```

            // Check if the area of trackingRect is too small

            if(trackingRect.area() <= 1)

```
            {
```

                // Use an offset value to make sure the trackingRect has a minimum size

                int cols = backproj.cols, rows = backproj.rows;

                int offset = MIN(rows, cols) + 1;

                trackingRect = Rect(trackingRect.x - offset, trackingRect.y - offset, trackingRect.x + offset, trackingRect.y + offset) & Rect(0, 0, cols, rows);

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

            // Draw the ellipse on top of the image

            ellipse(image, rotatedTrackingRect, Scalar(0,255,0), 3, CV_AA);

```
        }
```

Show histogram & Equalize histogram & Lomography effect & Cartoonize effect

Posted on February 12, 2018 by admin

The Original

Show histogram

void showHistoCallback(int state, void* userData)

```
{
```
```
    // Separate image in BRG
```
```
    vector<Mat> bgr;
```
```
    split( img, bgr );
```
```
 
```

    // Create the histogram for 256 bins

```
    // The number of possibles values
```
```
    int numbins= 256;
```
```
 
```
```
    /// Set the ranges ( for B,G,R) )
```
```
    float range[] = { 0, 256 } ;
```
```
    const float* histRange = { range };
```
```
 
```
```
    Mat b_hist, g_hist, r_hist;
```
```
 
```

    calcHist( &bgr[0], 1, 0, Mat(), b_hist, 1, &numbins, &histRange );

    calcHist( &bgr[1], 1, 0, Mat(), g_hist, 1, &numbins, &histRange );

    calcHist( &bgr[2], 1, 0, Mat(), r_hist, 1, &numbins, &histRange );

```
 
```
```
    // Draw the histogram
```

    // We go to draw lines for each channel

```
    int width= 512;
```
```
    int height= 300;
```
```
    // Create image with gray base
```

    Mat histImage( height, width, CV_8UC3, Scalar(20,20,20) );

```
 
```

    // Normalize the histograms to height of image

    normalize(b_hist, b_hist, 0, height, NORM_MINMAX );

    normalize(g_hist, g_hist, 0, height, NORM_MINMAX );

    normalize(r_hist, r_hist, 0, height, NORM_MINMAX );

```
 
```

    int binStep= cvRound((float)width/(float)numbins);

```
    for( int i=1; i< numbins; i++)
```
```
    {
```
```
        line( histImage, 
```

                Point( binStep*(i-1), height-cvRound(b_hist.at<float>(i-1) ) ),

                Point( binStep*(i), height-cvRound(b_hist.at<float>(i) ) ),

```
                Scalar(255,0,0)
```
```
            );
```
```
        line( histImage, 
```

                Point( binStep*(i-1), height-cvRound(g_hist.at<float>(i-1) ) ),

                Point( binStep*(i), height-cvRound(g_hist.at<float>(i) ) ),

```
                Scalar(0,255,0)
```
```
            );
```
```
        line( histImage, 
```

                Point( binStep*(i-1), height-cvRound(r_hist.at<float>(i-1) ) ),

                Point( binStep*(i), height-cvRound(r_hist.at<float>(i) ) ),

```
                Scalar(0,0,255)
```
```
            );
```
```
    }
```
```
 
```
```
    imshow("Histogram", histImage);
```
```
 
```
```
}
```

Equalize histogram

void equalizeCallback(int state, void* userData)

```
{
```
```
    Mat result;
```
```
    // Convert BGR image to YCbCr
```
```
    Mat ycrcb;
```

    cvtColor( img, ycrcb, COLOR_BGR2YCrCb);

```
 
```
```
    // Split image into channels
```
```
    vector<Mat> channels;
```
```
    split( ycrcb, channels );
```
```
 
```
```
    // Equalize the Y channel only
```

    equalizeHist( channels[0], channels[0] );

```
 
```
```
    // Merge the result channels
```
```
    merge( channels, ycrcb );
```
```
 
```
```
    // Convert color ycrcb to BGR
```

    cvtColor( ycrcb, result, COLOR_YCrCb2BGR );

```
 
```
```
    // Show image
```
```
    imshow("Equalized", result);
```
```
}
```

Lomography effect

void lomoCallback(int state, void* userData)

```
{
```
```
    Mat result;
```
```
 
```
```
    const double E = std::exp(1.0);
```

    // Create Lookup table for color curve effect

```
    Mat lut(1, 256, CV_8UC1);
```
```
    for (int i=0; i<256; i++)
```
```
    {
```
```
        float x= (float)i/256.0; 
```

        lut.at<uchar>(i)= cvRound( 256 * (1/(1 + pow(E, -((x-0.5)/0.1)) )) );

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

    // Split the image channels and apply curve transform only to red channel

```
    vector<Mat> bgr;
```
```
    split(img, bgr);
```
```
    LUT(bgr[2], lut, bgr[2]);
```
```
    // merge result
```
```
    merge(bgr, result);
```
```
 
```
```
    // Create image for halo dark
```

    Mat halo( img.rows, img.cols, CV_32FC3, Scalar(0.3,0.3,0.3) );

```
    // Create circle 
```

    circle(halo, Point(img.cols/2, img.rows/2), img.cols/3, Scalar(1,1,1), -1);

    blur(halo, halo, Size(img.cols/3, img.cols/3));

```
 
```

    // Convert the result to float to allow multiply by 1 factor

```
    Mat resultf;
```

    result.convertTo(resultf, CV_32FC3);

```
 
```
```
    // Multiply our result with halo
```
```
    multiply(resultf, halo, resultf);
```
```
 
```
```
    // convert to 8 bits
```
```
    resultf.convertTo(result, CV_8UC3);
```
```
 
```
```
    // show result
```
```
    imshow("Lomograpy", result);
```
```
 
```
```
    // Release mat memory
```
```
    halo.release();
```
```
    resultf.release();
```
```
    lut.release();
```
```
    bgr[0].release();
```
```
    bgr[1].release();
```
```
    bgr[2].release();
```
```
}
```

Cartoonize effect

void cartoonCallback(int state, void* userData)

```
{
```
```
    /** EDGES **/
```

    // Apply median filter to remove possible noise

```
    Mat imgMedian;
```
```
    medianBlur(img, imgMedian, 7);
```
```
 
```
```
    // Detect edges with canny
```
```
    Mat imgCanny;
```

    Canny(imgMedian, imgCanny, 50, 150);

```
 
```
```
    // Dilate the edges
```

    Mat kernel= getStructuringElement(MORPH_RECT, Size(2,2));

```
    dilate(imgCanny, imgCanny, kernel);
```
```
 
```

    // Scale edges values to 1 and invert values

```
    imgCanny= imgCanny/255;
```
```
    imgCanny= 1-imgCanny;
```
```
 
```

    // Use float values to allow multiply between 0 and 1

```
    Mat imgCannyf;
```

    imgCanny.convertTo(imgCannyf, CV_32FC3);

```
 
```

    // Blur the edgest to do smooth effect

    blur(imgCannyf, imgCannyf, Size(5,5));

```
 
```
```
    /** COLOR **/
```

    // Apply bilateral filter to homogenizes color

```
    Mat imgBF;
```

    bilateralFilter(img, imgBF, 9, 150.0, 150.0);

```
 
```
```
    // truncate colors
```
```
    Mat result= imgBF/25;
```
```
    result= result*25;
```
```
 
```
```
    /** MERGES COLOR + EDGES **/
```
```
    // Create a 3 channles for edges
```
```
    Mat imgCanny3c;
```

    Mat cannyChannels[]={ imgCannyf, imgCannyf, imgCannyf};

    merge(cannyChannels, 3, imgCanny3c);

```
 
```
```
    // Convert color result to float 
```
```
    Mat resultf;
```

    result.convertTo(resultf, CV_32FC3);

```
 
```

    // Multiply color and edges matrices

    multiply(resultf, imgCanny3c, resultf);

```
 
```
```
    // convert to 8 bits color
```
```
    resultf.convertTo(result, CV_8UC3);
```
```
 
```
```
    // Show image
```
```
    imshow("Result", result);
```
```
 
```
```
}
```

OpenGL & VTK

Posted on February 12, 2018 by admin

Refer to “OPENCV —> OpenCV 3 on macOS High Sierra —> 2.How to Install OpenCV3 WITH_VTK WITH_OPENGL on macOS High Sierra 10.13.3”

Slider & Mouse & Button(QT_CHECKBOX, QT_RADIOBOX, QT_PUSH_BUTTON)

Posted on February 12, 2018 by admin

Slider

createTrackbar("Lena", "Lena", &blurAmount, 30, onChange, &lena);

```
 
```
```
onChange(blurAmount, &lena);
```
```
 
```

static void onChange(int pos, void* userInput)

```
{
```
```
	if(pos <= 0)
```
```
		return;
```
```
	// Aux variable for result
```
```
	Mat imgBlur;
```
```
 
```
```
	// Get the pointer input image
```
```
	Mat* img= (Mat*)userInput;
```
```
 
```
```
	// Apply a blur filter
```
```
	blur(*img, imgBlur, Size(pos, pos));	
```
```
 
```
```
	// Show the result
```
```
	imshow("Lena", imgBlur);
```
```
}
```

Mouse

setMouseCallback("Lena", onMouse, &lena);

```
 
```

static void onMouse( int event, int x, int y, int, void* userInput )

```
{
```
```
	if( event != EVENT_LBUTTONDOWN )
```
```
	        return;
```
```
 
```
```
	// Get the pointer input image
```
```
	Mat* img= (Mat*)userInput;
```
```
 
```
```
	// Draw circle
```

	circle(*img, Point(x, y), 10, Scalar(0,255,0), 3);

```
 
```
```
	// Call on change to get blurred image
```
```
	onChange(blurAmount, img);
```
```
 
```
```
}
```

Button(QT_CHECKBOX, QT_RADIOBOX, QT_PUSH_BUTTON)

```
 
```

void grayCallback(int state, void* userData)

```
{
```
```
	applyGray= true;
```
```
	applyFilters();
```
```
}
```

void bgrCallback(int state, void* userData)

```
{
```
```
	applyGray= false;
```
```
	applyFilters();
```
```
}
```
```
 
```

void blurCallback(int state, void* userData)

```
{
```
```
	applyBlur= (bool)state;
```
```
	applyFilters();
```
```
}
```
```
 
```

void sobelCallback(int state, void* userData)

```
{
```
```
	applySobel= !applySobel;
```
```
	applyFilters();
```
```
}
```
```
 
```

	createButton("Blur", blurCallback, NULL, QT_CHECKBOX, 0);

```
 
```

	createButton("Gray",grayCallback,NULL,QT_RADIOBOX, 0);

	createButton("RGB",bgrCallback,NULL,QT_RADIOBOX, 1);

```
 
```

	createButton("Sobel",sobelCallback,NULL,QT_PUSH_BUTTON, 0);

OpenCV Simple GUI / QT

Posted on February 12, 2018 by admin

Simple Window

namedWindow("Photo", WINDOW_AUTOSIZE);
 
moveWindow("Photo", 520, 10);
 
imshow("Photo", photo);
 
resizeWindow("Lena", 512, 512);
 
destroyWindow("Photo");
 
destroyAllWindows();//

Qt Functions

displayOverlay("Lena", "Overlay 5secs", 5000);
 
displayStatusBar("Lena", "Status bar 5secs", 5000);
 
saveWindowParameters("Lena");
 
loadWindowParameters("Lena");

OpenCV Data Storage

Posted on February 12, 2018 by admin

Write OpenCV Data

FileStorage fs("test.yml", FileStorage::WRITE);

```
Mat m1= Mat::eye(2,3, CV_32F);
```
```
fs << "m1" << m1;
```
```
fs.release();
```

Read OpenCV Data

FileStorage fs2("test.yml", FileStorage::READ);

```
Mat r;
```
```
fs2["m1"] >> r;
```
```
std::cout << r << std::endl;
```
```
fs2.release();
```

Read/Write Image and Read VideoFile/Camera and Show It

Posted on February 12, 2018 by admin

Read Image

```
Mat color= imread("../lena.jpg");
```
```
Mat gray= imread("../lena.jpg", 0);
```

Write Image

```
imwrite("lenaGray.jpg", gray);
```

Show Image

```
imshow("Lena Gray", gray);
```

Read VideoFile/Camera

```
VideoCapture cap;
```
```
cap.open(videoFile);
```
```
cap.open(0);//default camera
```
```
 
```

if(!cap.isOpened())  // check if succeeded

```
    return -1;
```
```
 
```
```
cap.release();
```

Show VideoFile/Camera

```
namedWindow("Video",1);
```
```
for(;;)
```
```
{
```
```
    Mat frame;
```

    cap >> frame; // get a new frame from camera

```
    imshow("Video", frame);
```
```
    if(waitKey(30) >= 0) break;
```
```
}
```