makeSquare

Author: n-mam

app/qml/screens/CameraSettings.qml

@@ -74,6 +74,7 @@ Item {
                         var path = selectedFile.toString();
                         path = path.replace(/^(file:\/{3})|(qrc:\/{2})|(http:\/{2})/,"");
                         vr.source = path
+                        vr.waitKeyTimeout = 65
                     }
                 }
             }
@@ -89,11 +90,11 @@ Item {
                 TextField {
                     id: timeoutTextId
                     width: 100
+                    text: vr.waitKeyTimeout
                     implicitHeight: rowHeight - 10
                     placeholderText: qsTr("timeout")
-                    text: vr.waitKeyTimeout
-                    horizontalAlignment: TextInput.AlignHCenter
                     verticalAlignment: TextInput.AlignVCenter
+                    horizontalAlignment: TextInput.AlignHCenter
                     onEditingFinished: {
                         vr.waitKeyTimeout = parseInt(timeoutTextId.text)
                     }

cvl/cvl

@@ -87,10 +87,12 @@ struct camera {
         }
         cv::Mat f_in;
         while (!_stop) {
-            _count++;
             cap >> f_in;
+            if (f_in.empty() || f_in.cols <= 0 || f_in.rows <= 0) continue;
+            _count++;
+            auto f_square = cvl::geometry::makeSquare(f_in);
             if ((_count % cc->_skipFrames) == 0) {
-                q_in.enqueue(f_in);
+                q_in.enqueue(f_square);
                 auto f_out = q_out.dequeue();
                 if (!f_out.empty()) {
                     if (_frame_cbk) {

cvl/detector.hpp

@@ -241,7 +241,7 @@ struct BackgroundSubtractor : public Detector {
         cv::Mat fgMask;
         cv::Mat gray, blurred;
         cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
-        cv::GaussianBlur(gray, blurred, cv::Size(5, 5), 0);
+        cv::GaussianBlur(gray, blurred, cv::Size(12, 12), 0);
         pBackgroundSubtractor[cc->_mocapAlgo]->apply(blurred, fgMask, 0.05);
         cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
         cv::morphologyEx(fgMask, fgMask, cv::MORPH_OPEN, kernel);
@@ -275,10 +275,10 @@ struct FaceRecognizer {
             std::cerr << e.what() << std::endl;
         }
         _model = cv::face::LBPHFaceRecognizer::create();
-        _model->setRadius(1);
-        _model->setNeighbors(8);
         _model->setGridX(4);
         _model->setGridY(4);
+        _model->setRadius(1);
+        _model->setNeighbors(8);
         if (_images.size() && _ids.size()) {
             _model->train(_images, _ids);
         }
@@ -298,10 +298,10 @@ struct FaceRecognizer {
 
     auto predict(const cv::Mat& mat, spcc cc) {
         int id = -1;
-        double confidence = 0.0;
         cv::Mat gray;
         cv::cvtColor(mat, gray, cv::COLOR_BGR2GRAY);
         cv::resize(gray, gray, cv::Size(100, 100));
+        double confidence = 0.0;
         _model->predict(gray, id, confidence);
         std::pair<int, double> pair = {-1, 0.0};
         if (confidence <= cc->_facerecConfidence) {

cvl/geometry.hpp

@@ -137,6 +137,22 @@ inline auto computeLaplacianVariance(const cv::Mat& img) {
     return variance;
 }
 
+inline auto makeSquare(const cv::Mat& input, const cv::Scalar& paddingColor = cv::Scalar(0, 0, 0)) {
+    int width = input.cols;
+    int height = input.rows;
+    int maxDim = std::max(width, height);
+    // Create a square black image
+    cv::Mat square = cv::Mat::zeros(cv::Size(maxDim, maxDim), input.type());
+    square.setTo(paddingColor);
+    // Compute top-left corner where the image will be placed
+    int xOffset = (maxDim - width) / 2;
+    int yOffset = (maxDim - height) / 2;
+    // Define ROI and copy input frame into the center
+    cv::Rect roi(xOffset, yOffset, width, height);
+    input.copyTo(square(roi));
+    return square;
+}
+
 }
 }
 #endif