Img_processing: implement sun detector

Author: TziporaGoldshmidt

img_processing/CMakeLists.txt

@@ -32,7 +32,7 @@ add_library(CommunicationLib STATIC ../communication/src/communication.cpp ../co
 
 configure_file( ${CMAKE_BINARY_DIR}/config.json COPYONLY)
 # create test executable
-add_executable(runTests tests/main.cpp tests/test_serialize.cpp tests/test_detector.cpp tests/test_dynamic_tracker.cpp tests/test_distance.cpp tests/test_manager.cpp tests/test_velocity.cpp tests/test_lane_detector.cpp)
+add_executable(runTests tests/main.cpp tests/test_serialize.cpp tests/test_detector.cpp tests/test_dynamic_tracker.cpp tests/test_distance.cpp tests/test_manager.cpp tests/test_velocity.cpp tests/test_sun_detector.cpp tests/test_lane_detector.cpp)
 target_link_libraries(runTests ImageProcessingLib ${OpenCV_LIBS} ${GTEST_LIBRARIES} pthread CommunicationLib)
 
 #adding tests

img_processing/include/manager.h

@@ -10,6 +10,7 @@
 #include "log_manager.h"
 #include "velocity.h"
 #include "communication.h"
+#include "sun_detector.h"
 
 class Manager {
    public:
@@ -32,6 +33,7 @@ class Manager {
     Velocity velocity;
     DynamicTracker dynamicTracker;
     Alerter alerter;
+    SunDetector sunDetector;
     LaneDetector laneDetector;
     int longTime;
     int iterationCnt;

img_processing/include/sun_detector.h

@@ -0,0 +1,17 @@
+#ifndef __SUN_DETECTOR_H__
+#define __SUN_DETECTOR_H__
+
+#include <opencv2/opencv.hpp>
+
+class SunDetector {
+   public:
+    void detectSun(const std::shared_ptr<cv::Mat> &frame);
+    void drowSun(std::shared_ptr<cv::Mat> &frame);
+
+   private:
+    cv::Point2f center;
+    float radius;
+    bool isSun;
+};
+
+#endif  // __SUN_DETECTOR_H__

img_processing/src/manager.cpp

@@ -166,7 +166,7 @@ int Manager::processing(const Mat &newFrame, bool isTravel)
     // add distance to detection objects
     distance.findDistance(this->currentOutput);
     velocity.returnVelocities(this->currentOutput);
-
+    sunDetector.detectSun(this->currentFrame);
     // send allerts to main control
     vector<vector<uint8_t>> alerts = alerter.sendAlerts(this->currentOutput);
     sendAlerts(alerts);
@@ -258,6 +258,8 @@ void Manager::drawOutput()
               Point(legendX + 10, legendY + 55), Scalar(255, 0, 0), FILLED);
     putText(*currentFrame, "velocity", Point(legendX + 15, legendY + 50),
             FONT_HERSHEY_SIMPLEX, 0.6, Scalar(255, 255, 255), 1);
+    
+    sunDetector.drowSun(this->currentFrame);
 
 #ifdef LANE_DETECT
     laneDetector.drawLanesOnImage(currentFrame);

img_processing/src/sun_detector.cpp

@@ -0,0 +1,74 @@
+#include "sun_detector.h"
+
+using namespace std;
+using namespace cv;
+
+void SunDetector::detectSun(const std::shared_ptr<cv::Mat> &frame)
+{
+    isSun = false;
+    // Convert the frame to grayscale for easier processing
+    Mat image;
+    cvtColor(*frame, image, COLOR_BGR2GRAY);
+    // Calculate the histogram of the grayscale image
+    Mat histogram;
+    int histSize = 256;
+    float range[] = {0, 256};
+    const float *histRange = {range};
+    calcHist(&image, 1, 0, Mat(), histogram, 1, &histSize, &histRange);
+    // Compute the cumulative distribution function (CDF) from the histogram
+    Mat cdf;
+    histogram.copyTo(cdf);
+    for (int i = 1; i < histSize; i++) {
+        cdf.at<float>(i) += cdf.at<float>(i - 1);
+    }
+    cdf /= cdf.at<float>(histSize - 1);  // Normalize the CDF
+    // Determine a threshold based on the 95th percentile of pixel intensities
+    double minVal, maxVal;
+    minMaxLoc(image, &minVal, &maxVal);  // Find min and max pixel intensities
+    Mat percentileThreshold;
+    threshold(image, percentileThreshold, maxVal * 0.95, 255, THRESH_BINARY);
+    int thresholdArea = cv::countNonZero(percentileThreshold);
+    // Detect contours in the thresholded image (for bright regions)
+    std::vector<std::vector<Point>> contours;
+    findContours(percentileThreshold, contours, RETR_EXTERNAL,
+                 CHAIN_APPROX_SIMPLE);
+    // Find the largest contour in terms of area (which could be the sun)
+    double maxArea = 0;
+    int maxAreaIdx = -1;
+    for (size_t i = 0; i < contours.size(); i++) {
+        double area = contourArea(contours[i]);
+        if (area > maxArea) {
+            maxArea = area;
+            maxAreaIdx = i;
+        }
+    }
+    // If a valid contour was found, proceed with further analysis
+    if (maxAreaIdx != -1) {
+        // Draw a circle around the largest contour to visualize it
+        minEnclosingCircle(contours[maxAreaIdx], center, radius);
+        // Calculate image gradients (Sobel) to analyze the smoothness of the region
+        Mat gradX, gradY;
+        Sobel(image, gradX, CV_32F, 1, 0);  // Gradient in X direction
+        Sobel(image, gradY, CV_32F, 0, 1);  // Gradient in Y direction
+        // Calculate the gradient magnitude (intensity of edges)
+        Mat gradientMag;
+        magnitude(gradX, gradY, gradientMag);  // sqrt(gradX^2 + gradY^2)
+        // Compute the average gradient magnitude in the bright region (contour
+        // area)
+        Scalar meanGradient = mean(gradientMag, percentileThreshold);
+        // If the gradient magnitude is low, the area is likely smooth, like the sun
+        if (meanGradient[0] < 7 &&
+            thresholdArea < 35000)  // Adjust this threshold as needed
+        {
+            isSun = true;
+        }
+    }
+}
+
+void SunDetector::drowSun(std::shared_ptr<cv::Mat> &frame)
+{
+    if (isSun) {
+        // Draw a green circle around the detected sun region
+        circle(*frame, center, static_cast<int>(radius), Scalar(0, 255, 0), 2);
+    }
+}

img_processing/tests/images/sun_in_street.mov

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <opencv2/opencv.hpp>
+#include "sun_detector.h"
+
+using namespace std;
+using namespace cv;
+
+TEST(SunDetectorTest, detectSun)
+{
+    VideoCapture capture("../tests/images/sun_in_street.mov");
+
+    if (!capture.isOpened()) {
+        // LogManager::logErrorMessage(ErrorType::VIDEO_ERROR, "video not found");
+        // throw runtime_error("video not found");
+        cout << "couldn't open video" << endl;
+        return;
+    }
+    Mat img;
+    SunDetector sd;
+    while (1) {
+        capture >> img;
+
+        if (img.empty()) {
+            // LogManager::logInfoMessage(InfoType::MEDIA_FINISH);
+            cout << "media finish" << endl;
+            break;
+        }
+        shared_ptr<Mat> frame = make_shared<Mat>(img);
+        sd.detectSun(frame);
+        sd.drowSun(frame);
+        imshow("sun", *frame);
+        int key = waitKey(1);
+        if (key == 27) {
+            break;
+        }
+    }
+}