label-studio-converter 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,6 +1,560 @@
+// src/lib/schema.ts
+import z from "zod";
+var 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([
+            // Most specific rectangle variants first (with text or labels)
+            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({
+                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()
+            }),
+            // Base rectangle without text or labels
+            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()
+            }),
+            // Most specific polygon variants first (with text or labels)
+            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()
+            }),
+            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()
+            }),
+            // Base polygon without text or labels
+            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()
+            })
+          ])
+        ),
+        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([
+            // Most specific rectangle variants first (with text or labels)
+            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({
+                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()
+            }),
+            // Base rectangle without text or labels
+            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()
+            }),
+            // Most specific polygon variants first (with text or labels)
+            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()
+            }),
+            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()
+            }),
+            // Base polygon without text or labels
+            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()
+            })
+          ])
+        ),
+        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())
+  })
+);
+var 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()
+      })
+    ).optional().default([]),
+    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()
+        })
+      ])
+    ).optional().default([]),
+    transcription: z.union([z.string(), z.array(z.string())]).optional().transform((val) => {
+      if (!val) return [];
+      return Array.isArray(val) ? val : [val];
+    }),
+    poly: z.array(
+      z.object({
+        points: z.array(z.array(z.number())),
+        closed: z.boolean(),
+        original_width: z.number(),
+        original_height: z.number()
+      })
+    ).optional().default([]),
+    annotator: z.number(),
+    annotation_id: z.number(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    lead_time: z.number()
+  })
+);
+var PPOCRLabelSchema = z.array(
+  z.object({
+    transcription: z.string(),
+    points: z.array(z.array(z.number())),
+    dt_score: z.number().optional(),
+    // Detection score (from PaddleOCR)
+    difficult: z.boolean().optional()
+    // Difficult flag (from PPOCRLabel tool)
+  })
+);
+
 // src/lib/label-studio.ts
 import * as turf from "@turf/turf";
-var labelStudioToPPOCR = async (data, baseImageDir) => {
+
+// 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;
+}
+
+// src/constants.ts
+var DEFAULT_LABEL_NAME = "Text";
+var SORT_VERTICAL_NONE = "none";
+var SORT_VERTICAL_TOP_BOTTOM = "top-bottom";
+var SORT_HORIZONTAL_NONE = "none";
+var SORT_HORIZONTAL_LTR = "ltr";
+var SORT_HORIZONTAL_RTL = "rtl";
+var DEFAULT_LABEL_STUDIO_PRECISION = -1;
+
+// src/lib/sort.ts
+var GROUPING_TOLERANCE = 50;
+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;
+}
+
+// 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;
+}
+function hasEnhancementOptions(options) {
+  return !!(options.sortVertical || options.sortHorizontal || options.normalizeShape || options.widthIncrement !== 0 || options.heightIncrement !== 0);
+}
+
+// src/lib/label-studio.ts
+var 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 || "";
@@ -51,6 +605,12 @@ var labelStudioToPPOCR = async (data, baseImageDir) => {
           }
         }
         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];
@@ -76,7 +636,14 @@ var labelStudioToPPOCR = async (data, baseImageDir) => {
   }
   return resultMap;
 };
-var minLabelStudioToPPOCR = async (data, baseImageDir) => {
+var 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 || "";
@@ -88,57 +655,242 @@ var minLabelStudioToPPOCR = async (data, baseImageDir) => {
     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));
+    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 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]
+          ];
+        }
       }
-    } catch {
-      dt_score = 0.8;
-    }
-    const annotation = {
-      transcription: transcription ?? "",
-      points,
-      dt_score
-    };
-    if (!resultMap.has(imagePath)) {
-      resultMap.set(imagePath, []);
+      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);
     }
-    resultMap.get(imagePath).push(annotation);
   }
   return resultMap;
 };
+var 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);
+        }
+        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);
+          }
+        }
+        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]
+          ];
+        }
+        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;
+    });
+  }
+};
 
 // src/lib/ppocr-label.ts
 import { randomUUID } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import sizeOf from "image-size";
-
-// src/constants.ts
-var DEFAULT_LABEL_NAME = "Text";
-
-// src/lib/ppocr-label.ts
 var ppocrToLabelStudio = async (data, options) => {
   const {
     imagePath,
@@ -146,7 +898,11 @@ var ppocrToLabelStudio = async (data, options) => {
     inputDir,
     toFullJson = true,
     taskId = 1,
-    labelName = DEFAULT_LABEL_NAME
+    labelName = DEFAULT_LABEL_NAME,
+    normalizeShape: normalizeShape2,
+    widthIncrement = 0,
+    heightIncrement = 0,
+    precision = DEFAULT_LABEL_STUDIO_PRECISION
   } = options || {};
   if (toFullJson) {
     return ppocrToFullLabelStudio(
@@ -155,7 +911,11 @@ var ppocrToLabelStudio = async (data, options) => {
       baseServerUrl,
       inputDir,
       taskId,
-      labelName
+      labelName,
+      normalizeShape2,
+      widthIncrement,
+      heightIncrement,
+      precision
     );
   } else {
     return ppocrToMinLabelStudio(
@@ -163,11 +923,15 @@ var ppocrToLabelStudio = async (data, options) => {
       imagePath,
       baseServerUrl,
       inputDir,
-      labelName
+      labelName,
+      normalizeShape2,
+      widthIncrement,
+      heightIncrement,
+      precision
     );
   }
 };
-var ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId = 1, labelName = DEFAULT_LABEL_NAME) => {
+var 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;
@@ -194,11 +958,16 @@ var ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId =
           id: taskId,
           completed_by: 1,
           result: data.map((item) => {
-            const { points } = item;
+            let { points } = item;
+            points = transformPoints(points, {
+              normalizeShape: normalizeShape2,
+              widthIncrement,
+              heightIncrement
+            });
             const annotationId = randomUUID().slice(0, 10);
             const polygonPoints = points.map(([x, y]) => [
-              (x ?? 0) / original_width * 100,
-              (y ?? 0) / original_height * 100
+              roundToPrecision((x ?? 0) / original_width * 100, precision),
+              roundToPrecision((y ?? 0) / original_height * 100, precision)
             ]);
             return [
               // 1. Polygon geometry only
@@ -292,7 +1061,7 @@ var ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId =
   ];
   return result;
 };
-var ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName = "text") => {
+var 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;
@@ -311,12 +1080,23 @@ var ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName
   original_width = dimensions.width;
   original_height = dimensions.height;
   return data.map((item, index) => {
-    const { points } = item;
+    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 points) {
+    for (const point of roundedPoints) {
       const [x, y] = point;
       if (x !== void 0 && y !== void 0) {
         minX = Math.min(minX, x);
@@ -343,7 +1123,7 @@ var ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName
       ],
       label: [
         {
-          points,
+          points: roundedPoints,
           closed: true,
           labels: [labelName],
           original_width,
@@ -353,7 +1133,7 @@ var ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName
       transcription: [item.transcription],
       poly: [
         {
-          points,
+          points: roundedPoints,
           closed: true,
           original_width,
           original_height
@@ -368,10 +1148,24 @@ var ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName
   });
 };
 export {
+  FullOCRLabelStudioSchema,
+  MinOCRLabelStudioSchema,
+  PPOCRLabelSchema,
+  calculateCenter,
+  enhanceLabelStudioData,
+  enhancePPOCRLabel,
+  getMinimumBoundingRect,
+  hasEnhancementOptions,
   labelStudioToPPOCR,
   minLabelStudioToPPOCR,
+  normalizeShape,
   ppocrToFullLabelStudio,
   ppocrToLabelStudio,
-  ppocrToMinLabelStudio
+  ppocrToMinLabelStudio,
+  resizeBoundingBox,
+  roundPoints,
+  roundToPrecision,
+  sortBoundingBoxes,
+  transformPoints
 };
 //# sourceMappingURL=index.js.map