label-studio-converter 1.0.0 → 1.2.0

package/dist/bash-complete.cjs

@@ -38,7 +38,7 @@ var init_cjs_shims = __esm({
 });
 
 // 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 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, SHAPE_NORMALIZE_NONE, SHAPE_NORMALIZE_RECTANGLE, DEFAULT_SHAPE_NORMALIZE, DEFAULT_WIDTH_INCREMENT, DEFAULT_HEIGHT_INCREMENT, DEFAULT_LABEL_STUDIO_PRECISION, DEFAULT_PPOCR_PRECISION;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -59,247 +59,578 @@ var init_constants = __esm({
     SORT_HORIZONTAL_LTR = "ltr";
     SORT_HORIZONTAL_RTL = "rtl";
     DEFAULT_SORT_HORIZONTAL = SORT_HORIZONTAL_NONE;
+    SHAPE_NORMALIZE_NONE = "none";
+    SHAPE_NORMALIZE_RECTANGLE = "rectangle";
+    DEFAULT_SHAPE_NORMALIZE = SHAPE_NORMALIZE_NONE;
+    DEFAULT_WIDTH_INCREMENT = 0;
+    DEFAULT_HEIGHT_INCREMENT = 0;
+    DEFAULT_LABEL_STUDIO_PRECISION = -1;
+    DEFAULT_PPOCR_PRECISION = 0;
   }
 });
 
-// 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"() {
+// src/lib/geometry.ts
+function roundToPrecision(value, precision) {
+  if (precision < 0) {
+    return value;
+  }
+  const multiplier = Math.pow(10, precision);
+  return Math.round(value * multiplier) / multiplier;
+}
+function roundPoints(points, precision) {
+  if (precision < 0) {
+    return points;
+  }
+  return points.map(
+    ([x, y]) => [roundToPrecision(x, precision), roundToPrecision(y, precision)]
+  );
+}
+function calculateCenter(points) {
+  const sum = points.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [
+    0,
+    0
+  ]);
+  return [sum[0] / points.length, sum[1] / points.length];
+}
+function getMinimumBoundingRect(points) {
+  const minX = Math.min(...points.map(([x]) => x));
+  const maxX = Math.max(...points.map(([x]) => x));
+  const minY = Math.min(...points.map(([, y]) => y));
+  const maxY = Math.max(...points.map(([, y]) => y));
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function normalizeShape(points) {
+  if (points.length < 3) {
+    return points;
+  }
+  const { minX, minY, maxX, maxY } = getMinimumBoundingRect(points);
+  return [
+    [minX, minY],
+    [maxX, minY],
+    [maxX, maxY],
+    [minX, maxY]
+  ];
+}
+function resizeBoundingBox(points, widthIncrement, heightIncrement) {
+  if (points.length === 0) {
+    return points;
+  }
+  const center = calculateCenter(points);
+  const bbox = getMinimumBoundingRect(points);
+  const newWidth = Math.max(1, bbox.width + widthIncrement);
+  const newHeight = Math.max(1, bbox.height + heightIncrement);
+  const scaleX = newWidth / bbox.width;
+  const scaleY = newHeight / bbox.height;
+  return points.map(([x, y]) => {
+    const relX = x - center[0];
+    const relY = y - center[1];
+    return [center[0] + relX * scaleX, center[1] + relY * scaleY];
+  });
+}
+function transformPoints(points, options) {
+  let result = points;
+  if (options.normalizeShape && options.normalizeShape === "rectangle") {
+    result = normalizeShape(result);
+  }
+  if (options.widthIncrement !== void 0 || options.heightIncrement !== void 0) {
+    result = resizeBoundingBox(
+      result,
+      options.widthIncrement ?? 0,
+      options.heightIncrement ?? 0
+    );
+  }
+  return result;
+}
+var init_geometry = __esm({
+  "src/lib/geometry.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
-        );
+  }
+});
+
+// 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;
+        }
       }
-    };
-    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}`);
+      if (!addedToColumn) {
+        columns.push([item]);
       }
-      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}`
-        );
+    }
+    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;
       }
-      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
+    }
+    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/lib/enhance.ts
+function enhancePPOCRLabel(data, options) {
+  const {
+    sortVertical,
+    sortHorizontal,
+    normalizeShape: normalizeShape2,
+    widthIncrement = 0,
+    heightIncrement = 0,
+    precision = 0
+  } = options;
+  let enhanced = data;
+  if (sortVertical && sortHorizontal) {
+    enhanced = sortBoundingBoxes(enhanced, sortVertical, sortHorizontal);
+  }
+  if (normalizeShape2 || widthIncrement !== 0 || heightIncrement !== 0) {
+    enhanced = enhanced.map((annotation) => {
+      let points = transformPoints(annotation.points, {
+        normalizeShape: normalizeShape2,
+        widthIncrement,
+        heightIncrement
+      });
+      points = roundPoints(points, precision);
+      return {
+        ...annotation,
+        points
+      };
+    });
+  }
+  return enhanced;
+}
+var init_enhance = __esm({
+  "src/lib/enhance.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_geometry();
+    init_sort();
+  }
+});
+
+// src/lib/label-studio.ts
+var turf, labelStudioToPPOCR, minLabelStudioToPPOCR, enhanceLabelStudioData;
+var init_label_studio = __esm({
+  "src/lib/label-studio.ts"() {
+    "use strict";
+    init_cjs_shims();
+    turf = __toESM(require("@turf/turf"), 1);
+    init_enhance();
+    init_geometry();
+    labelStudioToPPOCR = async (data, options) => {
+      const {
+        baseImageDir,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = 0
+      } = options || {};
+      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
                 ]);
-                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"
-                  }
+              } 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]
                 ];
-              }).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
+              }
+              if ("text" in resultItem.value && Array.isArray(resultItem.value.text)) {
+                transcription = resultItem.value.text[0] || "";
+              }
             }
-          ],
-          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: []
+            if (points && points.length > 0) {
+              points = transformPoints(points, {
+                normalizeShape: normalizeShape2,
+                widthIncrement,
+                heightIncrement
+              });
+              points = roundPoints(points, precision);
+              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 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}`
+      return resultMap;
+    };
+    minLabelStudioToPPOCR = async (data, options) => {
+      const {
+        baseImageDir,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = 0
+      } = options || {};
+      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}`;
+        }
+        const numAnnotations = Math.max(
+          item.poly?.length || 0,
+          item.bbox?.length || 0,
+          item.transcription?.length || 0
         );
-      }
-      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);
+        for (let i = 0; i < numAnnotations; i++) {
+          let points;
+          if (item.poly && item.poly.length > i && item.poly[i]) {
+            const poly = item.poly[i];
+            if (poly) {
+              const { points: polyPoints } = poly;
+              points = polyPoints;
+            }
+          } else if (item.bbox && item.bbox.length > i && item.bbox[i]) {
+            const bbox = item.bbox[i];
+            if (bbox) {
+              const { x, y, width, height } = bbox;
+              points = [
+                [x, y],
+                [x + width, y],
+                [x + width, y + height],
+                [x, y + height]
+              ];
+            }
+          }
+          if (!points) {
+            continue;
+          }
+          points = transformPoints(points, {
+            normalizeShape: normalizeShape2,
+            widthIncrement,
+            heightIncrement
+          });
+          points = roundPoints(points, precision);
+          const transcription = item.transcription && item.transcription.length > i ? item.transcription[i] : "";
+          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);
         }
-        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
+      }
+      return resultMap;
+    };
+    enhanceLabelStudioData = async (data, isFull, options) => {
+      const {
+        sortVertical,
+        sortHorizontal,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = 0
+      } = options;
+      if (isFull) {
+        const fullData = data;
+        return fullData.map((task) => ({
+          ...task,
+          annotations: task.annotations.map((annotation) => {
+            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);
             }
-          ],
-          label: [
-            {
-              points,
-              closed: true,
-              labels: [labelName],
-              original_width,
-              original_height
+            const enhancedResult = [];
+            for (const [_, resultItems] of groupedById) {
+              let ppocrAnnotations = [];
+              for (const resultItem of resultItems) {
+                let points;
+                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 (points) {
+                  ppocrAnnotations.push({
+                    transcription: "",
+                    points,
+                    dt_score: 1
+                  });
+                }
+              }
+              if (ppocrAnnotations.length > 0) {
+                ppocrAnnotations = enhancePPOCRLabel(ppocrAnnotations, {
+                  sortVertical,
+                  sortHorizontal,
+                  normalizeShape: normalizeShape2,
+                  widthIncrement,
+                  heightIncrement,
+                  precision
+                });
+                for (let i = 0; i < resultItems.length; i++) {
+                  const resultItem = resultItems[i];
+                  const enhanced = ppocrAnnotations[i];
+                  if (!enhanced) {
+                    enhancedResult.push(resultItem);
+                    continue;
+                  }
+                  if ("points" in resultItem.value && resultItem.value.points) {
+                    const { original_width, original_height } = resultItem;
+                    enhancedResult.push({
+                      ...resultItem,
+                      value: {
+                        ...resultItem.value,
+                        points: enhanced.points.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 { original_width, original_height } = resultItem;
+                    const xs = enhanced.points.map(([x]) => x ?? 0);
+                    const ys = enhanced.points.map(([, y]) => y ?? 0);
+                    const minX = Math.min(...xs);
+                    const maxX = Math.max(...xs);
+                    const minY = Math.min(...ys);
+                    const maxY = Math.max(...ys);
+                    enhancedResult.push({
+                      ...resultItem,
+                      value: {
+                        ...resultItem.value,
+                        x: minX / original_width * 100,
+                        y: minY / original_height * 100,
+                        width: (maxX - minX) / original_width * 100,
+                        height: (maxY - minY) / original_height * 100
+                      }
+                    });
+                  } else {
+                    enhancedResult.push(resultItem);
+                  }
+                }
+              } else {
+                enhancedResult.push(...resultItems);
+              }
             }
-          ],
-          transcription: [item.transcription],
-          poly: [
-            {
-              points,
-              closed: true,
-              original_width,
-              original_height
+            return {
+              ...annotation,
+              result: enhancedResult
+            };
+          })
+        }));
+      } else {
+        const minData = data;
+        return minData.map((item) => {
+          let ppocrAnnotations = [];
+          const numAnnotations = Math.max(
+            item.poly?.length || 0,
+            item.bbox?.length || 0,
+            item.transcription?.length || 0
+          );
+          for (let i = 0; i < numAnnotations; i++) {
+            let points;
+            if (item.poly && item.poly.length > i && item.poly[i]) {
+              const { points: polyPoints } = item.poly[i];
+              points = polyPoints;
+            } else if (item.bbox && item.bbox.length > i && item.bbox[i]) {
+              const { x, y, width, height } = item.bbox[i];
+              points = [
+                [x, y],
+                [x + width, y],
+                [x + width, y + height],
+                [x, y + height]
+              ];
             }
-          ],
-          annotator: 1,
-          annotation_id: index + 1,
-          created_at: now,
-          updated_at: now,
-          lead_time: 0
-        };
-      });
+            if (points) {
+              ppocrAnnotations.push({
+                transcription: item.transcription && item.transcription.length > i ? item.transcription[i] ?? "" : "",
+                points,
+                dt_score: 1
+              });
+            }
+          }
+          if (ppocrAnnotations.length > 0) {
+            ppocrAnnotations = enhancePPOCRLabel(ppocrAnnotations, {
+              sortVertical,
+              sortHorizontal,
+              normalizeShape: normalizeShape2,
+              widthIncrement,
+              heightIncrement,
+              precision
+            });
+            const newPoly = ppocrAnnotations.map((ann) => ({
+              points: ann.points
+            }));
+            const { bbox: _, ...itemWithoutBbox } = item;
+            return {
+              ...itemWithoutBbox,
+              poly: newPoly
+            };
+          }
+          return item;
+        });
+      }
     };
   }
 });
@@ -320,6 +651,7 @@ var init_schema = __esm({
             completed_by: import_zod.default.number(),
             result: import_zod.default.array(
               import_zod.default.union([
+                // Most specific rectangle variants first (with text or labels)
                 import_zod.default.object({
                   original_width: import_zod.default.number(),
                   original_height: import_zod.default.number(),
@@ -329,7 +661,8 @@ var init_schema = __esm({
                     y: import_zod.default.number(),
                     width: import_zod.default.number(),
                     height: import_zod.default.number(),
-                    rotation: 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(),
@@ -355,6 +688,7 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Base rectangle without text or labels
                 import_zod.default.object({
                   original_width: import_zod.default.number(),
                   original_height: import_zod.default.number(),
@@ -364,8 +698,7 @@ var init_schema = __esm({
                     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())
+                    rotation: import_zod.default.number()
                   }),
                   id: import_zod.default.string(),
                   from_name: import_zod.default.string(),
@@ -373,13 +706,15 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Most specific polygon variants first (with text or labels)
                 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()
+                    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(),
@@ -402,14 +737,14 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Base polygon without text or labels
                 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())
+                    closed: import_zod.default.boolean()
                   }),
                   id: import_zod.default.string(),
                   from_name: import_zod.default.string(),
@@ -448,6 +783,7 @@ var init_schema = __esm({
             created_ago: import_zod.default.string(),
             result: import_zod.default.array(
               import_zod.default.union([
+                // Most specific rectangle variants first (with text or labels)
                 import_zod.default.object({
                   original_width: import_zod.default.number(),
                   original_height: import_zod.default.number(),
@@ -457,7 +793,8 @@ var init_schema = __esm({
                     y: import_zod.default.number(),
                     width: import_zod.default.number(),
                     height: import_zod.default.number(),
-                    rotation: 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(),
@@ -483,6 +820,7 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Base rectangle without text or labels
                 import_zod.default.object({
                   original_width: import_zod.default.number(),
                   original_height: import_zod.default.number(),
@@ -492,8 +830,7 @@ var init_schema = __esm({
                     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())
+                    rotation: import_zod.default.number()
                   }),
                   id: import_zod.default.string(),
                   from_name: import_zod.default.string(),
@@ -501,13 +838,15 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Most specific polygon variants first (with text or labels)
                 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()
+                    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(),
@@ -530,14 +869,14 @@ var init_schema = __esm({
                   type: import_zod.default.string(),
                   origin: import_zod.default.string()
                 }),
+                // Base polygon without text or labels
                 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())
+                    closed: import_zod.default.boolean()
                   }),
                   id: import_zod.default.string(),
                   from_name: import_zod.default.string(),
@@ -588,7 +927,7 @@ var init_schema = __esm({
             original_width: import_zod.default.number(),
             original_height: import_zod.default.number()
           })
-        ),
+        ).optional().default([]),
         label: import_zod.default.array(
           import_zod.default.union([
             import_zod.default.object({
@@ -609,8 +948,11 @@ var init_schema = __esm({
               original_height: import_zod.default.number()
             })
           ])
-        ),
-        transcription: import_zod.default.array(import_zod.default.string()),
+        ).optional().default([]),
+        transcription: import_zod.default.union([import_zod.default.string(), import_zod.default.array(import_zod.default.string())]).optional().transform((val) => {
+          if (!val) return [];
+          return Array.isArray(val) ? val : [val];
+        }),
         poly: import_zod.default.array(
           import_zod.default.object({
             points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
@@ -618,7 +960,7 @@ var init_schema = __esm({
             original_width: import_zod.default.number(),
             original_height: import_zod.default.number()
           })
-        ),
+        ).optional().default([]),
         annotator: import_zod.default.number(),
         annotation_id: import_zod.default.number(),
         created_at: import_zod.default.string(),
@@ -630,106 +972,450 @@ var init_schema = __esm({
       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()
+        dt_score: import_zod.default.number().optional(),
+        // Detection score (from PaddleOCR)
+        difficult: import_zod.default.boolean().optional()
+        // Difficult flag (from PPOCRLabel tool)
       })
     );
   }
 });
 
-// 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);
+// src/commands/enhance-labelstudio/impl.ts
+var impl_exports = {};
+__export(impl_exports, {
+  enhanceLabelStudio: () => enhanceLabelStudio
+});
+async function enhanceLabelStudio(flags, ...inputDirs) {
+  const {
+    outDir = OUTPUT_BASE_DIR,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_LABEL_STUDIO_PRECISION
+  } = flags;
+  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(".json")) {
+        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 labelStudioData = JSON.parse(fileData);
+        const { data, isFull } = isLabelStudioFullJSON(labelStudioData);
+        const enhanced = await enhanceLabelStudioData(data, isFull, {
+          sortVertical,
+          sortHorizontal,
+          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+          widthIncrement,
+          heightIncrement,
+          precision
+        });
+        const outputFilePath = (0, import_path.join)(outDir, file);
+        await (0, import_promises.writeFile)(
+          outputFilePath,
+          JSON.stringify(enhanced, null, 2),
+          "utf-8"
+        );
+        console.log(import_chalk.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+      } catch (error) {
+        console.error(
+          import_chalk.default.red(`Error processing file ${file}:`),
+          error instanceof Error ? error.message : String(error)
+        );
+      }
     }
   }
-  return {
-    x: (minX + maxX) / 2,
-    y: (minY + maxY) / 2,
-    width: maxX - minX,
-    height: maxY - minY
-  };
+  console.log(import_chalk.default.green("\n\u2713 Enhancement complete!"));
 }
-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;
+var import_promises, import_path, import_chalk, isLabelStudioFullJSON;
+var init_impl = __esm({
+  "src/commands/enhance-labelstudio/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_label_studio();
+    init_schema();
+    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 };
         }
       }
-      if (!addedToColumn) {
-        columns.push([item]);
+      const parsedMin = MinOCRLabelStudioSchema.safeParse(data);
+      if (parsedMin.success) {
+        return { isFull: false, data: parsedMin.data };
       }
-    }
-    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);
+      throw new Error("Input data is not valid Label Studio JSON format.");
+    };
   }
-  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;
+});
+
+// src/commands/enhance-ppocr/impl.ts
+var impl_exports2 = {};
+__export(impl_exports2, {
+  enhancePPOCR: () => enhancePPOCR
+});
+async function enhancePPOCR(flags, ...inputDirs) {
+  const {
+    outDir = OUTPUT_BASE_DIR,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_PPOCR_PRECISION
+  } = 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(".txt")) {
+        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 lines = fileData.trim().split("\n");
+        const enhancedLines = [];
+        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);
+          const enhanced = enhancePPOCRLabel(annotations, {
+            sortVertical,
+            sortHorizontal,
+            normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+            widthIncrement,
+            heightIncrement,
+            precision
+          });
+          PPOCRLabelSchema.parse(enhanced);
+          const jsonArray = JSON.stringify(enhanced);
+          enhancedLines.push(`${imagePath}	${jsonArray}`);
+        }
+        const outputFilePath = (0, import_path2.join)(outDir, file);
+        await (0, import_promises2.writeFile)(outputFilePath, enhancedLines.join("\n"), "utf-8");
+        console.log(import_chalk2.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+      } catch (error) {
+        console.error(
+          import_chalk2.default.red(`Error processing file ${file}:`),
+          error instanceof Error ? error.message : String(error)
+        );
       }
     }
-    if (horizontalSort !== SORT_HORIZONTAL_NONE) {
-      return horizontalSort === SORT_HORIZONTAL_LTR ? centerA.x - centerB.x : centerB.x - centerA.x;
-    }
-    return 0;
-  });
-  return sorted;
+  }
+  console.log(import_chalk2.default.green("\n\u2713 Enhancement complete!"));
 }
-var GROUPING_TOLERANCE;
-var init_sort = __esm({
-  "src/lib/sort.ts"() {
+var import_promises2, import_path2, import_chalk2;
+var init_impl2 = __esm({
+  "src/commands/enhance-ppocr/impl.ts"() {
     "use strict";
     init_cjs_shims();
+    import_promises2 = require("fs/promises");
+    import_path2 = require("path");
+    import_chalk2 = __toESM(require("chalk"), 1);
     init_constants();
-    GROUPING_TOLERANCE = 50;
+    init_enhance();
+    init_schema();
+  }
+});
+
+// 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();
+    init_geometry();
+    ppocrToLabelStudio = async (data, options) => {
+      const {
+        imagePath,
+        baseServerUrl,
+        inputDir,
+        toFullJson = true,
+        taskId = 1,
+        labelName = DEFAULT_LABEL_NAME,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = DEFAULT_LABEL_STUDIO_PRECISION
+      } = options || {};
+      if (toFullJson) {
+        return ppocrToFullLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          taskId,
+          labelName,
+          normalizeShape2,
+          widthIncrement,
+          heightIncrement,
+          precision
+        );
+      } else {
+        return ppocrToMinLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          labelName,
+          normalizeShape2,
+          widthIncrement,
+          heightIncrement,
+          precision
+        );
+      }
+    };
+    ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId = 1, labelName = DEFAULT_LABEL_NAME, normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION) => {
+      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) => {
+                let { points } = item;
+                points = transformPoints(points, {
+                  normalizeShape: normalizeShape2,
+                  widthIncrement,
+                  heightIncrement
+                });
+                const annotationId = (0, import_node_crypto.randomUUID)().slice(0, 10);
+                const polygonPoints = points.map(([x, y]) => [
+                  roundToPrecision((x ?? 0) / original_width * 100, precision),
+                  roundToPrecision((y ?? 0) / original_height * 100, precision)
+                ]);
+                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", normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION) => {
+      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) => {
+        let { points } = item;
+        points = transformPoints(points, {
+          normalizeShape: normalizeShape2,
+          widthIncrement,
+          heightIncrement
+        });
+        const roundedPoints = points.map(
+          ([x, y]) => [
+            roundToPrecision(x ?? 0, precision),
+            roundToPrecision(y ?? 0, precision)
+          ]
+        );
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const point of roundedPoints) {
+          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: roundedPoints,
+              closed: true,
+              labels: [labelName],
+              original_width,
+              original_height
+            }
+          ],
+          transcription: [item.transcription],
+          poly: [
+            {
+              points: roundedPoints,
+              closed: true,
+              original_width,
+              original_height
+            }
+          ],
+          annotator: 1,
+          annotation_id: index + 1,
+          created_at: now,
+          updated_at: now,
+          lead_time: 0
+        };
+      });
+    };
   }
 });
 
 // src/commands/toLabelStudio/impl.ts
-var impl_exports = {};
-__export(impl_exports, {
+var impl_exports3 = {};
+__export(impl_exports3, {
   convertToLabelStudio: () => convertToLabelStudio
 });
 async function convertToLabelStudio(flags, ...inputDirs) {
@@ -742,21 +1428,25 @@ async function convertToLabelStudio(flags, ...inputDirs) {
     fileListName = DEFAULT_FILE_LIST_NAME,
     baseServerUrl = DEFAULT_BASE_SERVER_URL,
     sortVertical = DEFAULT_SORT_VERTICAL,
-    sortHorizontal = DEFAULT_SORT_HORIZONTAL
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_LABEL_STUDIO_PRECISION
   } = flags;
   const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
-  await (0, import_promises.mkdir)(outDir, { recursive: true });
+  await (0, import_promises3.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);
+    console.log(import_chalk3.default.blue(`Processing input directory: ${inputDir}`));
+    const files = await (0, import_promises3.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}`));
+      const filePath = (0, import_path3.join)(inputDir, file);
+      console.log(import_chalk3.default.gray(`Processing file: ${file}`));
       try {
-        const fileData = await (0, import_promises.readFile)(filePath, "utf-8");
+        const fileData = await (0, import_promises3.readFile)(filePath, "utf-8");
         const lines = fileData.trim().split("\n");
         const imageDataMap = /* @__PURE__ */ new Map();
         for (const line of lines) {
@@ -785,7 +1475,11 @@ async function convertToLabelStudio(flags, ...inputDirs) {
             baseServerUrl: newBaseServerUrl,
             inputDir,
             taskId,
-            labelName: defaultLabelName
+            labelName: defaultLabelName,
+            normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+            widthIncrement,
+            heightIncrement,
+            precision
           });
           if (toFullJson) {
             allLabelStudioData.push(labelStudioData[0]);
@@ -794,11 +1488,11 @@ async function convertToLabelStudio(flags, ...inputDirs) {
           }
           if (createFilePerImage) {
             const imageBaseName = imagePath.replace(/\//g, "_").replace(/\.[^.]+$/, "");
-            const individualOutputPath = (0, import_path.join)(
+            const individualOutputPath = (0, import_path3.join)(
               outDir,
               `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
             );
-            await (0, import_promises.writeFile)(
+            await (0, import_promises3.writeFile)(
               individualOutputPath,
               JSON.stringify(
                 toFullJson ? labelStudioData[0] : labelStudioData,
@@ -808,7 +1502,7 @@ async function convertToLabelStudio(flags, ...inputDirs) {
               "utf-8"
             );
             console.log(
-              import_chalk.default.gray(
+              import_chalk3.default.gray(
                 `  \u2713 Created individual file: ${individualOutputPath}`
               )
             );
@@ -819,43 +1513,43 @@ async function convertToLabelStudio(flags, ...inputDirs) {
           taskId++;
         }
         const baseName = file.replace(".txt", "");
-        const outputPath = (0, import_path.join)(
+        const outputPath = (0, import_path3.join)(
           outDir,
           `${baseName}_${toFullJson ? "full" : "min"}.json`
         );
-        await (0, import_promises.writeFile)(
+        await (0, import_promises3.writeFile)(
           outputPath,
           JSON.stringify(allLabelStudioData, null, 2),
           "utf-8"
         );
-        console.log(import_chalk.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+        console.log(import_chalk3.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");
+          const fileListPath = (0, import_path3.join)(outDir, fileListName);
+          await (0, import_promises3.writeFile)(fileListPath, fileList.join("\n"), "utf-8");
           console.log(
-            import_chalk.default.green(
+            import_chalk3.default.green(
               `\u2713 Created file list: ${fileListPath} (${fileList.length} files)`
             )
           );
         }
       } catch (error) {
         console.error(
-          import_chalk.default.red(`\u2717 Failed to process ${file}:`),
+          import_chalk3.default.red(`\u2717 Failed to process ${file}:`),
           error instanceof Error ? error.message : error
         );
       }
     }
   }
-  console.log(import_chalk.default.green("\n\u2713 Conversion completed!"));
+  console.log(import_chalk3.default.green("\n\u2713 Conversion completed!"));
 }
-var import_promises, import_path, import_chalk;
-var init_impl = __esm({
+var import_promises3, import_path3, import_chalk3;
+var init_impl3 = __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);
+    import_promises3 = require("fs/promises");
+    import_path3 = require("path");
+    import_chalk3 = __toESM(require("chalk"), 1);
     init_constants();
     init_ppocr_label();
     init_schema();
@@ -863,147 +1557,9 @@ var init_impl = __esm({
   }
 });
 
-// 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, {
+var impl_exports4 = {};
+__export(impl_exports4, {
   convertToPPOCR: () => convertToPPOCR
 });
 async function convertToPPOCR(flags, ...inputDirs) {
@@ -1012,26 +1568,39 @@ async function convertToPPOCR(flags, ...inputDirs) {
     fileName = DEFAULT_PPOCR_FILE_NAME,
     baseImageDir,
     sortVertical = DEFAULT_SORT_VERTICAL,
-    sortHorizontal = DEFAULT_SORT_HORIZONTAL
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_PPOCR_PRECISION
   } = flags;
-  await (0, import_promises2.mkdir)(outDir, { recursive: true });
+  await (0, import_promises4.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);
+    console.log(import_chalk4.default.blue(`Processing input directory: ${inputDir}`));
+    const files = await (0, import_promises4.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}`));
+      const filePath = (0, import_path4.join)(inputDir, file);
+      console.log(import_chalk4.default.gray(`Processing file: ${file}`));
       try {
-        const fileData = await (0, import_promises2.readFile)(filePath, "utf-8");
+        const fileData = await (0, import_promises4.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 { data, isFull } = isLabelStudioFullJSON2(labelStudioData);
+        const ppocrDataMap = isFull ? await labelStudioToPPOCR(data, {
+          baseImageDir,
+          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+          widthIncrement,
+          heightIncrement,
+          precision
+        }) : await minLabelStudioToPPOCR(data, {
+          baseImageDir,
+          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+          widthIncrement,
+          heightIncrement,
+          precision
+        });
         const outputLines = [];
         for (const [imagePath, annotations] of ppocrDataMap.entries()) {
           const sortedAnnotations = sortBoundingBoxes(
@@ -1044,32 +1613,32 @@ async function convertToPPOCR(flags, ...inputDirs) {
           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}`));
+        const outputPath = (0, import_path4.join)(outDir, `${baseName}_${fileName}`);
+        await (0, import_promises4.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
+        console.log(import_chalk4.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
       } catch (error) {
         console.error(
-          import_chalk2.default.red(`\u2717 Failed to process ${file}:`),
+          import_chalk4.default.red(`\u2717 Failed to process ${file}:`),
           error instanceof Error ? error.message : error
         );
       }
     }
   }
-  console.log(import_chalk2.default.green("\n\u2713 Conversion completed!"));
+  console.log(import_chalk4.default.green("\n\u2713 Conversion completed!"));
 }
-var import_promises2, import_path2, import_chalk2, isLabelStudioFullJSON;
-var init_impl2 = __esm({
+var import_promises4, import_path4, import_chalk4, isLabelStudioFullJSON2;
+var init_impl4 = __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);
+    import_promises4 = require("fs/promises");
+    import_path4 = require("path");
+    import_chalk4 = __toESM(require("chalk"), 1);
     init_constants();
     init_label_studio();
     init_schema();
     init_sort();
-    isLabelStudioFullJSON = (data) => {
+    isLabelStudioFullJSON2 = (data) => {
       const parsedFull = FullOCRLabelStudioSchema.safeParse(data);
       if (parsedFull.success) {
         return { isFull: true, data: parsedFull.data };
@@ -1091,24 +1660,160 @@ var init_impl2 = __esm({
 
 // src/bin/bash-complete.ts
 init_cjs_shims();
-var import_core4 = require("@stricli/core");
+var import_core6 = require("@stricli/core");
 
 // src/app.ts
 init_cjs_shims();
 var import_auto_complete = require("@stricli/auto-complete");
-var import_core3 = require("@stricli/core");
+var import_core5 = require("@stricli/core");
 
 // package.json
-var version = "1.0.0";
+var version = "1.2.0";
 var description = "Convert between Label Studio OCR format and PPOCRLabelv2 format";
 
-// src/commands/toLabelStudio/command.ts
+// src/commands/enhance-labelstudio/command.ts
 init_cjs_shims();
 var import_core = require("@stricli/core");
 init_constants();
-var toLabelStudioCommand = (0, import_core.buildCommand)({
+var enhanceLabelStudioCommand = (0, import_core.buildCommand)({
+  loader: async () => {
+    const { enhanceLabelStudio: enhanceLabelStudio2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
+    return enhanceLabelStudio2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing Label Studio JSON files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: `Output directory. Default: "${OUTPUT_BASE_DIR}"`,
+        parse: String,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
+        parse: String,
+        optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_LABEL_STUDIO_PRECISION}`,
+        parse: Number,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Enhance Label Studio files with sorting, normalization, and resizing"
+  }
+});
+
+// src/commands/enhance-ppocr/command.ts
+init_cjs_shims();
+var import_core2 = require("@stricli/core");
+init_constants();
+var enhancePPOCRCommand = (0, import_core2.buildCommand)({
+  loader: async () => {
+    const { enhancePPOCR: enhancePPOCR2 } = await Promise.resolve().then(() => (init_impl2(), impl_exports2));
+    return enhancePPOCR2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing PPOCRLabel files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: `Output directory. Default: "${OUTPUT_BASE_DIR}"`,
+        parse: String,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
+        parse: String,
+        optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_PPOCR_PRECISION} (integers)`,
+        parse: Number,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Enhance PPOCRLabel files with sorting, normalization, and resizing"
+  }
+});
+
+// src/commands/toLabelStudio/command.ts
+init_cjs_shims();
+var import_core3 = require("@stricli/core");
+init_constants();
+var toLabelStudioCommand = (0, import_core3.buildCommand)({
   loader: async () => {
-    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
+    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl3(), impl_exports3));
     return convertToLabelStudio2;
   },
   parameters: {
@@ -1123,54 +1828,78 @@ var toLabelStudioCommand = (0, import_core.buildCommand)({
     flags: {
       outDir: {
         kind: "parsed",
-        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        brief: `Output directory. Default: "${OUTPUT_BASE_DIR}"`,
         parse: String,
         optional: true
       },
       defaultLabelName: {
         kind: "parsed",
-        brief: `Default label name for text annotations. Default to "${DEFAULT_LABEL_NAME}"`,
+        brief: `Default label name for text annotations. Default: "${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}"`,
+        brief: `Convert to Full OCR Label Studio format. Default: "${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}"`,
+        brief: `Create a separate Label Studio JSON file for each image. Default: "${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}"`,
+        brief: `Create a file list for serving in Label Studio. Default: "${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}"`,
+        brief: `Name of the file list for serving. Default: "${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}"`,
+        brief: `Base server URL for constructing image URLs in the file list. Default: "${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}"`,
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
         parse: String,
         optional: true
       },
       sortHorizontal: {
         kind: "parsed",
-        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
         parse: String,
         optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_LABEL_STUDIO_PRECISION}`,
+        parse: Number,
+        optional: true
       }
     }
   },
@@ -1181,11 +1910,11 @@ var toLabelStudioCommand = (0, import_core.buildCommand)({
 
 // src/commands/toPPOCR/commands.ts
 init_cjs_shims();
-var import_core2 = require("@stricli/core");
+var import_core4 = require("@stricli/core");
 init_constants();
-var toPPOCRCommand = (0, import_core2.buildCommand)({
+var toPPOCRCommand = (0, import_core4.buildCommand)({
   loader: async () => {
-    const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl2(), impl_exports2));
+    const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl4(), impl_exports4));
     return convertToPPOCR2;
   },
   parameters: {
@@ -1200,13 +1929,13 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
     flags: {
       outDir: {
         kind: "parsed",
-        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        brief: `Output directory. Default: "${OUTPUT_BASE_DIR}"`,
         parse: String,
         optional: true
       },
       fileName: {
         kind: "parsed",
-        brief: `Output PPOCR file name. Default to "${DEFAULT_PPOCR_FILE_NAME}"`,
+        brief: `Output PPOCR file name. Default: "${DEFAULT_PPOCR_FILE_NAME}"`,
         parse: String,
         optional: true
       },
@@ -1218,15 +1947,39 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
       },
       sortVertical: {
         kind: "parsed",
-        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}" (default), "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}"`,
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
         parse: String,
         optional: true
       },
       sortHorizontal: {
         kind: "parsed",
-        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
         parse: String,
         optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_PPOCR_PRECISION} (integers)`,
+        parse: Number,
+        optional: true
       }
     }
   },
@@ -1236,10 +1989,12 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
 });
 
 // src/app.ts
-var routes = (0, import_core3.buildRouteMap)({
+var routes = (0, import_core5.buildRouteMap)({
   routes: {
     toLabelStudio: toLabelStudioCommand,
     toPPOCR: toPPOCRCommand,
+    "enhance-labelstudio": enhanceLabelStudioCommand,
+    "enhance-ppocr": enhancePPOCRCommand,
     install: (0, import_auto_complete.buildInstallCommand)("label-studio-converter", {
       bash: "__label-studio-converter_bash_complete"
     }),
@@ -1253,7 +2008,7 @@ var routes = (0, import_core3.buildRouteMap)({
     }
   }
 });
-var app = (0, import_core3.buildApplication)(routes, {
+var app = (0, import_core5.buildApplication)(routes, {
   name: "label-studio-converter",
   versionInfo: {
     currentVersion: version
@@ -1280,9 +2035,9 @@ function buildContext(process2) {
   if (process.env.COMP_LINE?.endsWith(" ")) {
     inputs.push("");
   }
-  await (0, import_core4.proposeCompletions)(app, inputs, buildContext(process));
+  await (0, import_core6.proposeCompletions)(app, inputs, buildContext(process));
   try {
-    for (const { completion } of await (0, import_core4.proposeCompletions)(
+    for (const { completion } of await (0, import_core6.proposeCompletions)(
       app,
       inputs,
       buildContext(process)