Śledzenie kuli - openCV

int main(int argc, char** argv) {

    // Load input image
    VideoCapture capture = VideoCapture(1);
    cv::Mat bgr_image;

    while (waitKey(20) != 27)  {
        capture >> bgr_image;
        bgr_image.copyTo(orig_image);

        cv::medianBlur(bgr_image, bgr_image, 3);
        // Convert input image to HSV
        cv::Mat hsv_image;
        cv::cvtColor(bgr_image, hsv_image, cv::COLOR_BGR2HSV);

        // Threshold the HSV image, keep only the red pixels
        cv::Mat lower_red_hue_range;
        cv::Mat upper_red_hue_range;
        cv::inRange(hsv_image, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), lower_red_hue_range);
        cv::inRange(hsv_image, cv::Scalar(160, 100, 100), cv::Scalar(179, 255, 255), upper_red_hue_range);

        // Combine the above two images
        cv::Mat red_hue_image;
        cv::addWeighted(lower_red_hue_range, 1.0, upper_red_hue_range, 1.0, 0.0, red_hue_image);

        cv::GaussianBlur(red_hue_image, red_hue_image, cv::Size(9, 9), 2, 2);

        // Use the Hough transform to detect circles in the combined threshold image
        std::vector<cv::Vec3f> circles;
        cv::HoughCircles(red_hue_image, circles, HOUGH_GRADIENT, 1, red_hue_image.rows / 8, 100, 20, 0, 0);

        // Loop over all detected circles and outline them on the original image
        for (size_t current_circle = 0; current_circle < circles.size(); ++current_circle) {
            cv::Point center(std::round(circles[current_circle][0]), std::round(circles[current_circle][1]));
            int radius = std::round(circles[current_circle][2]);

            cv::circle(orig_image, center, radius, cv::Scalar(0, 255, 0), 5);
        }

        // Show images
        cv::namedWindow("Threshold lower image", cv::WINDOW_AUTOSIZE);
        cv::imshow("Threshold lower image", lower_red_hue_range);
        cv::namedWindow("Threshold upper image", cv::WINDOW_AUTOSIZE);
        cv::imshow("Threshold upper image", upper_red_hue_range);
        cv::namedWindow("Combined threshold images", cv::WINDOW_AUTOSIZE);
        cv::imshow("Combined threshold images", red_hue_image);
        cv::namedWindow("Detected red circles on the input image", cv::WINDOW_AUTOSIZE);
        cv::imshow("Detected red circles on the input image", orig_image);
    }
    return 0;
}

int main(int argc, char** argv) {

    // Load input image
    VideoCapture capture = VideoCapture(1);
    cv::Mat bgr_image;
    cv::Mat orig_image;
    cv::Mat hsv_image;
    cv::Mat thresholded;
    std::vector<cv::Vec3f> circles;
    int hueLower = 0, hueUpper = 180, saturationLower = 100, saturationUpper = 255, valueLower = 100, valueUpper = 255;

    string nameThreshold = "Threshold lower image";
    cv::namedWindow(nameThreshold, cv::WINDOW_AUTOSIZE);
    createTrackbar("Hue lower", nameThreshold, &hueLower, 180, NULL);
    createTrackbar("Hue upper", nameThreshold, &hueUpper, 180, NULL);
    createTrackbar("Saturation lower", nameThreshold, &saturationLower, 255, NULL);
    createTrackbar("Saturation upper", nameThreshold, &saturationUpper, 255, NULL);
    createTrackbar("Value lower", nameThreshold, &valueLower, 255, NULL);
    createTrackbar("Value upper", nameThreshold, &valueUpper, 255, NULL);
    cv::namedWindow("Detected red circles on the input image", cv::WINDOW_AUTOSIZE);

    while (waitKey(20) != 27)
    {
        capture >> bgr_image;
        bgr_image.copyTo(orig_image);

        // MedianBlur
        cv::medianBlur(bgr_image, bgr_image, 3);
        // Convert input image to HSV
        cv::cvtColor(bgr_image, hsv_image, cv::COLOR_BGR2HSV);

        // Threshold the HSV image, keep only the red pixels
        cv::inRange(hsv_image, cv::Scalar(hueLower, saturationLower, valueLower),
            cv::Scalar(hueUpper, saturationUpper, valueUpper), thresholded);

        cv::GaussianBlur(thresholded, thresholded, cv::Size(9, 9), 2, 2);

        // Use the Hough transform to detect circles in the combined threshold image
        cv::HoughCircles(thresholded, circles, HOUGH_GRADIENT, 1, thresholded.rows / 8, 100, 20, 0, 0);

        // Loop over all detected circles and outline them on the original image
        for (size_t current_circle = 0; current_circle < circles.size(); ++current_circle) {
            cv::Point center(std::round(circles[current_circle][0]), std::round(circles[current_circle][1]));
            int radius = std::round(circles[current_circle][2]);
            cv::circle(orig_image, center, radius, cv::Scalar(0, 255, 0), 5);
        }

        // Show images
        cv::imshow(nameThreshold, thresholded);
        cv::imshow("Detected red circles on the input image", orig_image);
    }
    return 0;
}

    capture.set(CAP_PROP_FRAME_WIDTH, 640);
    capture.set(CAP_PROP_FRAME_HEIGHT, 480);

#include <opencv2/opencv.hpp>
#include <string>
#include <iostream>

using namespace cv;

class BallTracker {
public:
    BallTracker()
    {
        openCamera();
        setupTrackbars();
    }

    void openCamera()
    {
        capture.setExceptionMode(true);
        capture.open(0);
    }

    void setupTrackbars()
    {
        cv::namedWindow(nameThreshold, cv::WINDOW_AUTOSIZE);
        createTrackbar("Hue lower", nameThreshold, &hueLower, 180);
        createTrackbar("Hue upper", nameThreshold, &hueUpper, 180);
        createTrackbar("Saturation lower", nameThreshold, &saturationLower, 255);
        createTrackbar("Saturation upper", nameThreshold, &saturationUpper, 255);
        createTrackbar("Value lower", nameThreshold, &valueLower, 255);
        createTrackbar("Value upper", nameThreshold, &valueUpper, 255);
        cv::namedWindow(nameCaptureWindow, cv::WINDOW_AUTOSIZE);
    }

    void run()
    {
        while (waitKey(20) != 27) {
            std::vector<cv::Vec3f> circles;
            capture >> orig_image;

            // Convert input image to HSV
            cv::cvtColor(orig_image, hsv_image, cv::COLOR_BGR2HSV);

            // Threshold the HSV image, keep only the red pixels
            cv::inRange(hsv_image, cv::Scalar(hueLower, saturationLower, valueLower),
                cv::Scalar(hueUpper, saturationUpper, valueUpper), thresholded);

            cv::Canny(thresholded, thresholded, 100, 200);

            cv::HoughCircles(thresholded, circles, HOUGH_GRADIENT, 1, thresholded.rows / 8, 100, 20, 5, 200);

            for (size_t current_circle = 0; current_circle < circles.size(); ++current_circle) {
                cv::Point center(std::round(circles[current_circle][0]), std::round(circles[current_circle][1]));
                int radius = std::round(circles[current_circle][2]);
                cv::circle(orig_image, center, radius, detectedCircelColor, 5);
            }

            // Show images
            cv::imshow(nameThreshold, thresholded);
            cv::imshow(nameCaptureWindow, orig_image);
        }
    }

private:
    const String nameThreshold = "Threshold lower image";
    const String nameCaptureWindow = "Detected red circles on the input image";
    const cv::Scalar detectedCircelColor{ 0, 255, 0 };

    VideoCapture capture;
    cv::Mat bgr_image;
    cv::Mat orig_image;
    cv::Mat hsv_image;
    cv::Mat thresholded;

    int hueLower = 0;
    int hueUpper = 8;
    int saturationLower = 150;
    int saturationUpper = 255;
    int valueLower = 100;
    int valueUpper = 255;
};

int main(int argc, char** argv)
{
    try {
        BallTracker tracker;
        tracker.run();
    }
    catch (const std::exception& e) {
        std::cerr << "ERROR! " << e.what() << '\n';
        return 1;
    }

    return 0;
}