Merge pull request #322 from tritonuas/feat/compression

Compression Algorithm with denoising.

Author: 2q46

include/cv/utilities.hpp

@@ -1,6 +1,8 @@
 #ifndef INCLUDE_CV_UTILITIES_HPP_
 #define INCLUDE_CV_UTILITIES_HPP_
 
+#include <optional>
+#include <vector>
 #include <opencv2/opencv.hpp>
 
 #include "protos/obc.pb.h"
@@ -27,4 +29,16 @@ struct DetectedTarget {
 // Helper function to crop out a bounding box from an image if you still need it
 cv::Mat crop(const cv::Mat& original, const Bbox& bbox);
 
+/**
+ * Denoises and compresses a JPEG image to a desired quality.
+ * 
+ * @param img       : a const reference to the image you want to compress
+ * @param quality   : the quality you want to compress to. A quality of about 60
+ *                    compresses an image about half size.
+ * 
+ * @return          : std::nullopt if the compression fails. 
+ *                    cv::Mat otherwise
+ */
+std::optional<cv::Mat> compressImg(const cv::Mat& img, int quality = 60);
+
 #endif  // INCLUDE_CV_UTILITIES_HPP_

src/cv/utilities.cpp

@@ -1,4 +1,5 @@
 #include "cv/utilities.hpp"
+#include "utilities/logging.hpp"
 
 int Bbox::width() const { return x2 - x1; }
 
@@ -10,3 +11,25 @@ cv::Mat crop(const cv::Mat& original, const Bbox& bbox) {
     auto x = cv::Mat(original.clone(), cv::Rect(bbox.x1, bbox.y1, bbox.width(), bbox.height()));
     return x;
 }
+
+std::optional<cv::Mat> compressImg(const cv::Mat& img, int quality) {
+    std::vector<int> compressionParams {cv::IMWRITE_JPEG_QUALITY, quality};
+    std::vector<uchar> buffer;
+    cv::Mat denoisedImg;
+
+    cv::fastNlMeansDenoisingColored(img, denoisedImg);
+
+    if (!cv::imencode(".jpg", denoisedImg, buffer, compressionParams)) {
+        LOG_F(WARNING, "Unable to encode the image into a buffer. Using the orignal instead");
+        return std::nullopt;
+    }
+
+    cv::Mat decodedImg = cv::imdecode(buffer, cv::IMREAD_COLOR);
+
+    if (decodedImg.empty()) {
+        LOG_F(WARNING, "Unable to decoode the image from a buffer. Using the orignal instead");
+        return std::nullopt;
+    }
+
+    return std::make_optional(decodedImg);
+}

src/network/gcs_routes.cpp

@@ -24,6 +24,7 @@
 #include "utilities/http.hpp"
 #include "utilities/logging.hpp"
 #include "utilities/serialize.hpp"
+#include "cv/utilities.hpp"
 
 extern "C" {
 #include "udp_squared/protocol.h"
@@ -251,39 +252,11 @@ DEF_GCS_HANDLE(Get, camera, capture) {
     }
 
     std::optional<ImageTelemetry> telemetry = image->TELEMETRY;
-
-    // START COMPRESSION
-    // Compress the image before converting to base64
-    std::vector<uchar> compressed_data;
-    std::vector<int> compression_params;
-    compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
-    compression_params.push_back(85);  // Quality: 0-100, 85 is a good balance for transmission
-
-    cv::Mat compressed_image;
-    if (cv::imencode(".jpg", image->DATA, compressed_data, compression_params)) {
-        // Create compressed Mat from encoded data
-        compressed_image = cv::imdecode(compressed_data, cv::IMREAD_COLOR);
-
-        if (!compressed_image.empty()) {
-                LOG_F(INFO,
-                  "Compressed manual capture image from %zu bytes to %zu bytes "
-                  "(%.1f%% compression)",
-                  image->DATA.total() * image->DATA.elemSize(), compressed_data.size(),
-                  (1.0 - static_cast<double>(compressed_data.size()) /
-                             (image->DATA.total() * image->DATA.elemSize())) *
-                      100.0);
-        } else {
-            LOG_F(WARNING, "Failed to decode compressed manual capture image, using original");
-            compressed_image = image->DATA;
-        }
-    } else {
-        LOG_F(WARNING, "Failed to compress manual capture image, using original");
-        compressed_image = image->DATA;
-    }
-
+    std::optional<cv::Mat> optCompressedImg = compressImg(image->DATA);
+    cv::Mat compressed_image = optCompressedImg.has_value() ?
+    optCompressedImg->clone() : image->DATA;
     ManualImage manual_image;
     manual_image.set_img_b64(cvMatToBase64(compressed_image));
-    // END COMPRESSION
 
     manual_image.set_timestamp(image->TIMESTAMP);
     if (telemetry.has_value()) {
@@ -379,40 +352,12 @@ DEF_GCS_HANDLE(Get, targets, all) {
         IdentifiedTarget target;
         // Set the run ID
         target.set_run_id(run.run_id);
-        // START COMPRESSION
-
-        // Compress the annotated image before converting to base64
-        std::vector<uchar> compressed_data;
-        std::vector<int> compression_params;
-        compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
-        compression_params.push_back(85);
-        // Quality: 0-100, 85 is a good balance for transmission
-
-        cv::Mat compressed_image;
-        if (cv::imencode(".jpg", run.annotatedImage, compressed_data, compression_params)) {
-            // Create compressed Mat from encoded data
-            compressed_image = cv::imdecode(compressed_data, cv::IMREAD_COLOR);
-
-            if (!compressed_image.empty()) {
-                LOG_F(INFO, "Compressed image from %zu bytes to %zu bytes (%.1f%% compression)",
-                      run.annotatedImage.total() * run.annotatedImage.elemSize(),
-                      compressed_data.size(),
-                      (1.0 - static_cast<double>(compressed_data.size()) /
-                                 (run.annotatedImage.total() * run.annotatedImage.elemSize())) *
-                          100.0);
-            } else {
-                LOG_F(WARNING, "Failed to decode compressed image, using original");
-                compressed_image = run.annotatedImage;
-            }
-        } else {
-            LOG_F(WARNING, "Failed to compress image, using original");
-            compressed_image = run.annotatedImage;
-        }
 
-        // Convert the compressed image to base64 and set it (once per run)
+        std::optional<cv::Mat> optCompressedImg = compressImg(run.annotatedImage);
+        cv::Mat compressed_image = optCompressedImg.has_value() ?
+        optCompressedImg->clone() : run.annotatedImage;
         std::string b64 = cvMatToBase64(compressed_image);
         target.set_picture(b64);
-        // END COMPRESSION
 
         // Ensure coords and bboxes vectors are the same size (should be guaranteed by Aggregator
         // logic)