OpenCV: Unable to run Canny edge detection in C++

Question

I have written a simple code to perform canny edge detection on a live stream. The code is as shown below,

#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int lowThreshold=0;
int const max_lowThreshold = 100;
int kernel_size = 3;
int ratio = 3;

Mat img;
Mat display;

void CannyThreshold()
{
    cvtColor(img, display, COLOR_RGB2GRAY);

    // GaussianBlur(display,display,Size(7,7),3,3);
    GaussianBlur(display, display, Size(1, 1), 1,1);

    printf("%d\n",lowThreshold);

    Canny(display,display,lowThreshold,3);

    imshow("Canny",display);
}

int main()
{

    VideoCapture cap(0);

    namedWindow("Canny");
    createTrackbar("Min Threshold: ","Canny",&lowThreshold,max_lowThreshold);

    while(1)
    {
        cap.read(img);

        int ret = waitKey(1);

        CannyThreshold();

        if(ret == 'q')
            break;
    }

    cap.release();

    return 0;
}

I get the following run-time error when I run the code. (I'm using OpenCV 4)

error: (-215:Assertion failed) ksize.width > 0 && ksize.width % 2 == 1 && ksize.height > 0 && ksize.height % 2 == 1 in function 'createGaussianKernels'

Any suggestions on how I can solve this error?

Answer 1

The issue is GaussianBlur cant accept kernel size of 1. Correct it to 3x3 or 5x5 in your code as follows

#include <opencv2/core/utility.hpp>
#include "opencv2/video/tracking.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/videoio.hpp"
#include "opencv2/highgui.hpp"

#include <iostream>
#include <ctype.h>

using namespace cv;
using namespace std;

int main(int argc, const char** argv)
{
    VideoCapture cap;
    Mat frame;
    Mat image; // from cap to image
    Mat src_gray;

    Mat dst;
    Mat detected_edges;


    const String window_name = "Canny Edge Detector - VideoCapture";
    int lowThreshold = 10;
    const int max_lowThreshold = 100;
    const int ratio = 3;
    const int kernel_size = 3;

    int FPS;
    int frame_width, frame_height;

    int camNum = 0;
    cap.open(camNum);


    if (!cap.isOpened())
    {

        cout << "***Could not initialize capturing...***\n";
        cout << "Current parameter's value: \n";
        return -1;
    }


    FPS = cap.get(CAP_PROP_FPS);
    frame_width = cap.get(CAP_PROP_FRAME_WIDTH);
    frame_height = cap.get(CAP_PROP_FRAME_HEIGHT);
    dst.create(frame_width, frame_height, CV_8UC3);

    //cout << CV_8UC3;

    while (true)
    {

        cap >> frame;
        if (frame.empty())
            break;


        frame.copyTo(image);

        // Convert the image to grayscale
        cvtColor(image, src_gray, COLOR_BGR2GRAY);

        //![reduce_noise]
        /// Reduce noise with a kernel 3x3
        blur(src_gray, detected_edges, Size(3, 3));
        //![reduce_noise]

        //![canny]
        /// Canny detector
        Canny(detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size);
        //![canny]

        /// Using Canny's output as a mask, we display our result
        //![fill]
        dst = Scalar::all(0);
        //![fill]

        //![copyto]
        image.copyTo(dst, detected_edges);
        //![copyto]


        //![display]
        imshow(window_name, dst);

        if (waitKey(1000 / FPS) >= 0)
            break;

    }




    return 0;
}