label-studio-converter 1.0.0

package/dist/cli.js

@@ -0,0 +1,1264 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// 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/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_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/esm_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_esm_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
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import sizeOf from "image-size";
+var ppocrToLabelStudio, ppocrToFullLabelStudio, ppocrToMinLabelStudio;
+var init_ppocr_label = __esm({
+  "src/lib/ppocr-label.ts"() {
+    "use strict";
+    init_esm_shims();
+    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 ? join(inputDir, imagePath) : imagePath;
+      if (!existsSync(resolvedImagePath)) {
+        throw new Error(`Image file not found: ${resolvedImagePath}`);
+      }
+      const buffer = readFileSync(resolvedImagePath);
+      const dimensions = sizeOf(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 = 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: 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 ? join(inputDir, imagePath) : imagePath;
+      if (!existsSync(resolvedImagePath)) {
+        throw new Error(`Image file not found: ${resolvedImagePath}`);
+      }
+      const buffer = readFileSync(resolvedImagePath);
+      const dimensions = sizeOf(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
+import z from "zod";
+var FullOCRLabelStudioSchema, MinOCRLabelStudioSchema, PPOCRLabelSchema;
+var init_schema = __esm({
+  "src/lib/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    FullOCRLabelStudioSchema = z.array(
+      z.object({
+        id: z.number(),
+        annotations: z.array(
+          z.object({
+            id: z.number(),
+            completed_by: z.number(),
+            result: z.array(
+              z.union([
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number()
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number(),
+                    labels: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number(),
+                    text: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean()
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean(),
+                    labels: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean(),
+                    text: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                })
+              ])
+            ),
+            was_cancelled: z.boolean(),
+            ground_truth: z.boolean(),
+            created_at: z.string(),
+            updated_at: z.string(),
+            draft_created_at: z.string(),
+            lead_time: z.number(),
+            prediction: z.object({}),
+            result_count: z.number(),
+            unique_id: z.string(),
+            import_id: z.null(),
+            last_action: z.null(),
+            bulk_created: z.boolean(),
+            task: z.number(),
+            project: z.number(),
+            updated_by: z.number(),
+            parent_prediction: z.null(),
+            parent_annotation: z.null(),
+            last_created_by: z.null()
+          })
+        ),
+        file_upload: z.string(),
+        drafts: z.array(
+          z.object({
+            id: z.number(),
+            user: z.string(),
+            created_username: z.string(),
+            created_ago: z.string(),
+            result: z.array(
+              z.union([
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number()
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number(),
+                    labels: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    x: z.number(),
+                    y: z.number(),
+                    width: z.number(),
+                    height: z.number(),
+                    rotation: z.number(),
+                    text: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean()
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean(),
+                    labels: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                }),
+                z.object({
+                  original_width: z.number(),
+                  original_height: z.number(),
+                  image_rotation: z.number(),
+                  value: z.object({
+                    points: z.array(z.array(z.number())),
+                    closed: z.boolean(),
+                    text: z.array(z.string())
+                  }),
+                  id: z.string(),
+                  from_name: z.string(),
+                  to_name: z.string(),
+                  type: z.string(),
+                  origin: z.string()
+                })
+              ])
+            ),
+            lead_time: z.number(),
+            was_postponed: z.boolean(),
+            import_id: z.null(),
+            created_at: z.string(),
+            updated_at: z.string(),
+            task: z.number(),
+            annotation: z.number()
+          })
+        ),
+        predictions: z.array(z.unknown()),
+        data: z.object({ ocr: z.string() }),
+        meta: z.object({}),
+        created_at: z.string(),
+        updated_at: z.string(),
+        allow_skip: z.boolean(),
+        inner_id: z.number(),
+        total_annotations: z.number(),
+        cancelled_annotations: z.number(),
+        total_predictions: z.number(),
+        comment_count: z.number(),
+        unresolved_comment_count: z.number(),
+        last_comment_updated_at: z.null(),
+        project: z.number(),
+        updated_by: z.number(),
+        comment_authors: z.array(z.unknown())
+      })
+    );
+    MinOCRLabelStudioSchema = z.array(
+      z.object({
+        ocr: z.string(),
+        id: z.number(),
+        bbox: z.array(
+          z.object({
+            x: z.number(),
+            y: z.number(),
+            width: z.number(),
+            height: z.number(),
+            rotation: z.number(),
+            original_width: z.number(),
+            original_height: z.number()
+          })
+        ),
+        label: z.array(
+          z.union([
+            z.object({
+              x: z.number(),
+              y: z.number(),
+              width: z.number(),
+              height: z.number(),
+              rotation: z.number(),
+              labels: z.array(z.string()),
+              original_width: z.number(),
+              original_height: z.number()
+            }),
+            z.object({
+              points: z.array(z.array(z.number())),
+              closed: z.boolean(),
+              labels: z.array(z.string()),
+              original_width: z.number(),
+              original_height: z.number()
+            })
+          ])
+        ),
+        transcription: z.array(z.string()),
+        poly: z.array(
+          z.object({
+            points: z.array(z.array(z.number())),
+            closed: z.boolean(),
+            original_width: z.number(),
+            original_height: z.number()
+          })
+        ),
+        annotator: z.number(),
+        annotation_id: z.number(),
+        created_at: z.string(),
+        updated_at: z.string(),
+        lead_time: z.number()
+      })
+    );
+    PPOCRLabelSchema = z.array(
+      z.object({
+        transcription: z.string(),
+        points: z.array(z.array(z.number())),
+        dt_score: z.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_esm_shims();
+    init_constants();
+    GROUPING_TOLERANCE = 50;
+  }
+});
+
+// src/commands/toLabelStudio/impl.ts
+var impl_exports = {};
+__export(impl_exports, {
+  convertToLabelStudio: () => convertToLabelStudio
+});
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import chalk from "chalk";
+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 mkdir(outDir, { recursive: true });
+  for (const inputDir of inputDirs) {
+    console.log(chalk.blue(`Processing input directory: ${inputDir}`));
+    const files = await readdir(inputDir);
+    for (const file of files) {
+      if (!file.endsWith(".txt")) {
+        continue;
+      }
+      const filePath = join2(inputDir, file);
+      console.log(chalk.gray(`Processing file: ${file}`));
+      try {
+        const fileData = await 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 = join2(
+              outDir,
+              `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
+            );
+            await writeFile(
+              individualOutputPath,
+              JSON.stringify(
+                toFullJson ? labelStudioData[0] : labelStudioData,
+                null,
+                2
+              ),
+              "utf-8"
+            );
+            console.log(
+              chalk.gray(
+                `  \u2713 Created individual file: ${individualOutputPath}`
+              )
+            );
+          }
+          if (createFileListForServing) {
+            fileList.push(finalImagePath);
+          }
+          taskId++;
+        }
+        const baseName = file.replace(".txt", "");
+        const outputPath = join2(
+          outDir,
+          `${baseName}_${toFullJson ? "full" : "min"}.json`
+        );
+        await writeFile(
+          outputPath,
+          JSON.stringify(allLabelStudioData, null, 2),
+          "utf-8"
+        );
+        console.log(chalk.green(`\u2713 Converted ${file} -> ${outputPath}`));
+        if (createFileListForServing && fileList.length > 0) {
+          const fileListPath = join2(outDir, fileListName);
+          await writeFile(fileListPath, fileList.join("\n"), "utf-8");
+          console.log(
+            chalk.green(
+              `\u2713 Created file list: ${fileListPath} (${fileList.length} files)`
+            )
+          );
+        }
+      } catch (error) {
+        console.error(
+          chalk.red(`\u2717 Failed to process ${file}:`),
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+  }
+  console.log(chalk.green("\n\u2713 Conversion completed!"));
+}
+var init_impl = __esm({
+  "src/commands/toLabelStudio/impl.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_ppocr_label();
+    init_schema();
+    init_sort();
+  }
+});
+
+// src/lib/label-studio.ts
+import * as turf from "@turf/turf";
+var labelStudioToPPOCR, minLabelStudioToPPOCR;
+var init_label_studio = __esm({
+  "src/lib/label-studio.ts"() {
+    "use strict";
+    init_esm_shims();
+    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
+});
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import chalk2 from "chalk";
+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 mkdir2(outDir, { recursive: true });
+  for (const inputDir of inputDirs) {
+    console.log(chalk2.blue(`Processing input directory: ${inputDir}`));
+    const files = await readdir2(inputDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = join3(inputDir, file);
+      console.log(chalk2.gray(`Processing file: ${file}`));
+      try {
+        const fileData = await readFile2(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 = join3(outDir, `${baseName}_${fileName}`);
+        await writeFile2(outputPath, outputLines.join("\n"), "utf-8");
+        console.log(chalk2.green(`\u2713 Converted ${file} -> ${outputPath}`));
+      } catch (error) {
+        console.error(
+          chalk2.red(`\u2717 Failed to process ${file}:`),
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+  }
+  console.log(chalk2.green("\n\u2713 Conversion completed!"));
+}
+var isLabelStudioFullJSON;
+var init_impl2 = __esm({
+  "src/commands/toPPOCR/impl.ts"() {
+    "use strict";
+    init_esm_shims();
+    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/cli.ts
+init_esm_shims();
+import { run } from "@stricli/core";
+
+// src/app.ts
+init_esm_shims();
+import {
+  buildInstallCommand,
+  buildUninstallCommand
+} from "@stricli/auto-complete";
+import { buildApplication, buildRouteMap } from "@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_esm_shims();
+init_constants();
+import { buildCommand } from "@stricli/core";
+var toLabelStudioCommand = 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_esm_shims();
+init_constants();
+import { buildCommand as buildCommand2 } from "@stricli/core";
+var toPPOCRCommand = buildCommand2({
+  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 = buildRouteMap({
+  routes: {
+    toLabelStudio: toLabelStudioCommand,
+    toPPOCR: toPPOCRCommand,
+    install: buildInstallCommand("label-studio-converter", {
+      bash: "__label-studio-converter_bash_complete"
+    }),
+    uninstall: buildUninstallCommand("label-studio-converter", { bash: true })
+  },
+  docs: {
+    brief: description,
+    hideRoute: {
+      install: true,
+      uninstall: true
+    }
+  }
+});
+var app = buildApplication(routes, {
+  name: "label-studio-converter",
+  versionInfo: {
+    currentVersion: version
+  }
+});
+
+// src/context.ts
+init_esm_shims();
+import fs from "fs";
+import os from "os";
+import path2 from "path";
+function buildContext(process2) {
+  return {
+    process: process2,
+    os,
+    fs,
+    path: path2
+  };
+}
+
+// src/bin/cli.ts
+(async () => {
+  run(app, process.argv.slice(2), buildContext(process));
+})();
+//# sourceMappingURL=cli.js.map