detect autolabel to labelme

.vscode/launch.json

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(Windows) Launch",
+            "type": "cppvsdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/Debug/autolabel.exe",
+            "args": ["I:/datas/yolov8n.engine", "I:/workspace/yolov8/ultralytics/assets"],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "console": "internalConsole"
+        }
+
+    ]
+}
\ No newline at end of file

.vscode/tasks.json

+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++.exe build active file",
+            "command": "D:\\Qt\\Tools\\mingw810_64\\bin\\g++.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}
\ No newline at end of file

include/base64.h

+//
+//  base64 encoding and decoding with C++.
+//  Version: 2.rc.09 (release candidate)
+//
+
+#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+
+#include <string>
+
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif  // __cplusplus >= 201703L
+
+std::string base64_encode     (std::string const& s, bool url = false);
+std::string base64_encode_pem (std::string const& s);
+std::string base64_encode_mime(std::string const& s);
+
+std::string base64_decode(std::string const& s, bool remove_linebreaks = false);
+std::string base64_encode(unsigned char const*, size_t len, bool url = false);
+
+#if __cplusplus >= 201703L
+//
+// Interface with std::string_view rather than const std::string&
+// Requires C++17
+// Provided by Yannic Bonenberger (https://github.com/Yannic)
+//
+std::string base64_encode     (std::string_view s, bool url = false);
+std::string base64_encode_pem (std::string_view s);
+std::string base64_encode_mime(std::string_view s);
+
+std::string base64_decode(std::string_view s, bool remove_linebreaks = false);
+#endif  // __cplusplus >= 201703L
+
+#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

include/labelmeJson.h

@@ -3,16 +3,20 @@
 #include <vector>
 #include "json.hpp"
 #include <fstream>
-using json = nlohmann::json;
+// using json = nlohmann::json;
+using json = nlohmann::ordered_json;
 using std::string;
 using std::vector;
-json j_null(json::value_t::null);
-json j_boolean(json::value_t::boolean);
-json j_number_integer(json::value_t::number_integer);
-json j_number_float(json::value_t::number_float);
-json j_object(json::value_t::object);
-json j_array(json::value_t::array);
-json j_string(json::value_t::string);
+
+
+const static json j_null(json::value_t::null);
+const static json j_boolean(json::value_t::boolean);
+const static json j_number_integer(json::value_t::number_integer);
+const static json j_number_float(json::value_t::number_float);
+const static json j_object(json::value_t::object);
+const static json j_array(json::value_t::array);
+const static json j_string(json::value_t::string);
+
 // create JSON objects
 // json j_no_init_list = json::object();
 // json j_empty_init_list = json::object({});
@@ -98,33 +102,71 @@ json j_string(json::value_t::string);
 */
 
 
+struct shape{
+    std::string label = j_string;
+    vector<vector<double>> points;
+    std::string type = "rectangle";
+    json group_id = j_null;
+    json context = j_object;
+    json description = j_string;
+    json flags = j_object;
+    shape(string _label, vector<vector<double>>& _points) : label(_label), points(_points){
+        // json o = j_object;
+    }
+    void setType(string& _type){
+      type = _type;
+    }
+    json compile(){
+      json& o = context;
+      o["label"] = label;
+      o["points"] = points;
+      o["group_id"] = group_id;
+      o["description"] = description;
+      o["shape_type"] = type;
+      o["flags"] = flags;
+      return o;
+    }
+};
 
 class LabelmeJson{
 public:
     LabelmeJson(std::string &_filePath):filePath(_filePath){
         //"version": "5.3.1",
-        context["version"] = "5.3.1";
-        //"flags": {},
-        context["flags"] = j_object;
     }
 
     ~LabelmeJson(){
         std::ofstream o(filePath);
         o << std::setw(4) << context << std::endl;
     }
-    struct shape{
-        shape(string& _label, vector<vector<double>>& _points, string _type="rectangle") : label(_label), points(_points),type(_type){
-            json o = j_object;
-
-        }
-        std::string label = j_string;
-        std::vector<vector<double>> points;
-        std::string type = j_string;
 
+    json compile(){
+      context["version"] = version;
+      context["flags"] = flags;
+      context["shapes"] = shapes;
+      context["imagePath"] = imagePath;
+      context["imageData"] = imageData;
+      context["imageHeight"] = imageHeight;
+      context["imageWidth"] = imageWidth;
+      return context;
+    }
 
-    };
     void addShape(shape& _shp){
-
+      shapes.emplace_back(_shp.context);
+    }
+    void addShape(json& _shp){
+      shapes.emplace_back(_shp);
+    }
+    void setImagePath(string & imgPath){
+      imagePath = imgPath;
+    }
+    void setImageData(string& imgData){
+      imageData = imgData;
+    }
+    void setImageHeight(int h){
+      imageHeight = h;
+    }
+    void setImageWidth(int w){
+      imageWidth = w;
     }
 private:
 
@@ -161,6 +203,13 @@ private:
     //     }
     // }
     std::string filePath;
+    string version = "5.3.1";
+    json flags = j_object;
+    json shapes = j_array;
+    json imagePath = j_string;
+    json imageData = j_string; //"image base64code"
+    int imageHeight = 480;
+    int imageWidth = 640;
     json context;
 
 };

src/base64.cpp

+/*
+   base64.cpp and base64.h
+
+   base64 encoding and decoding with C++.
+   More information at
+     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
+
+   Version: 2.rc.09 (release candidate)
+
+   Copyright (C) 2004-2017, 2020-2022 René Nyffenegger
+
+   This source code is provided 'as-is', without any express or implied
+   warranty. In no event will the author be held liable for any damages
+   arising from the use of this software.
+
+   Permission is granted to anyone to use this software for any purpose,
+   including commercial applications, and to alter it and redistribute it
+   freely, subject to the following restrictions:
+
+   1. The origin of this source code must not be misrepresented; you must not
+      claim that you wrote the original source code. If you use this source code
+      in a product, an acknowledgment in the product documentation would be
+      appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+      misrepresented as being the original source code.
+
+   3. This notice may not be removed or altered from any source distribution.
+
+   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+*/
+// std::string encoded = base64_encode(reinterpret_cast<const unsigned char*>(orig.c_str()), orig.length());
+#include "base64.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+ //
+ // Depending on the url parameter in base64_chars, one of
+ // two sets of base64 characters needs to be chosen.
+ // They differ in their last two characters.
+ //
+static const char* base64_chars[2] = {
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789"
+             "+/",
+
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789"
+             "-_"};
+
+static unsigned int pos_of_char(const unsigned char chr) {
+ //
+ // Return the position of chr within base64_encode()
+ //
+
+    if      (chr >= 'A' && chr <= 'Z') return chr - 'A';
+    else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A')               + 1;
+    else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
+    else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
+    else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
+    else
+ //
+ // 2020-10-23: Throw std::exception rather than const char*
+ //(Pablo Martin-Gomez, https://github.com/Bouska)
+ //
+    throw std::runtime_error("Input is not valid base64-encoded data.");
+}
+
+static std::string insert_linebreaks(std::string str, size_t distance) {
+ //
+ // Provided by https://github.com/JomaCorpFX, adapted by me.
+ //
+    if (!str.length()) {
+        return "";
+    }
+
+    size_t pos = distance;
+
+    while (pos < str.size()) {
+        str.insert(pos, "\n");
+        pos += distance + 1;
+    }
+
+    return str;
+}
+
+template <typename String, unsigned int line_length>
+static std::string encode_with_line_breaks(String s) {
+  return insert_linebreaks(base64_encode(s, false), line_length);
+}
+
+template <typename String>
+static std::string encode_pem(String s) {
+  return encode_with_line_breaks<String, 64>(s);
+}
+
+template <typename String>
+static std::string encode_mime(String s) {
+  return encode_with_line_breaks<String, 76>(s);
+}
+
+template <typename String>
+static std::string encode(String s, bool url) {
+  return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
+}
+
+std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
+
+    size_t len_encoded = (in_len +2) / 3 * 4;
+
+    unsigned char trailing_char = url ? '.' : '=';
+
+ //
+ // Choose set of base64 characters. They differ
+ // for the last two positions, depending on the url
+ // parameter.
+ // A bool (as is the parameter url) is guaranteed
+ // to evaluate to either 0 or 1 in C++ therefore,
+ // the correct character set is chosen by subscripting
+ // base64_chars with url.
+ //
+    const char* base64_chars_ = base64_chars[url];
+
+    std::string ret;
+    ret.reserve(len_encoded);
+
+    unsigned int pos = 0;
+
+    while (pos < in_len) {
+        ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
+
+        if (pos+1 < in_len) {
+           ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
+
+           if (pos+2 < in_len) {
+              ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
+              ret.push_back(base64_chars_[  bytes_to_encode[pos + 2] & 0x3f]);
+           }
+           else {
+              ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
+              ret.push_back(trailing_char);
+           }
+        }
+        else {
+
+            ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
+            ret.push_back(trailing_char);
+            ret.push_back(trailing_char);
+        }
+
+        pos += 3;
+    }
+
+
+    return ret;
+}
+
+template <typename String>
+static std::string decode(String const& encoded_string, bool remove_linebreaks) {
+ //
+ // decode(…) is templated so that it can be used with String = const std::string&
+ // or std::string_view (requires at least C++17)
+ //
+
+    if (encoded_string.empty()) return std::string();
+
+    if (remove_linebreaks) {
+
+       std::string copy(encoded_string);
+
+       copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
+
+       return base64_decode(copy, false);
+    }
+
+    size_t length_of_string = encoded_string.length();
+    size_t pos = 0;
+
+ //
+ // The approximate length (bytes) of the decoded string might be one or
+ // two bytes smaller, depending on the amount of trailing equal signs
+ // in the encoded string. This approximation is needed to reserve
+ // enough space in the string to be returned.
+ //
+    size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
+    std::string ret;
+    ret.reserve(approx_length_of_decoded_string);
+
+    while (pos < length_of_string) {
+    //
+    // Iterate over encoded input string in chunks. The size of all
+    // chunks except the last one is 4 bytes.
+    //
+    // The last chunk might be padded with equal signs or dots
+    // in order to make it 4 bytes in size as well, but this
+    // is not required as per RFC 2045.
+    //
+    // All chunks except the last one produce three output bytes.
+    //
+    // The last chunk produces at least one and up to three bytes.
+    //
+
+       size_t pos_of_char_1 = pos_of_char(encoded_string.at(pos+1) );
+
+    //
+    // Emit the first output byte that is produced in each chunk:
+    //
+       ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string.at(pos+0)) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
+
+       if ( ( pos + 2 < length_of_string  )       &&  // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
+              encoded_string.at(pos+2) != '='     &&
+              encoded_string.at(pos+2) != '.'         // accept URL-safe base 64 strings, too, so check for '.' also.
+          )
+       {
+       //
+       // Emit a chunk's second byte (which might not be produced in the last chunk).
+       //
+          unsigned int pos_of_char_2 = pos_of_char(encoded_string.at(pos+2) );
+          ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
+
+          if ( ( pos + 3 < length_of_string )     &&
+                 encoded_string.at(pos+3) != '='  &&
+                 encoded_string.at(pos+3) != '.'
+             )
+          {
+          //
+          // Emit a chunk's third byte (which might not be produced in the last chunk).
+          //
+             ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string.at(pos+3))   ));
+          }
+       }
+
+       pos += 4;
+    }
+
+    return ret;
+}
+
+std::string base64_decode(std::string const& s, bool remove_linebreaks) {
+   return decode(s, remove_linebreaks);
+}
+
+std::string base64_encode(std::string const& s, bool url) {
+   return encode(s, url);
+}
+
+std::string base64_encode_pem (std::string const& s) {
+   return encode_pem(s);
+}
+
+std::string base64_encode_mime(std::string const& s) {
+   return encode_mime(s);
+}
+
+#if __cplusplus >= 201703L
+//
+// Interface with std::string_view rather than const std::string&
+// Requires C++17
+// Provided by Yannic Bonenberger (https://github.com/Yannic)
+//
+
+std::string base64_encode(std::string_view s, bool url) {
+   return encode(s, url);
+}
+
+std::string base64_encode_pem(std::string_view s) {
+   return encode_pem(s);
+}
+
+std::string base64_encode_mime(std::string_view s) {
+   return encode_mime(s);
+}
+
+std::string base64_decode(std::string_view s, bool remove_linebreaks) {
+   return decode(s, remove_linebreaks);
+}
+
+#endif  // __cplusplus >= 201703L

src/detect.cpp

@@ -5,6 +5,12 @@
 #include "opencv2/opencv.hpp"
 #include "yolov8.hpp"
 #include "json.hpp"
+#include "labelmeJson.h"
+#include "base64.h"
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
 using namespace nlohmann;
 const std::vector<std::string> CLASS_NAMES = {
     "person",         "bicycle",    "car",           "motorcycle",    "airplane",     "bus",           "train",
@@ -68,6 +74,7 @@ int main(int argc, char** argv)
     }
     else if (IsFolder(path)) {
         cv::glob(path + "/*.jpg", imagePathList);
+        // cv::glob(path + "/*.png", imagePathList);
     }
 
     cv::Mat  res, image;
@@ -112,8 +119,28 @@ int main(int argc, char** argv)
             auto start = std::chrono::system_clock::now();
             yolov8->infer();
             auto end = std::chrono::system_clock::now();
+            string imgFileName = fs::path(path).filename().string();
+            string labelPath = (fs::path(path).parent_path() / (fs::path(imgFileName).stem().string() + ".json")).string();
+            LabelmeJson labelme(labelPath);
+            labelme.setImagePath(imgFileName);
+            std::vector<uchar> buf;
+            cv::imencode(".jpg", image, buf);
+            auto *enc_msg = reinterpret_cast<unsigned char*>(buf.data());
+            std::string encoded = base64_encode(enc_msg, buf.size());
+            labelme.setImageData(encoded);
+            labelme.setImageHeight(image.size().height);
+            labelme.setImageWidth(image.size().width);
+
             yolov8->postprocess(objs, score_thres, iou_thres, topk, num_labels);
             yolov8->draw_objects(image, res, objs, CLASS_NAMES, COLORS);
+            for(auto& o : objs){
+                vector<vector<double>>points;
+                points.push_back({o.rect.x,o.rect.y});
+                points.push_back({o.rect.x + o.rect.width,o.rect.y + o.rect.height});
+                shape shp(CLASS_NAMES[o.label], points);
+                labelme.addShape(shp.compile());
+            }
+            labelme.compile();
             auto tc = (double)std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.;
             printf("cost %2.4lf ms\n", tc);
             cv::imshow("result", res);