label-studio-converter 1.0.0

package/dist/bash-complete.cjs

@@ -0,0 +1,1296 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+var OUTPUT_BASE_DIR, DEFAULT_LABEL_NAME, DEFAULT_LABEL_STUDIO_FULL_JSON, DEFAULT_CREATE_FILE_PER_IMAGE, DEFAULT_CREATE_FILE_LIST_FOR_SERVING, DEFAULT_FILE_LIST_NAME, DEFAULT_BASE_SERVER_URL, DEFAULT_PPOCR_FILE_NAME, SORT_VERTICAL_NONE, SORT_VERTICAL_TOP_BOTTOM, SORT_VERTICAL_BOTTOM_TOP, DEFAULT_SORT_VERTICAL, SORT_HORIZONTAL_NONE, SORT_HORIZONTAL_LTR, SORT_HORIZONTAL_RTL, DEFAULT_SORT_HORIZONTAL;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_cjs_shims();
+    OUTPUT_BASE_DIR = "./output";
+    DEFAULT_LABEL_NAME = "Text";
+    DEFAULT_LABEL_STUDIO_FULL_JSON = true;
+    DEFAULT_CREATE_FILE_PER_IMAGE = false;
+    DEFAULT_CREATE_FILE_LIST_FOR_SERVING = true;
+    DEFAULT_FILE_LIST_NAME = "files.txt";
+    DEFAULT_BASE_SERVER_URL = "http://localhost:8081";
+    DEFAULT_PPOCR_FILE_NAME = "Label.txt";
+    SORT_VERTICAL_NONE = "none";
+    SORT_VERTICAL_TOP_BOTTOM = "top-bottom";
+    SORT_VERTICAL_BOTTOM_TOP = "bottom-top";
+    DEFAULT_SORT_VERTICAL = SORT_VERTICAL_NONE;
+    SORT_HORIZONTAL_NONE = "none";
+    SORT_HORIZONTAL_LTR = "ltr";
+    SORT_HORIZONTAL_RTL = "rtl";
+    DEFAULT_SORT_HORIZONTAL = SORT_HORIZONTAL_NONE;
+  }
+});
+
+// src/lib/ppocr-label.ts
+var import_node_crypto, import_node_fs, import_node_path, import_image_size, ppocrToLabelStudio, ppocrToFullLabelStudio, ppocrToMinLabelStudio;
+var init_ppocr_label = __esm({
+  "src/lib/ppocr-label.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto = require("crypto");
+    import_node_fs = require("fs");
+    import_node_path = require("path");
+    import_image_size = __toESM(require("image-size"), 1);
+    init_constants();
+    ppocrToLabelStudio = async (data, options) => {
+      const {
+        imagePath,
+        baseServerUrl,
+        inputDir,
+        toFullJson = true,
+        taskId = 1,
+        labelName = DEFAULT_LABEL_NAME
+      } = options || {};
+      if (toFullJson) {
+        return ppocrToFullLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          taskId,
+          labelName
+        );
+      } else {
+        return ppocrToMinLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          labelName
+        );
+      }
+    };
+    ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId = 1, labelName = DEFAULT_LABEL_NAME) => {
+      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let original_width = 1920;
+      let original_height = 1080;
+      const resolvedImagePath = inputDir ? (0, import_node_path.join)(inputDir, imagePath) : imagePath;
+      if (!(0, import_node_fs.existsSync)(resolvedImagePath)) {
+        throw new Error(`Image file not found: ${resolvedImagePath}`);
+      }
+      const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
+      const dimensions = (0, import_image_size.default)(buffer);
+      if (!dimensions.width || !dimensions.height) {
+        throw new Error(
+          `Failed to read image dimensions from: ${resolvedImagePath}`
+        );
+      }
+      original_width = dimensions.width;
+      original_height = dimensions.height;
+      const fileName = imagePath.split("/").pop() || imagePath;
+      const result = [
+        {
+          id: taskId,
+          annotations: [
+            {
+              id: taskId,
+              completed_by: 1,
+              result: data.map((item) => {
+                const { points } = item;
+                const annotationId = (0, import_node_crypto.randomUUID)().slice(0, 10);
+                const polygonPoints = points.map(([x, y]) => [
+                  (x ?? 0) / original_width * 100,
+                  (y ?? 0) / original_height * 100
+                ]);
+                return [
+                  // 1. Polygon geometry only
+                  {
+                    original_width,
+                    original_height,
+                    image_rotation: 0,
+                    value: {
+                      points: polygonPoints,
+                      closed: true
+                    },
+                    id: annotationId,
+                    from_name: "poly",
+                    to_name: "image",
+                    type: "polygon",
+                    origin: "manual"
+                  },
+                  // 2. Labels with polygon geometry
+                  {
+                    original_width,
+                    original_height,
+                    image_rotation: 0,
+                    value: {
+                      points: polygonPoints,
+                      closed: true,
+                      labels: [labelName]
+                    },
+                    id: annotationId,
+                    from_name: "label",
+                    to_name: "image",
+                    type: "labels",
+                    origin: "manual"
+                  },
+                  // 3. Textarea with polygon geometry and text
+                  {
+                    original_width,
+                    original_height,
+                    image_rotation: 0,
+                    value: {
+                      points: polygonPoints,
+                      closed: true,
+                      text: [item.transcription]
+                    },
+                    id: annotationId,
+                    from_name: "transcription",
+                    to_name: "image",
+                    type: "textarea",
+                    origin: "manual"
+                  }
+                ];
+              }).flat(),
+              was_cancelled: false,
+              ground_truth: false,
+              created_at: now,
+              updated_at: now,
+              draft_created_at: now,
+              lead_time: 0,
+              prediction: {},
+              result_count: data.length * 3,
+              unique_id: (0, import_node_crypto.randomUUID)(),
+              import_id: null,
+              last_action: null,
+              bulk_created: false,
+              task: taskId,
+              project: 1,
+              updated_by: 1,
+              parent_prediction: null,
+              parent_annotation: null,
+              last_created_by: null
+            }
+          ],
+          file_upload: fileName,
+          drafts: [],
+          predictions: [],
+          data: { ocr: `${newBaseServerUrl}${imagePath}` },
+          meta: {},
+          created_at: now,
+          updated_at: now,
+          allow_skip: false,
+          inner_id: taskId,
+          total_annotations: 1,
+          cancelled_annotations: 0,
+          total_predictions: 0,
+          comment_count: 0,
+          unresolved_comment_count: 0,
+          last_comment_updated_at: null,
+          project: 1,
+          updated_by: 1,
+          comment_authors: []
+        }
+      ];
+      return result;
+    };
+    ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName = "text") => {
+      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let original_width = 1920;
+      let original_height = 1080;
+      const resolvedImagePath = inputDir ? (0, import_node_path.join)(inputDir, imagePath) : imagePath;
+      if (!(0, import_node_fs.existsSync)(resolvedImagePath)) {
+        throw new Error(`Image file not found: ${resolvedImagePath}`);
+      }
+      const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
+      const dimensions = (0, import_image_size.default)(buffer);
+      if (!dimensions.width || !dimensions.height) {
+        throw new Error(
+          `Failed to read image dimensions from: ${resolvedImagePath}`
+        );
+      }
+      original_width = dimensions.width;
+      original_height = dimensions.height;
+      return data.map((item, index) => {
+        const { points } = item;
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const point of points) {
+          const [x, y] = point;
+          if (x !== void 0 && y !== void 0) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+          }
+        }
+        const width = maxX - minX;
+        const height = maxY - minY;
+        return {
+          ocr: encodeURI(`${newBaseServerUrl}${imagePath}`),
+          id: index + 1,
+          bbox: [
+            {
+              x: minX,
+              y: minY,
+              width,
+              height,
+              rotation: 0,
+              original_width,
+              original_height
+            }
+          ],
+          label: [
+            {
+              points,
+              closed: true,
+              labels: [labelName],
+              original_width,
+              original_height
+            }
+          ],
+          transcription: [item.transcription],
+          poly: [
+            {
+              points,
+              closed: true,
+              original_width,
+              original_height
+            }
+          ],
+          annotator: 1,
+          annotation_id: index + 1,
+          created_at: now,
+          updated_at: now,
+          lead_time: 0
+        };
+      });
+    };
+  }
+});
+
+// src/lib/schema.ts
+var import_zod, FullOCRLabelStudioSchema, MinOCRLabelStudioSchema, PPOCRLabelSchema;
+var init_schema = __esm({
+  "src/lib/schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod = __toESM(require("zod"), 1);
+    FullOCRLabelStudioSchema = import_zod.default.array(
+      import_zod.default.object({
+        id: import_zod.default.number(),
+        annotations: import_zod.default.array(
+          import_zod.default.object({
+            id: import_zod.default.number(),
+            completed_by: import_zod.default.number(),
+            result: import_zod.default.array(
+              import_zod.default.union([
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number()
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number(),
+                    labels: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number(),
+                    text: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean()
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean(),
+                    labels: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean(),
+                    text: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                })
+              ])
+            ),
+            was_cancelled: import_zod.default.boolean(),
+            ground_truth: import_zod.default.boolean(),
+            created_at: import_zod.default.string(),
+            updated_at: import_zod.default.string(),
+            draft_created_at: import_zod.default.string(),
+            lead_time: import_zod.default.number(),
+            prediction: import_zod.default.object({}),
+            result_count: import_zod.default.number(),
+            unique_id: import_zod.default.string(),
+            import_id: import_zod.default.null(),
+            last_action: import_zod.default.null(),
+            bulk_created: import_zod.default.boolean(),
+            task: import_zod.default.number(),
+            project: import_zod.default.number(),
+            updated_by: import_zod.default.number(),
+            parent_prediction: import_zod.default.null(),
+            parent_annotation: import_zod.default.null(),
+            last_created_by: import_zod.default.null()
+          })
+        ),
+        file_upload: import_zod.default.string(),
+        drafts: import_zod.default.array(
+          import_zod.default.object({
+            id: import_zod.default.number(),
+            user: import_zod.default.string(),
+            created_username: import_zod.default.string(),
+            created_ago: import_zod.default.string(),
+            result: import_zod.default.array(
+              import_zod.default.union([
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number()
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number(),
+                    labels: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    x: import_zod.default.number(),
+                    y: import_zod.default.number(),
+                    width: import_zod.default.number(),
+                    height: import_zod.default.number(),
+                    rotation: import_zod.default.number(),
+                    text: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean()
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean(),
+                    labels: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                }),
+                import_zod.default.object({
+                  original_width: import_zod.default.number(),
+                  original_height: import_zod.default.number(),
+                  image_rotation: import_zod.default.number(),
+                  value: import_zod.default.object({
+                    points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+                    closed: import_zod.default.boolean(),
+                    text: import_zod.default.array(import_zod.default.string())
+                  }),
+                  id: import_zod.default.string(),
+                  from_name: import_zod.default.string(),
+                  to_name: import_zod.default.string(),
+                  type: import_zod.default.string(),
+                  origin: import_zod.default.string()
+                })
+              ])
+            ),
+            lead_time: import_zod.default.number(),
+            was_postponed: import_zod.default.boolean(),
+            import_id: import_zod.default.null(),
+            created_at: import_zod.default.string(),
+            updated_at: import_zod.default.string(),
+            task: import_zod.default.number(),
+            annotation: import_zod.default.number()
+          })
+        ),
+        predictions: import_zod.default.array(import_zod.default.unknown()),
+        data: import_zod.default.object({ ocr: import_zod.default.string() }),
+        meta: import_zod.default.object({}),
+        created_at: import_zod.default.string(),
+        updated_at: import_zod.default.string(),
+        allow_skip: import_zod.default.boolean(),
+        inner_id: import_zod.default.number(),
+        total_annotations: import_zod.default.number(),
+        cancelled_annotations: import_zod.default.number(),
+        total_predictions: import_zod.default.number(),
+        comment_count: import_zod.default.number(),
+        unresolved_comment_count: import_zod.default.number(),
+        last_comment_updated_at: import_zod.default.null(),
+        project: import_zod.default.number(),
+        updated_by: import_zod.default.number(),
+        comment_authors: import_zod.default.array(import_zod.default.unknown())
+      })
+    );
+    MinOCRLabelStudioSchema = import_zod.default.array(
+      import_zod.default.object({
+        ocr: import_zod.default.string(),
+        id: import_zod.default.number(),
+        bbox: import_zod.default.array(
+          import_zod.default.object({
+            x: import_zod.default.number(),
+            y: import_zod.default.number(),
+            width: import_zod.default.number(),
+            height: import_zod.default.number(),
+            rotation: import_zod.default.number(),
+            original_width: import_zod.default.number(),
+            original_height: import_zod.default.number()
+          })
+        ),
+        label: import_zod.default.array(
+          import_zod.default.union([
+            import_zod.default.object({
+              x: import_zod.default.number(),
+              y: import_zod.default.number(),
+              width: import_zod.default.number(),
+              height: import_zod.default.number(),
+              rotation: import_zod.default.number(),
+              labels: import_zod.default.array(import_zod.default.string()),
+              original_width: import_zod.default.number(),
+              original_height: import_zod.default.number()
+            }),
+            import_zod.default.object({
+              points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+              closed: import_zod.default.boolean(),
+              labels: import_zod.default.array(import_zod.default.string()),
+              original_width: import_zod.default.number(),
+              original_height: import_zod.default.number()
+            })
+          ])
+        ),
+        transcription: import_zod.default.array(import_zod.default.string()),
+        poly: import_zod.default.array(
+          import_zod.default.object({
+            points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+            closed: import_zod.default.boolean(),
+            original_width: import_zod.default.number(),
+            original_height: import_zod.default.number()
+          })
+        ),
+        annotator: import_zod.default.number(),
+        annotation_id: import_zod.default.number(),
+        created_at: import_zod.default.string(),
+        updated_at: import_zod.default.string(),
+        lead_time: import_zod.default.number()
+      })
+    );
+    PPOCRLabelSchema = import_zod.default.array(
+      import_zod.default.object({
+        transcription: import_zod.default.string(),
+        points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
+        dt_score: import_zod.default.number()
+      })
+    );
+  }
+});
+
+// src/lib/sort.ts
+function getBoundingBoxCenter(points) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of points) {
+    if (x !== void 0 && y !== void 0) {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  return {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function sortBoundingBoxes(annotations, verticalSort, horizontalSort) {
+  if (verticalSort === SORT_VERTICAL_NONE && horizontalSort === SORT_HORIZONTAL_NONE) {
+    return annotations;
+  }
+  const sorted = [...annotations];
+  const isVerticalText = sorted.length > 0 && (() => {
+    const verticalCount = sorted.filter((ann) => {
+      const center = getBoundingBoxCenter(ann.points);
+      return center.height > center.width * 1.5;
+    }).length;
+    return verticalCount > sorted.length / 2;
+  })();
+  if (horizontalSort === SORT_HORIZONTAL_RTL && verticalSort !== SORT_VERTICAL_NONE && isVerticalText) {
+    const annotationsWithCenters = sorted.map((ann) => ({
+      annotation: ann,
+      center: getBoundingBoxCenter(ann.points)
+    }));
+    const columns = [];
+    for (const item of annotationsWithCenters) {
+      let addedToColumn = false;
+      for (const column of columns) {
+        const avgX = column.reduce((sum, c) => sum + c.center.x, 0) / column.length;
+        if (Math.abs(item.center.x - avgX) < GROUPING_TOLERANCE) {
+          column.push(item);
+          addedToColumn = true;
+          break;
+        }
+      }
+      if (!addedToColumn) {
+        columns.push([item]);
+      }
+    }
+    columns.sort((colA, colB) => {
+      const avgXA = colA.reduce((sum, c) => sum + c.center.x, 0) / colA.length;
+      const avgXB = colB.reduce((sum, c) => sum + c.center.x, 0) / colB.length;
+      return avgXB - avgXA;
+    });
+    for (const column of columns) {
+      column.sort((a, b) => {
+        return verticalSort === SORT_VERTICAL_TOP_BOTTOM ? a.center.y - b.center.y : b.center.y - a.center.y;
+      });
+    }
+    return columns.flat().map((item) => item.annotation);
+  }
+  sorted.sort((a, b) => {
+    const centerA = getBoundingBoxCenter(a.points);
+    const centerB = getBoundingBoxCenter(b.points);
+    if (verticalSort !== SORT_VERTICAL_NONE) {
+      const yDiff = verticalSort === SORT_VERTICAL_TOP_BOTTOM ? centerA.y - centerB.y : centerB.y - centerA.y;
+      if (Math.abs(yDiff) > GROUPING_TOLERANCE) {
+        return yDiff;
+      }
+    }
+    if (horizontalSort !== SORT_HORIZONTAL_NONE) {
+      return horizontalSort === SORT_HORIZONTAL_LTR ? centerA.x - centerB.x : centerB.x - centerA.x;
+    }
+    return 0;
+  });
+  return sorted;
+}
+var GROUPING_TOLERANCE;
+var init_sort = __esm({
+  "src/lib/sort.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_constants();
+    GROUPING_TOLERANCE = 50;
+  }
+});
+
+// src/commands/toLabelStudio/impl.ts
+var impl_exports = {};
+__export(impl_exports, {
+  convertToLabelStudio: () => convertToLabelStudio
+});
+async function convertToLabelStudio(flags, ...inputDirs) {
+  const {
+    outDir = OUTPUT_BASE_DIR,
+    defaultLabelName = DEFAULT_LABEL_NAME,
+    toFullJson = DEFAULT_LABEL_STUDIO_FULL_JSON,
+    createFilePerImage = DEFAULT_CREATE_FILE_PER_IMAGE,
+    createFileListForServing = DEFAULT_CREATE_FILE_LIST_FOR_SERVING,
+    fileListName = DEFAULT_FILE_LIST_NAME,
+    baseServerUrl = DEFAULT_BASE_SERVER_URL,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL
+  } = flags;
+  const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
+  await (0, import_promises.mkdir)(outDir, { recursive: true });
+  for (const inputDir of inputDirs) {
+    console.log(import_chalk.default.blue(`Processing input directory: ${inputDir}`));
+    const files = await (0, import_promises.readdir)(inputDir);
+    for (const file of files) {
+      if (!file.endsWith(".txt")) {
+        continue;
+      }
+      const filePath = (0, import_path.join)(inputDir, file);
+      console.log(import_chalk.default.gray(`Processing file: ${file}`));
+      try {
+        const fileData = await (0, import_promises.readFile)(filePath, "utf-8");
+        const lines = fileData.trim().split("\n");
+        const imageDataMap = /* @__PURE__ */ new Map();
+        for (const line of lines) {
+          const parts = line.split("	");
+          if (parts.length !== 2) {
+            throw new Error(`Invalid PPOCRLabelV2 format in line: ${line}`);
+          }
+          const [imagePath, annotationsStr] = parts;
+          const annotations = JSON.parse(annotationsStr);
+          PPOCRLabelSchema.parse(annotations);
+          imageDataMap.set(imagePath, annotations);
+        }
+        const allLabelStudioData = [];
+        const fileList = [];
+        let taskId = 1;
+        for (const [imagePath, ppocrData] of imageDataMap.entries()) {
+          const sortedPpocrData = sortBoundingBoxes(
+            ppocrData,
+            sortVertical,
+            sortHorizontal
+          );
+          const finalImagePath = createFileListForServing ? encodeURI(`${newBaseServerUrl}${imagePath}`) : imagePath;
+          const labelStudioData = await ppocrToLabelStudio(sortedPpocrData, {
+            toFullJson,
+            imagePath,
+            baseServerUrl: newBaseServerUrl,
+            inputDir,
+            taskId,
+            labelName: defaultLabelName
+          });
+          if (toFullJson) {
+            allLabelStudioData.push(labelStudioData[0]);
+          } else {
+            allLabelStudioData.push(...labelStudioData);
+          }
+          if (createFilePerImage) {
+            const imageBaseName = imagePath.replace(/\//g, "_").replace(/\.[^.]+$/, "");
+            const individualOutputPath = (0, import_path.join)(
+              outDir,
+              `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
+            );
+            await (0, import_promises.writeFile)(
+              individualOutputPath,
+              JSON.stringify(
+                toFullJson ? labelStudioData[0] : labelStudioData,
+                null,
+                2
+              ),
+              "utf-8"
+            );
+            console.log(
+              import_chalk.default.gray(
+                `  \u2713 Created individual file: ${individualOutputPath}`
+              )
+            );
+          }
+          if (createFileListForServing) {
+            fileList.push(finalImagePath);
+          }
+          taskId++;
+        }
+        const baseName = file.replace(".txt", "");
+        const outputPath = (0, import_path.join)(
+          outDir,
+          `${baseName}_${toFullJson ? "full" : "min"}.json`
+        );
+        await (0, import_promises.writeFile)(
+          outputPath,
+          JSON.stringify(allLabelStudioData, null, 2),
+          "utf-8"
+        );
+        console.log(import_chalk.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+        if (createFileListForServing && fileList.length > 0) {
+          const fileListPath = (0, import_path.join)(outDir, fileListName);
+          await (0, import_promises.writeFile)(fileListPath, fileList.join("\n"), "utf-8");
+          console.log(
+            import_chalk.default.green(
+              `\u2713 Created file list: ${fileListPath} (${fileList.length} files)`
+            )
+          );
+        }
+      } catch (error) {
+        console.error(
+          import_chalk.default.red(`\u2717 Failed to process ${file}:`),
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+  }
+  console.log(import_chalk.default.green("\n\u2713 Conversion completed!"));
+}
+var import_promises, import_path, import_chalk;
+var init_impl = __esm({
+  "src/commands/toLabelStudio/impl.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises = require("fs/promises");
+    import_path = require("path");
+    import_chalk = __toESM(require("chalk"), 1);
+    init_constants();
+    init_ppocr_label();
+    init_schema();
+    init_sort();
+  }
+});
+
+// src/lib/label-studio.ts
+var turf, labelStudioToPPOCR, minLabelStudioToPPOCR;
+var init_label_studio = __esm({
+  "src/lib/label-studio.ts"() {
+    "use strict";
+    init_cjs_shims();
+    turf = __toESM(require("@turf/turf"), 1);
+    labelStudioToPPOCR = async (data, baseImageDir) => {
+      const resultMap = /* @__PURE__ */ new Map();
+      for (const task of data) {
+        let imagePath = task.file_upload || "";
+        if (task.data.ocr) {
+          const urlPath = task.data.ocr.replace(/^https?:\/\/[^/]+\//, "");
+          imagePath = decodeURIComponent(urlPath);
+        }
+        if (baseImageDir) {
+          imagePath = `${baseImageDir}/${task.file_upload || imagePath.split("/").pop() || imagePath}`;
+        }
+        const imageAnnotations = [];
+        for (const annotation of task.annotations) {
+          const groupedById = /* @__PURE__ */ new Map();
+          for (const resultItem of annotation.result) {
+            const { id } = resultItem;
+            if (!groupedById.has(id)) {
+              groupedById.set(id, []);
+            }
+            groupedById.get(id).push(resultItem);
+          }
+          for (const [_, resultItems] of groupedById) {
+            let points;
+            let transcription = "";
+            for (const resultItem of resultItems) {
+              if ("points" in resultItem.value && resultItem.value.points) {
+                const { points: valuePoints } = resultItem.value;
+                const { original_width, original_height } = resultItem;
+                points = valuePoints.map(([x, y]) => [
+                  (x ?? 0) * original_width / 100,
+                  (y ?? 0) * original_height / 100
+                ]);
+              } else if ("x" in resultItem.value && "y" in resultItem.value && "width" in resultItem.value && "height" in resultItem.value) {
+                const { x, y, width, height } = resultItem.value;
+                const { original_width, original_height } = resultItem;
+                const absX = x * original_width / 100;
+                const absY = y * original_height / 100;
+                const absWidth = width * original_width / 100;
+                const absHeight = height * original_height / 100;
+                points = [
+                  [absX, absY],
+                  [absX + absWidth, absY],
+                  [absX + absWidth, absY + absHeight],
+                  [absX, absY + absHeight]
+                ];
+              }
+              if ("text" in resultItem.value && Array.isArray(resultItem.value.text)) {
+                transcription = resultItem.value.text[0] || "";
+              }
+            }
+            if (points && points.length > 0) {
+              let dt_score = 1;
+              try {
+                const firstPoint = points[0];
+                if (firstPoint) {
+                  const polygon2 = turf.polygon([points.concat([firstPoint])]);
+                  const area2 = turf.area(polygon2);
+                  dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
+                }
+              } catch {
+                dt_score = 0.8;
+              }
+              imageAnnotations.push({
+                transcription,
+                points,
+                dt_score
+              });
+            }
+          }
+        }
+        if (imageAnnotations.length > 0) {
+          resultMap.set(imagePath, imageAnnotations);
+        }
+      }
+      return resultMap;
+    };
+    minLabelStudioToPPOCR = async (data, baseImageDir) => {
+      const resultMap = /* @__PURE__ */ new Map();
+      for (const item of data) {
+        let imagePath = item.ocr || "";
+        if (imagePath) {
+          imagePath = decodeURIComponent(
+            imagePath.replace(/^https?:\/\/[^/]+\//, "")
+          );
+        }
+        if (baseImageDir) {
+          imagePath = `${baseImageDir}/${imagePath.split("/").pop() || imagePath}`;
+        }
+        let points;
+        if (item.poly.length > 0 && item.poly[0]) {
+          const { points: polyPoints } = item.poly[0];
+          points = polyPoints;
+        } else if (item.bbox.length > 0 && item.bbox[0]) {
+          const bbox = item.bbox[0];
+          const { x, y, width, height } = bbox;
+          points = [
+            [x, y],
+            [x + width, y],
+            [x + width, y + height],
+            [x, y + height]
+          ];
+        } else {
+          continue;
+        }
+        const transcription = item.transcription.length > 0 ? item.transcription[0] : "";
+        let dt_score = 1;
+        try {
+          const firstPoint = points[0];
+          if (firstPoint) {
+            const polygon2 = turf.polygon([points.concat([firstPoint])]);
+            const area2 = turf.area(polygon2);
+            dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
+          }
+        } catch {
+          dt_score = 0.8;
+        }
+        const annotation = {
+          transcription: transcription ?? "",
+          points,
+          dt_score
+        };
+        if (!resultMap.has(imagePath)) {
+          resultMap.set(imagePath, []);
+        }
+        resultMap.get(imagePath).push(annotation);
+      }
+      return resultMap;
+    };
+  }
+});
+
+// src/commands/toPPOCR/impl.ts
+var impl_exports2 = {};
+__export(impl_exports2, {
+  convertToPPOCR: () => convertToPPOCR
+});
+async function convertToPPOCR(flags, ...inputDirs) {
+  const {
+    outDir = `${OUTPUT_BASE_DIR}`,
+    fileName = DEFAULT_PPOCR_FILE_NAME,
+    baseImageDir,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL
+  } = flags;
+  await (0, import_promises2.mkdir)(outDir, { recursive: true });
+  for (const inputDir of inputDirs) {
+    console.log(import_chalk2.default.blue(`Processing input directory: ${inputDir}`));
+    const files = await (0, import_promises2.readdir)(inputDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = (0, import_path2.join)(inputDir, file);
+      console.log(import_chalk2.default.gray(`Processing file: ${file}`));
+      try {
+        const fileData = await (0, import_promises2.readFile)(filePath, "utf-8");
+        const labelStudioData = JSON.parse(fileData);
+        const { data, isFull } = isLabelStudioFullJSON(labelStudioData);
+        const ppocrDataMap = isFull ? await labelStudioToPPOCR(data, baseImageDir) : await minLabelStudioToPPOCR(
+          data,
+          baseImageDir
+        );
+        const outputLines = [];
+        for (const [imagePath, annotations] of ppocrDataMap.entries()) {
+          const sortedAnnotations = sortBoundingBoxes(
+            annotations,
+            sortVertical,
+            sortHorizontal
+          );
+          PPOCRLabelSchema.parse(sortedAnnotations);
+          const jsonArray = JSON.stringify(sortedAnnotations);
+          outputLines.push(`${imagePath}	${jsonArray}`);
+        }
+        const baseName = file.replace(".json", "");
+        const outputPath = (0, import_path2.join)(outDir, `${baseName}_${fileName}`);
+        await (0, import_promises2.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
+        console.log(import_chalk2.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+      } catch (error) {
+        console.error(
+          import_chalk2.default.red(`\u2717 Failed to process ${file}:`),
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+  }
+  console.log(import_chalk2.default.green("\n\u2713 Conversion completed!"));
+}
+var import_promises2, import_path2, import_chalk2, isLabelStudioFullJSON;
+var init_impl2 = __esm({
+  "src/commands/toPPOCR/impl.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises2 = require("fs/promises");
+    import_path2 = require("path");
+    import_chalk2 = __toESM(require("chalk"), 1);
+    init_constants();
+    init_label_studio();
+    init_schema();
+    init_sort();
+    isLabelStudioFullJSON = (data) => {
+      const parsedFull = FullOCRLabelStudioSchema.safeParse(data);
+      if (parsedFull.success) {
+        return { isFull: true, data: parsedFull.data };
+      }
+      if (!Array.isArray(data) && typeof data === "object" && data !== null) {
+        const parsedSingleFull = FullOCRLabelStudioSchema.safeParse([data]);
+        if (parsedSingleFull.success) {
+          return { isFull: true, data: parsedSingleFull.data };
+        }
+      }
+      const parsedMin = MinOCRLabelStudioSchema.safeParse(data);
+      if (parsedMin.success) {
+        return { isFull: false, data: parsedMin.data };
+      }
+      throw new Error("Input data is not valid Label Studio JSON format.");
+    };
+  }
+});
+
+// src/bin/bash-complete.ts
+init_cjs_shims();
+var import_core4 = require("@stricli/core");
+
+// src/app.ts
+init_cjs_shims();
+var import_auto_complete = require("@stricli/auto-complete");
+var import_core3 = require("@stricli/core");
+
+// package.json
+var version = "1.0.0";
+var description = "Convert between Label Studio OCR format and PPOCRLabelv2 format";
+
+// src/commands/toLabelStudio/command.ts
+init_cjs_shims();
+var import_core = require("@stricli/core");
+init_constants();
+var toLabelStudioCommand = (0, import_core.buildCommand)({
+  loader: async () => {
+    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
+    return convertToLabelStudio2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing PPOCRLabel files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        parse: String,
+        optional: true
+      },
+      defaultLabelName: {
+        kind: "parsed",
+        brief: `Default label name for text annotations. Default to "${DEFAULT_LABEL_NAME}"`,
+        parse: String,
+        optional: true
+      },
+      toFullJson: {
+        kind: "boolean",
+        brief: `Convert to Full OCR Label Studio format. Default to "${DEFAULT_LABEL_STUDIO_FULL_JSON}"`,
+        optional: true
+      },
+      createFilePerImage: {
+        kind: "boolean",
+        brief: `Create a separate Label Studio JSON file for each image. Default to "${DEFAULT_CREATE_FILE_PER_IMAGE}"`,
+        optional: true
+      },
+      createFileListForServing: {
+        kind: "boolean",
+        brief: `Create a file list for serving in Label Studio. Default to "${DEFAULT_CREATE_FILE_LIST_FOR_SERVING}"`,
+        optional: true
+      },
+      fileListName: {
+        kind: "parsed",
+        brief: `Name of the file list for serving. Default to "${DEFAULT_FILE_LIST_NAME}"`,
+        parse: String,
+        optional: true
+      },
+      baseServerUrl: {
+        kind: "parsed",
+        brief: `Base server URL for constructing image URLs in the file list. Default to "${DEFAULT_BASE_SERVER_URL}"`,
+        parse: String,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}" (default), "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        parse: String,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Convert PPOCRLabel files to Label Studio format"
+  }
+});
+
+// src/commands/toPPOCR/commands.ts
+init_cjs_shims();
+var import_core2 = require("@stricli/core");
+init_constants();
+var toPPOCRCommand = (0, import_core2.buildCommand)({
+  loader: async () => {
+    const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl2(), impl_exports2));
+    return convertToPPOCR2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing Label Studio files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        parse: String,
+        optional: true
+      },
+      fileName: {
+        kind: "parsed",
+        brief: `Output PPOCR file name. Default to "${DEFAULT_PPOCR_FILE_NAME}"`,
+        parse: String,
+        optional: true
+      },
+      baseImageDir: {
+        kind: "parsed",
+        brief: 'Base directory path to prepend to image filenames in output (e.g., "ch" or "images/ch")',
+        parse: String,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}" (default), "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        parse: String,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Convert Label Studio files to PPOCRLabel format"
+  }
+});
+
+// src/app.ts
+var routes = (0, import_core3.buildRouteMap)({
+  routes: {
+    toLabelStudio: toLabelStudioCommand,
+    toPPOCR: toPPOCRCommand,
+    install: (0, import_auto_complete.buildInstallCommand)("label-studio-converter", {
+      bash: "__label-studio-converter_bash_complete"
+    }),
+    uninstall: (0, import_auto_complete.buildUninstallCommand)("label-studio-converter", { bash: true })
+  },
+  docs: {
+    brief: description,
+    hideRoute: {
+      install: true,
+      uninstall: true
+    }
+  }
+});
+var app = (0, import_core3.buildApplication)(routes, {
+  name: "label-studio-converter",
+  versionInfo: {
+    currentVersion: version
+  }
+});
+
+// src/context.ts
+init_cjs_shims();
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function buildContext(process2) {
+  return {
+    process: process2,
+    os: import_node_os.default,
+    fs: import_node_fs2.default,
+    path: import_node_path2.default
+  };
+}
+
+// src/bin/bash-complete.ts
+(async () => {
+  const inputs = process.argv.slice(3);
+  if (process.env.COMP_LINE?.endsWith(" ")) {
+    inputs.push("");
+  }
+  await (0, import_core4.proposeCompletions)(app, inputs, buildContext(process));
+  try {
+    for (const { completion } of await (0, import_core4.proposeCompletions)(
+      app,
+      inputs,
+      buildContext(process)
+    )) {
+      process.stdout.write(`${completion}
+`);
+    }
+  } catch {
+  }
+})();
+//# sourceMappingURL=bash-complete.cjs.map