Img_processing: Refactor Distance and Velocity classes

- Removed singleton from Distance class
- Enhanced Velocity to support null values
- Suppressed speed calculations and alerts when insufficient distance data is available

Author: MeravBenLulu

img_processing/include/distance.h

@@ -9,18 +9,13 @@
 class Distance {
    public:
     void findDistance(std::vector<ObjectInformation> &objectInformation);
-    static Distance &getInstance(const cv::Mat &image = cv::Mat());
+    void setFocalLength(const cv::Mat &image);
     void setFocalLength(double focalLength);
     void drawDistance(std::shared_ptr<cv::Mat> image,
                       std::vector<ObjectInformation> &objects);
 
    private:
-    static Distance *instance;
     double focalLength;
-
-    Distance(const cv::Mat &image);
-    Distance(const Distance &) = delete;
-    Distance &operator=(const Distance &) = delete;
     void findFocalLength(const cv::Mat &image);
     void addDistance(float distance, ObjectInformation &obj);
 };

img_processing/include/manager.h

@@ -29,18 +29,22 @@ class Manager {
     Detector detector;
     Velocity velocity;
     DynamicTracker dynamicTracker;
+    Distance distance;
     Alerter alerter;
     int iterationCnt;
     uint32_t destID;
     uint32_t processID;
+    bool isTravel;
 
     // Moves the current image to the prevFrame
     // and clears the memory of the currentFrame;
     void prepareForTheNext();
     int drawOutput();
-    bool isDetect(bool isTravel);
-    bool isResetTracker(bool isTravel);
-    bool isTrack(bool isTravel);
+    bool isDetect();
+    bool isResetTracker();
+    bool isTrack();
+    bool isCalcVelocity();
+
     void sendAlerts(std::vector<std::vector<uint8_t>> &alerts);
     void runOnVideo(std::string videoPath);
     int readIdFromJson(const char *target);

img_processing/include/object_information_struct.h

@@ -3,6 +3,7 @@
 
 #include <opencv2/opencv.hpp>
 #include "object_type_enum.h"
+#include <optional>
 
 #define MAX_PREV_DISTANCES_SIZE 10
 #define MAX_PREV_VELOCITIES_SIZE 2
@@ -15,7 +16,7 @@ struct ObjectInformation {
     std::deque<float> prevDistances;
     float distance;
     std::deque<float> prevVelocities;
-    float velocity;
+    std::optional<float> velocity = std::nullopt;
 };
 
 #endif  // __OBJECT_INFORMATION_STRUCT_H__

img_processing/src/alerter.cpp

@@ -31,7 +31,7 @@ vector<vector<uint8_t>> Alerter::sendAlerts(
         if (isSendAlert(objectInformation)) {
             vector<uint8_t> alertBuffer = makeAlertBuffer(
                 objectInformation.type, objectInformation.distance,
-                objectInformation.velocity);
+                objectInformation.velocity.value());
             alerts.push_back(alertBuffer);
         }
     }

img_processing/src/distance.cpp

@@ -10,28 +10,10 @@
 using namespace std;
 using namespace cv;
 
-Distance *Distance::instance = nullptr;
-
-Distance::Distance(const cv::Mat &image)
+void Distance::setFocalLength(const Mat &image)
 {
     findFocalLength(image);
 }
-
-Distance &Distance::getInstance(const cv::Mat &image)
-{
-    if (!instance) {
-        if (image.empty()) {
-            LogManager::logErrorMessage(ErrorType::IMAGE_ERROR,
-                                        "Could not load image");
-            throw std::runtime_error(
-                "Could not load image. Distance instance creation failed.");
-        }
-        else
-            instance = new Distance(image);
-    }
-    return *instance;
-}
-
 void Distance::setFocalLength(double focalLength)
 {
     this->focalLength = focalLength;

img_processing/src/manager.cpp

@@ -31,7 +31,7 @@ void Manager::init()
         LogManager::logErrorMessage(ErrorType::IMAGE_ERROR, "image not found");
         return;
     }
-    Distance &distance = Distance::getInstance(calibrationImage);
+    distance.setFocalLength(calibrationImage);
     iterationCnt = 1;
     bool isCuda = false;
     detector.init(isCuda);
@@ -67,7 +67,6 @@ void Manager::mainDemo()
             return;
         }
         // intialize focal length
-        Distance &distance = Distance::getInstance();
         distance.setFocalLength(focalLength);
         runOnVideo(videoPath);
     }
@@ -104,21 +103,28 @@ void Manager::runOnVideo(string videoPath)
     }
 }
 
-bool Manager::isDetect(bool isTravel)
+bool Manager::isDetect()
 {
     if (!isTravel || iterationCnt == 1)
         return true;
     return false;
 }
 
-bool Manager::isResetTracker(bool isTravel)
+bool Manager::isResetTracker()
 {
     if (isTravel && iterationCnt == 1)
         return true;
     return false;
 }
 
-bool Manager::isTrack(bool isTravel)
+bool Manager::isTrack()
+{
+    if (isTravel && iterationCnt > 1)
+        return true;
+    return false;
+}
+
+bool Manager::isCalcVelocity()
 {
     if (isTravel && iterationCnt > 1)
         return true;
@@ -127,31 +133,36 @@ bool Manager::isTrack(bool isTravel)
 
 int Manager::processing(const Mat &newFrame, bool isTravel)
 {
-    Distance &distance = Distance::getInstance();
+    this->isTravel = isTravel;
     currentFrame = make_shared<Mat>(newFrame);
-    if (isDetect(isTravel)) {
+    if (isDetect()) {
         // send the frame to detect
         detector.detect(this->currentFrame, isTravel);
         this->currentOutput = detector.getOutput();
     }
 
-    if (isResetTracker(isTravel)) {
+    if (isResetTracker()) {
         // prepare the tracker
         dynamicTracker.startTracking(this->currentFrame, this->currentOutput);
     }
 
-    if (isTrack(isTravel)) {
+    if (isTrack()) {
         // send the frame to track
         dynamicTracker.tracking(this->currentFrame, this->currentOutput);
     }
 
     // add distance to detection objects
     distance.findDistance(this->currentOutput);
-    velocity.returnVelocities(this->currentOutput);
+    if (isCalcVelocity()) {
+        velocity.returnVelocities(this->currentOutput);
+    }
 
     // send allerts to main control
-    vector<vector<uint8_t>> alerts = alerter.sendAlerts(this->currentOutput);
-    sendAlerts(alerts);
+    if (isCalcVelocity()) {
+        vector<vector<uint8_t>> alerts =
+            alerter.sendAlerts(this->currentOutput);
+        sendAlerts(alerts);
+    }
 
     // update of the iterationCnt
     if (isTravel) {
@@ -166,10 +177,10 @@ int Manager::processing(const Mat &newFrame, bool isTravel)
 
 int Manager::drawOutput()
 {
-    Distance &distance = Distance::getInstance();
     dynamicTracker.drawTracking(currentFrame, currentOutput);
     distance.drawDistance(currentFrame, currentOutput);
-    velocity.drawVelocity(currentFrame, currentOutput);
+    if (isCalcVelocity())
+        velocity.drawVelocity(currentFrame, currentOutput);
 
     // Legend
     int legendX = 10, legendY = 10;

img_processing/src/velocity.cpp

@@ -83,28 +83,41 @@ void Velocity::updateVelocity(float newVelocity, ObjectInformation &obj)
     }
 }
 
-void Velocity::drawVelocity(shared_ptr<Mat> image,
-                            vector<ObjectInformation> &objects)
+void Velocity::drawVelocity(std::shared_ptr<Mat> image,
+                            std::vector<ObjectInformation> &objects)
 {
     // Font properties
     int fontFace = FONT_HERSHEY_SIMPLEX;
     double fontScale = 0.6;
     int thickness = 2;
     int baseline = 0;
+
     // Calculate text sizes
     Size velocityTextSize =
         getTextSize("velocity", fontFace, fontScale, thickness, &baseline);
+
     for (auto &obj : objects) {
-        std::stringstream ssVelocity;
-        ssVelocity << std::fixed << std::setprecision(2) << obj.velocity;
+        // Check if velocity has a value
+        if (obj.velocity.has_value()) {
+            std::stringstream ssVelocity;
+            ssVelocity << std::fixed << std::setprecision(2)
+                       << obj.velocity.value();
 
-        Point velocityTextOrg(obj.position.x + 5, obj.position.y - 7);
+            Point velocityTextOrg(obj.position.x + 5, obj.position.y - 7);
 
-        // Draw outline for velocity text
-        putText(*image, ssVelocity.str(), velocityTextOrg, fontFace, fontScale,
-                Scalar(0, 0, 0), thickness + 3);
-        // Write the velocity text
-        putText(*image, ssVelocity.str(), velocityTextOrg, fontFace, fontScale,
-                Scalar(255, 255, 0), thickness);
+            // Draw outline for velocity text
+            putText(*image, ssVelocity.str(), velocityTextOrg, fontFace,
+                    fontScale, Scalar(0, 0, 0), thickness + 3);
+            // Write the velocity text
+            putText(*image, ssVelocity.str(), velocityTextOrg, fontFace,
+                    fontScale, Scalar(255, 255, 0), thickness);
+        }
+        else {
+            // Optional: Handle the case where velocity is not set
+            // For example, you can draw a placeholder or skip drawing.
+            Point velocityTextOrg(obj.position.x + 5, obj.position.y - 7);
+            putText(*image, "N/A", velocityTextOrg, fontFace, fontScale,
+                    Scalar(255, 0, 0), thickness);  // Draw "N/A" in red
+        }
     }
 }

img_processing/tests/test_distance.cpp

@@ -21,8 +21,8 @@ TEST(DistanceTest, DistanceWithCalibration)
         throw runtime_error("Could not open or find the image");
     }
 
-    Distance &distance = Distance::getInstance(calibrationImage);
-
+    Distance distance;
+    distance.setFocalLength(calibrationImage);
     // Load a real image from file
     string imagePath2 = "../tests/images/parking_car.JPG";
     Mat carImage;

img_processing/tests/test_velocity.cpp

@@ -19,9 +19,8 @@ TEST(TVelocity, calculate_TVelocity)
     if (calibrationImage.empty()) {
         throw runtime_error("Could not open or find the image");
     }
-
-    Distance &distance = Distance::getInstance(calibrationImage);
-
+    Distance distance;
+    distance.setFocalLength(calibrationImage);
     Detector detector;
     DynamicTracker tracker;
     Velocity velocity;