label-studio-converter 1.4.0 → 1.5.0

package/dist/bash-complete.cjs

@@ -30,15 +30,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+// node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@6.0.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js"() {
+  "node_modules/.pnpm/tsup@8.5.1_jiti@2.4.2_postcss@8.5.6_typescript@6.0.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
 
 // src/constants.ts
-var DEFAULT_DETECT_IMAGE_SIZE, 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_USE_ORIENTED_BOX, DEFAULT_WIDTH_INCREMENT, DEFAULT_HEIGHT_INCREMENT, DEFAULT_ADAPT_RESIZE_THRESHOLD, DEFAULT_ADAPT_RESIZE_MARGIN, DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE, DEFAULT_ADAPT_RESIZE_MAX_COMPONENT_SIZE, DEFAULT_ADAPT_RESIZE_OUTLIER_PERCENTILE, DEFAULT_ADAPT_RESIZE_MORPHOLOGY_SIZE, DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION, DEFAULT_ADAPT_RESIZE_TIMEOUT_MS, DEFAULT_ADAPT_RESIZE_MAX_BOX_SIZE, DEFAULT_LABEL_STUDIO_PRECISION, DEFAULT_PPOCR_PRECISION, DEFAULT_RECURSIVE, DEFAULT_PPOCR_FILE_PATTERN, DEFAULT_LABEL_STUDIO_FILE_PATTERN, OUTPUT_MODE_ANNOTATIONS, OUTPUT_MODE_PREDICTIONS, DEFAULT_OUTPUT_MODE, DEFAULT_BACKUP, BACKUP_SUFFIX_PREFIX, DEFAULT_COPY_IMAGES;
+var DEFAULT_DETECT_IMAGE_SIZE, 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_USE_ORIENTED_BOX, DEFAULT_WIDTH_INCREMENT, DEFAULT_HEIGHT_INCREMENT, DEFAULT_ADAPT_RESIZE, DEFAULT_ADAPT_RESIZE_THRESHOLD, DEFAULT_ADAPT_RESIZE_MARGIN, DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE, DEFAULT_ADAPT_RESIZE_MAX_COMPONENT_SIZE, DEFAULT_ADAPT_RESIZE_OUTLIER_PERCENTILE, DEFAULT_ADAPT_RESIZE_MORPHOLOGY_SIZE, DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION, DEFAULT_ADAPT_RESIZE_TIMEOUT_MS, DEFAULT_ADAPT_RESIZE_MAX_BOX_SIZE, DEFAULT_ADAPT_RESIZE_PADDING_CHECK_WIDTH, DEFAULT_ADAPT_RESIZE_MIN_PADDING_BRIGHTNESS, DEFAULT_ADAPT_RESIZE_MIN_PADDING_RATIO, DEFAULT_ADAPT_RESIZE_USE_ADAPTIVE_THRESHOLD, DEFAULT_ADAPT_RESIZE_ADAPTIVE_BLOCK_SIZE, DEFAULT_LABEL_STUDIO_PRECISION, DEFAULT_PPOCR_PRECISION, DEFAULT_RECURSIVE, DEFAULT_PPOCR_FILE_PATTERN, DEFAULT_LABEL_STUDIO_FILE_PATTERN, OUTPUT_MODE_ANNOTATIONS, OUTPUT_MODE_PREDICTIONS, DEFAULT_OUTPUT_MODE, DEFAULT_BACKUP, BACKUP_SUFFIX_PREFIX, DEFAULT_COPY_IMAGES, IMAGE_BASE_DIR_TASK_FILE, IMAGE_BASE_DIR_INPUT_DIR, DEFAULT_IMAGE_BASE_DIR, DEFAULT_LABEL_STUDIO_OUTPUT_IMAGE_BASE_DIR;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -65,6 +65,7 @@ var init_constants = __esm({
     DEFAULT_USE_ORIENTED_BOX = false;
     DEFAULT_WIDTH_INCREMENT = 0;
     DEFAULT_HEIGHT_INCREMENT = 0;
+    DEFAULT_ADAPT_RESIZE = false;
     DEFAULT_ADAPT_RESIZE_THRESHOLD = 128;
     DEFAULT_ADAPT_RESIZE_MARGIN = 5;
     DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE = 10;
@@ -72,8 +73,13 @@ var init_constants = __esm({
     DEFAULT_ADAPT_RESIZE_OUTLIER_PERCENTILE = 2;
     DEFAULT_ADAPT_RESIZE_MORPHOLOGY_SIZE = 2;
     DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION = 50;
-    DEFAULT_ADAPT_RESIZE_TIMEOUT_MS = 3e4;
+    DEFAULT_ADAPT_RESIZE_TIMEOUT_MS = 15e3;
     DEFAULT_ADAPT_RESIZE_MAX_BOX_SIZE = 3e3;
+    DEFAULT_ADAPT_RESIZE_PADDING_CHECK_WIDTH = 3;
+    DEFAULT_ADAPT_RESIZE_MIN_PADDING_BRIGHTNESS = 200;
+    DEFAULT_ADAPT_RESIZE_MIN_PADDING_RATIO = 0.85;
+    DEFAULT_ADAPT_RESIZE_USE_ADAPTIVE_THRESHOLD = true;
+    DEFAULT_ADAPT_RESIZE_ADAPTIVE_BLOCK_SIZE = 50;
     DEFAULT_LABEL_STUDIO_PRECISION = -1;
     DEFAULT_PPOCR_PRECISION = 0;
     DEFAULT_RECURSIVE = false;
@@ -85,6 +91,10 @@ var init_constants = __esm({
     DEFAULT_BACKUP = false;
     BACKUP_SUFFIX_PREFIX = "backup-";
     DEFAULT_COPY_IMAGES = true;
+    IMAGE_BASE_DIR_TASK_FILE = "task-file";
+    IMAGE_BASE_DIR_INPUT_DIR = "input-dir";
+    DEFAULT_IMAGE_BASE_DIR = IMAGE_BASE_DIR_TASK_FILE;
+    DEFAULT_LABEL_STUDIO_OUTPUT_IMAGE_BASE_DIR = "/data/local-files/?d=";
   }
 });
 
@@ -92,11 +102,17 @@ var init_constants = __esm({
 function withOptions(fn, options) {
   return [fn, options];
 }
-var Processor;
+var defaultResolveInputImagePath, defaultResolveOutputImagePath, Processor;
 var init_processor = __esm({
   "src/lib/processor.ts"() {
     "use strict";
     init_cjs_shims();
+    defaultResolveInputImagePath = (taskImagePath) => {
+      return taskImagePath;
+    };
+    defaultResolveOutputImagePath = (taskImagePath) => {
+      return taskImagePath;
+    };
     Processor = class {
       input;
       output;
@@ -113,8 +129,8 @@ var init_processor = __esm({
       async process({
         inputData,
         taskFilePath,
-        resolveInputImagePath,
-        resolveOutputImagePath
+        resolveInputImagePath = defaultResolveInputImagePath,
+        resolveOutputImagePath = defaultResolveOutputImagePath
       }) {
         const [inputFn, inputOptions] = Array.isArray(this.input) ? this.input : [this.input, void 0];
         const [outputFn, outputOptions] = Array.isArray(this.output) ? this.output : [this.output, void 0];
@@ -540,10 +556,62 @@ function withTimeout(promise, timeoutMs, timeoutValue) {
   return Promise.race([
     promise,
     new Promise(
-      (resolve3) => setTimeout(() => resolve3(timeoutValue), timeoutMs)
+      (resolve4) => setTimeout(() => resolve4(timeoutValue), timeoutMs)
     )
   ]);
 }
+function calculateAdaptiveThreshold(grayscaleData, width, height) {
+  const histogram = new Array(256).fill(0);
+  for (let i = 0; i < grayscaleData.length; i++) {
+    const pixelValue = grayscaleData[i];
+    if (pixelValue !== void 0) {
+      histogram[pixelValue]++;
+    }
+  }
+  const totalPixels = width * height;
+  let sum = 0;
+  for (let i = 0; i < 256; i++) {
+    sum += i * histogram[i];
+  }
+  let sumB = 0;
+  let wB = 0;
+  let wF = 0;
+  let maxVariance = 0;
+  let threshold = 0;
+  for (let t = 0; t < 256; t++) {
+    wB += histogram[t];
+    if (wB === 0) continue;
+    wF = totalPixels - wB;
+    if (wF === 0) break;
+    sumB += t * histogram[t];
+    const mB = sumB / wB;
+    const mF = (sum - sumB) / wF;
+    const variance = wB * wF * (mB - mF) * (mB - mF);
+    if (variance > maxVariance) {
+      maxVariance = variance;
+      threshold = t;
+    }
+  }
+  return Math.max(100, Math.min(200, threshold + 10));
+}
+function validatePaddingStrip(grayscaleData, x1, y1, x2, y2, width, height, minBrightness, minRatio) {
+  let totalPixels = 0;
+  let whitePixels = 0;
+  for (let y = Math.floor(y1); y <= Math.ceil(y2); y++) {
+    for (let x = Math.floor(x1); x <= Math.ceil(x2); x++) {
+      if (x >= 0 && x < width && y >= 0 && y < height) {
+        totalPixels++;
+        const idx = y * width + x;
+        const pixelValue = grayscaleData[idx];
+        if (pixelValue !== void 0 && pixelValue >= minBrightness) {
+          whitePixels++;
+        }
+      }
+    }
+  }
+  if (totalPixels === 0) return false;
+  return whitePixels / totalPixels >= minRatio;
+}
 async function adaptiveResizeBoundingBox(points, imagePath, options) {
   if (points.length === 0 || !(0, import_node_fs.existsSync)(imagePath)) {
     return points;
@@ -555,7 +623,11 @@ async function adaptiveResizeBoundingBox(points, imagePath, options) {
     maxComponentSize = DEFAULT_ADAPT_RESIZE_MAX_COMPONENT_SIZE,
     outlierPercentile = DEFAULT_ADAPT_RESIZE_OUTLIER_PERCENTILE,
     morphologySize = DEFAULT_ADAPT_RESIZE_MORPHOLOGY_SIZE,
-    maxHorizontalExpansion = DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION
+    maxHorizontalExpansion = DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION,
+    paddingCheckWidth = DEFAULT_ADAPT_RESIZE_PADDING_CHECK_WIDTH,
+    minPaddingBrightness = DEFAULT_ADAPT_RESIZE_MIN_PADDING_BRIGHTNESS,
+    minPaddingRatio = DEFAULT_ADAPT_RESIZE_MIN_PADDING_RATIO,
+    useAdaptiveThreshold = DEFAULT_ADAPT_RESIZE_USE_ADAPTIVE_THRESHOLD
   } = options;
   try {
     const rotation = getBoxRotation(points);
@@ -600,14 +672,30 @@ async function adaptiveResizeBoundingBox(points, imagePath, options) {
     if (analysisW <= 0 || analysisH <= 0) {
       return points;
     }
-    const { data, info } = await image.extract({
+    const grayscaleImage = image.extract({
       left: analysisX,
       top: analysisY,
       width: analysisW,
       height: analysisH
-    }).grayscale().threshold(threshold).raw().toBuffer({ resolveWithObject: true });
+    }).grayscale();
+    const { data: grayscaleData, info: grayscaleInfo } = await grayscaleImage.raw().toBuffer({ resolveWithObject: true });
+    let actualThreshold = threshold;
+    if (useAdaptiveThreshold) {
+      actualThreshold = calculateAdaptiveThreshold(
+        grayscaleData,
+        grayscaleInfo.width,
+        grayscaleInfo.height
+      );
+    }
+    const { data: binaryData, info } = await (0, import_sharp.default)(grayscaleData, {
+      raw: {
+        width: grayscaleInfo.width,
+        height: grayscaleInfo.height,
+        channels: 1
+      }
+    }).threshold(actualThreshold).raw().toBuffer({ resolveWithObject: true });
     const morphed = morphologicalClosing(
-      data,
+      binaryData,
       info.width,
       info.height,
       morphologySize
@@ -616,7 +704,7 @@ async function adaptiveResizeBoundingBox(points, imagePath, options) {
       morphed,
       info.width,
       info.height,
-      threshold
+      actualThreshold
     );
     const validComponents = components.filter(
       (comp) => comp.size >= minComponentSize && comp.size <= maxComponentSize
@@ -643,10 +731,10 @@ async function adaptiveResizeBoundingBox(points, imagePath, options) {
     const minY = sortedY[0] || 0;
     const maxY = sortedY[sortedY.length - 1] || info.height - 1;
     const detectSeparator = createSeparatorDetector({
-      data,
+      data: binaryData,
       width: info.width,
       height: info.height,
-      threshold
+      threshold: actualThreshold
     });
     const originalBoxMinX = x - analysisX;
     const originalBoxMaxX = x - analysisX + w;
@@ -659,21 +747,142 @@ async function adaptiveResizeBoundingBox(points, imagePath, options) {
       detectSeparator,
       info.width
     );
-    const limitedMinX = Math.max(
+    let limitedMinX = Math.max(
       leftBoundary,
       originalBoxMinX - maxHorizontalExpansion
     );
-    const limitedMaxX = Math.min(
+    let limitedMaxX = Math.min(
       rightBoundary,
       originalBoxMaxX + maxHorizontalExpansion
     );
+    let limitedMinY = minY;
+    let limitedMaxY = maxY;
+    const leftPaddingValid = validatePaddingStrip(
+      grayscaleData,
+      limitedMinX,
+      limitedMinY,
+      Math.min(limitedMinX + paddingCheckWidth - 1, limitedMaxX),
+      limitedMaxY,
+      info.width,
+      info.height,
+      minPaddingBrightness,
+      minPaddingRatio
+    );
+    if (!leftPaddingValid && limitedMinX < originalBoxMinX) {
+      for (let i = 0; i < maxHorizontalExpansion; i++) {
+        limitedMinX++;
+        if (validatePaddingStrip(
+          grayscaleData,
+          limitedMinX,
+          limitedMinY,
+          Math.min(limitedMinX + paddingCheckWidth - 1, limitedMaxX),
+          limitedMaxY,
+          info.width,
+          info.height,
+          minPaddingBrightness,
+          minPaddingRatio
+        )) {
+          break;
+        }
+      }
+    }
+    const rightPaddingValid = validatePaddingStrip(
+      grayscaleData,
+      Math.max(limitedMaxX - paddingCheckWidth + 1, limitedMinX),
+      limitedMinY,
+      limitedMaxX,
+      limitedMaxY,
+      info.width,
+      info.height,
+      minPaddingBrightness,
+      minPaddingRatio
+    );
+    if (!rightPaddingValid && limitedMaxX > originalBoxMaxX) {
+      for (let i = 0; i < maxHorizontalExpansion; i++) {
+        limitedMaxX--;
+        if (validatePaddingStrip(
+          grayscaleData,
+          Math.max(limitedMaxX - paddingCheckWidth + 1, limitedMinX),
+          limitedMinY,
+          limitedMaxX,
+          limitedMaxY,
+          info.width,
+          info.height,
+          minPaddingBrightness,
+          minPaddingRatio
+        )) {
+          break;
+        }
+      }
+    }
+    const topPaddingValid = validatePaddingStrip(
+      grayscaleData,
+      limitedMinX,
+      limitedMinY,
+      limitedMaxX,
+      Math.min(limitedMinY + paddingCheckWidth - 1, limitedMaxY),
+      info.width,
+      info.height,
+      minPaddingBrightness,
+      minPaddingRatio
+    );
+    if (!topPaddingValid && limitedMinY > 0) {
+      for (let i = 0; i < 20; i++) {
+        limitedMinY++;
+        if (validatePaddingStrip(
+          grayscaleData,
+          limitedMinX,
+          limitedMinY,
+          limitedMaxX,
+          Math.min(limitedMinY + paddingCheckWidth - 1, limitedMaxY),
+          info.width,
+          info.height,
+          minPaddingBrightness,
+          minPaddingRatio
+        )) {
+          break;
+        }
+      }
+    }
+    const bottomPaddingValid = validatePaddingStrip(
+      grayscaleData,
+      limitedMinX,
+      Math.max(limitedMaxY - paddingCheckWidth + 1, limitedMinY),
+      limitedMaxX,
+      limitedMaxY,
+      info.width,
+      info.height,
+      minPaddingBrightness,
+      minPaddingRatio
+    );
+    if (!bottomPaddingValid && limitedMaxY < info.height - 1) {
+      for (let i = 0; i < 20; i++) {
+        limitedMaxY--;
+        if (validatePaddingStrip(
+          grayscaleData,
+          limitedMinX,
+          Math.max(limitedMaxY - paddingCheckWidth + 1, limitedMinY),
+          limitedMaxX,
+          limitedMaxY,
+          info.width,
+          info.height,
+          minPaddingBrightness,
+          minPaddingRatio
+        )) {
+          break;
+        }
+      }
+    }
     const newMinX = Math.max(0, analysisX + limitedMinX - margin);
-    const newMinY = Math.max(0, analysisY + minY - margin);
+    const newMinY = Math.max(0, analysisY + limitedMinY - margin);
     const newMaxX = Math.min(
       metadata.width,
       analysisX + limitedMaxX + 1 + margin
     );
-    const newMaxY = Math.min(metadata.height, analysisY + maxY + 1 + margin);
+    const newMaxY = Math.min(
+      metadata.height,
+      analysisY + limitedMaxY + 1 + margin
+    );
     if (isRotated) {
       const center = calculateCenter(points);
       const cos = Math.cos(rotation);
@@ -720,13 +929,18 @@ var init_adapt_resize = __esm({
     init_separator_detection();
     adaptResizeTransformer = (async (boxes, imageFilePath, options) => {
       const {
-        threshold = 128,
-        margin = 5,
-        minComponentSize = 10,
-        maxComponentSize = 1e5,
-        outlierPercentile = 2,
-        morphologySize = 2,
-        maxHorizontalExpansion = 50
+        threshold = DEFAULT_ADAPT_RESIZE_THRESHOLD,
+        margin = DEFAULT_ADAPT_RESIZE_MARGIN,
+        minComponentSize = DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE,
+        maxComponentSize = DEFAULT_ADAPT_RESIZE_MAX_COMPONENT_SIZE,
+        outlierPercentile = DEFAULT_ADAPT_RESIZE_OUTLIER_PERCENTILE,
+        morphologySize = DEFAULT_ADAPT_RESIZE_MORPHOLOGY_SIZE,
+        maxHorizontalExpansion = DEFAULT_ADAPT_RESIZE_MAX_HORIZONTAL_EXPANSION,
+        paddingCheckWidth = DEFAULT_ADAPT_RESIZE_PADDING_CHECK_WIDTH,
+        minPaddingBrightness = DEFAULT_ADAPT_RESIZE_MIN_PADDING_BRIGHTNESS,
+        minPaddingRatio = DEFAULT_ADAPT_RESIZE_MIN_PADDING_RATIO,
+        useAdaptiveThreshold = DEFAULT_ADAPT_RESIZE_USE_ADAPTIVE_THRESHOLD,
+        adaptiveBlockSize = DEFAULT_ADAPT_RESIZE_ADAPTIVE_BLOCK_SIZE
       } = options || {};
       if (boxes.length === 0) {
         return boxes;
@@ -734,6 +948,9 @@ var init_adapt_resize = __esm({
       console.log(
         `Processing ${boxes.length} boxes with adaptive resize for: ${imageFilePath}`
       );
+      if (useAdaptiveThreshold) {
+        console.log("  Using adaptive thresholding based on image histogram");
+      }
       const resized = await Promise.all(
         boxes.map(async (box, index) => {
           const newPoints = await withTimeout(
@@ -744,7 +961,12 @@ var init_adapt_resize = __esm({
               maxComponentSize,
               outlierPercentile,
               morphologySize,
-              maxHorizontalExpansion
+              maxHorizontalExpansion,
+              paddingCheckWidth,
+              minPaddingBrightness,
+              minPaddingRatio,
+              useAdaptiveThreshold,
+              adaptiveBlockSize
             }),
             DEFAULT_ADAPT_RESIZE_TIMEOUT_MS,
             box.points
@@ -1186,6 +1408,34 @@ var init_schema3 = __esm({
   }
 });
 
+// src/modules/label-studio-output/schema.ts
+var import_zod5, OutputLabelStudioSchema;
+var init_schema4 = __esm({
+  "src/modules/label-studio-output/schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod5 = __toESM(require("zod"), 1);
+    init_schema();
+    OutputLabelStudioSchema = AnnotationSchema.extend({
+      created_username: import_zod5.default.string(),
+      created_ago: import_zod5.default.string().optional(),
+      completed_by: import_zod5.default.object({
+        id: import_zod5.default.number(),
+        first_name: import_zod5.default.string(),
+        last_name: import_zod5.default.string(),
+        email: import_zod5.default.string()
+      }),
+      task: FullOCRLabelStudioSchema.omit({
+        annotations: true,
+        predictions: true,
+        drafts: true
+      }).extend({
+        overlap: import_zod5.default.number()
+      })
+    });
+  }
+});
+
 // src/lib/image.ts
 var import_node_fs2, import_promises, import_image_size, getImageDimensions;
 var init_image = __esm({
@@ -1616,6 +1866,68 @@ var init_output3 = __esm({
   }
 });
 
+// src/modules/label-studio-output/input.ts
+var import_es_toolkit3, OutputLabelStudioInput;
+var init_input4 = __esm({
+  "src/modules/label-studio-output/input.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_es_toolkit3 = require("es-toolkit");
+    init_geometry();
+    OutputLabelStudioInput = (async (inputTask, resolveImagePath) => {
+      const imageFilePath = await resolveImagePath(inputTask.task.data.ocr);
+      const { id, result, ...metadata } = inputTask;
+      const annoData = result;
+      const imageMeta = annoData?.find(
+        (item) => item.original_height !== void 0 && item.original_width !== void 0
+      );
+      let { original_height: imgHeight, original_width: imgWidth } = imageMeta ?? {};
+      const groupByAnnoId = (0, import_es_toolkit3.groupBy)(annoData || [], (item) => item.id);
+      return {
+        id: id.toString(),
+        height: imgHeight,
+        width: imgWidth,
+        imagePath: imageFilePath,
+        metadata,
+        boxes: Object.entries(groupByAnnoId).map(([annoId, items]) => {
+          let baseAnno = {};
+          for (const item of items) {
+            baseAnno = { ...baseAnno, ...item.value };
+          }
+          let newPoints = "points" in baseAnno ? tupleToPoints(baseAnno.points) : [];
+          if (newPoints.length === 0 && "x" in baseAnno && "y" in baseAnno && "width" in baseAnno && "height" in baseAnno) {
+            newPoints = rectangleToPoints(
+              baseAnno.x,
+              baseAnno.y,
+              baseAnno.width,
+              baseAnno.height,
+              imgWidth,
+              imgHeight
+            );
+          }
+          return {
+            id: annoId,
+            points: newPoints,
+            metadata: baseAnno,
+            score: imageMeta?.score,
+            text: "text" in baseAnno ? Array.isArray(baseAnno.text) ? baseAnno.text.join(" ") : baseAnno.text : void 0
+          };
+        })
+      };
+    });
+  }
+});
+
+// src/modules/label-studio-output/output.ts
+var init_output4 = __esm({
+  "src/modules/label-studio-output/output.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_constants();
+    init_geometry();
+  }
+});
+
 // src/config.ts
 var baseFileIOFlagOptions, baseEnhanceFlagOptions;
 var init_config = __esm({
@@ -1656,6 +1968,12 @@ var init_config = __esm({
         kind: "boolean",
         brief: `Copy images to output directory when --outDir is specified. Only applies to toLabelStudio and toPPOCR commands. Default: ${DEFAULT_COPY_IMAGES}`,
         optional: true
+      },
+      imageBaseDir: {
+        kind: "parsed",
+        brief: `Base directory for resolving image paths. Options: "${IMAGE_BASE_DIR_TASK_FILE}" (relative to task file location), "${IMAGE_BASE_DIR_INPUT_DIR}" (relative to command execution directory). Default: "${DEFAULT_IMAGE_BASE_DIR}"`,
+        parse: String,
+        optional: true
       }
     };
     baseEnhanceFlagOptions = {
@@ -1696,7 +2014,7 @@ var init_config = __esm({
       },
       adaptResize: {
         kind: "boolean",
-        brief: `Apply adaptive resize to automatically adjust bounding boxes based on image content. Default: false`,
+        brief: `Apply adaptive resize to automatically adjust bounding boxes based on image content. Default: ${DEFAULT_ADAPT_RESIZE}`,
         optional: true
       },
       adaptResizeThreshold: {
@@ -1741,6 +2059,35 @@ var init_config = __esm({
         parse: Number,
         optional: true
       },
+      adaptResizePaddingCheckWidth: {
+        kind: "parsed",
+        brief: `Width of padding strip to validate (in pixels). Default: ${DEFAULT_ADAPT_RESIZE_PADDING_CHECK_WIDTH}`,
+        parse: Number,
+        optional: true
+      },
+      adaptResizeMinPaddingBrightness: {
+        kind: "parsed",
+        brief: `Minimum brightness for white padding pixels (0-255). Default: ${DEFAULT_ADAPT_RESIZE_MIN_PADDING_BRIGHTNESS}`,
+        parse: Number,
+        optional: true
+      },
+      adaptResizeMinPaddingRatio: {
+        kind: "parsed",
+        brief: `Minimum ratio of white pixels in padding strip (0-1). Default: ${DEFAULT_ADAPT_RESIZE_MIN_PADDING_RATIO}`,
+        parse: Number,
+        optional: true
+      },
+      adaptResizeUseAdaptiveThreshold: {
+        kind: "boolean",
+        brief: `Use adaptive thresholding based on image histogram (recommended). Default: ${DEFAULT_ADAPT_RESIZE_USE_ADAPTIVE_THRESHOLD}`,
+        optional: true
+      },
+      adaptResizeAdaptiveBlockSize: {
+        kind: "parsed",
+        brief: `Block size for adaptive thresholding. Default: ${DEFAULT_ADAPT_RESIZE_ADAPTIVE_BLOCK_SIZE}`,
+        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)`,
@@ -1764,13 +2111,14 @@ var init_label_studio_to_ppocr = __esm({
     fullLabelStudioToPPOCRConverters = async (inputTasks, taskFilePath, outputDir, options) => {
       const {
         baseImageDir,
+        imageBaseDir: _imageBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -1814,13 +2162,13 @@ var init_label_studio_to_ppocr = __esm({
           const filename = (0, import_path.basename)(urlPath);
           const fileDir2 = (0, import_path.dirname)(taskFilePath2);
           const localPath = (0, import_path.join)(fileDir2, filename);
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             (0, import_https.get)(taskImagePath, (response) => {
               const fileStream = (0, import_fs.createWriteStream)(localPath);
               response.pipe(fileStream);
               fileStream.on("finish", () => {
                 fileStream.close();
-                resolve3();
+                resolve4();
               });
               fileStream.on("error", reject);
             }).on("error", reject);
@@ -1861,13 +2209,14 @@ var init_label_studio_to_ppocr = __esm({
     minLabelStudioToPPOCRConverters = async (inputTasks, taskFilePath, outputDir, options) => {
       const {
         baseImageDir,
+        imageBaseDir: _imageBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -1911,13 +2260,13 @@ var init_label_studio_to_ppocr = __esm({
           const filename = (0, import_path.basename)(urlPath);
           const fileDir2 = (0, import_path.dirname)(taskFilePath2);
           const localPath = (0, import_path.join)(fileDir2, filename);
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             (0, import_https.get)(taskImagePath, (response) => {
               const fileStream = (0, import_fs.createWriteStream)(localPath);
               response.pipe(fileStream);
               fileStream.on("finish", () => {
                 fileStream.close();
-                resolve3();
+                resolve4();
               });
               fileStream.on("error", reject);
             }).on("error", reject);
@@ -1965,20 +2314,26 @@ var init_ppocr_to_label_studio = __esm({
     "use strict";
     init_cjs_shims();
     import_path2 = require("path");
+    init_constants();
     init_lib();
     ppocrToFullLabelStudioConverters = async (inputTasks, taskFilePath, options) => {
       const {
         baseServerUrl,
         defaultLabelName,
-        outDir,
-        copyImages = false,
+        outputMode,
+        outDir: _outDir,
+        // Keep for potential future use
+        copyImages: _copyImages = false,
+        // Keep for potential future use
+        imageBaseDir,
+        inputBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -1986,6 +2341,11 @@ var init_ppocr_to_label_studio = __esm({
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
+        adaptResizePaddingCheckWidth,
+        adaptResizeMinPaddingBrightness,
+        adaptResizeMinPaddingRatio,
+        adaptResizeUseAdaptiveThreshold,
+        adaptResizeAdaptiveBlockSize,
         precision
       } = options;
       const transformerParams = [
@@ -2005,7 +2365,12 @@ var init_ppocr_to_label_studio = __esm({
             maxComponentSize: adaptResizeMaxComponentSize,
             outlierPercentile: adaptResizeOutlierPercentile,
             morphologySize: adaptResizeMorphologySize,
-            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion
+            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion,
+            paddingCheckWidth: adaptResizePaddingCheckWidth,
+            minPaddingBrightness: adaptResizeMinPaddingBrightness,
+            minPaddingRatio: adaptResizeMinPaddingRatio,
+            useAdaptiveThreshold: adaptResizeUseAdaptiveThreshold,
+            adaptiveBlockSize: adaptResizeAdaptiveBlockSize
           })
         ] : [],
         withOptions(roundTransformer, {
@@ -2026,35 +2391,23 @@ var init_ppocr_to_label_studio = __esm({
           return (0, import_path2.join)(fileDir, taskImagePath);
         }
       };
-      const resolveOutputImagePath = (taskImagePath, taskFilePath2) => {
-        let resolvedPath;
-        if (outDir) {
-          const outputJsonDir = (0, import_path2.resolve)(outDir);
-          if (copyImages) {
-            const fileName = (0, import_path2.basename)(taskImagePath);
-            resolvedPath = fileName;
-          } else {
-            const absoluteImagePath = (0, import_path2.resolve)(process.cwd(), taskImagePath);
-            resolvedPath = (0, import_path2.relative)(outputJsonDir, absoluteImagePath);
-          }
-        } else {
-          const taskDir = (0, import_path2.dirname)(taskFilePath2);
-          resolvedPath = (0, import_path2.relative)(taskDir, taskImagePath);
-        }
+      const resolveOutputImagePath = (taskImagePath, _taskFilePath) => {
+        const relativePath = imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR && inputBaseDir ? (0, import_path2.relative)(inputBaseDir, taskImagePath) : (0, import_path2.basename)(taskImagePath);
+        const resolvedPath = relativePath;
         if (baseServerUrl !== void 0) {
           if (baseServerUrl === "") {
             return encodeURI(`/${resolvedPath}`);
-          } else {
-            const normalizedBaseUrl = baseServerUrl.replace(/\/+$/, "");
-            return encodeURI(`${normalizedBaseUrl}/${resolvedPath}`);
           }
+          const normalizedBaseUrl = baseServerUrl.replace(/\/+$/, "");
+          return encodeURI(`${normalizedBaseUrl}/${resolvedPath}`);
         }
         return resolvedPath;
       };
       const processor = new Processor({
         input: PPOCRInput,
         output: withOptions(FullOCRLabelStudioOutput, {
-          defaultLabelName
+          defaultLabelName,
+          outputMode
         }),
         transformers: transformerParams
       });
@@ -2074,8 +2427,12 @@ var init_ppocr_to_label_studio = __esm({
       const {
         baseServerUrl,
         defaultLabelName,
-        outDir,
-        copyImages = false,
+        outDir: _outDir,
+        // Keep for potential future use
+        copyImages: _copyImages = false,
+        // Keep for potential future use
+        imageBaseDir,
+        inputBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
@@ -2111,28 +2468,15 @@ var init_ppocr_to_label_studio = __esm({
           return (0, import_path2.join)(fileDir, taskImagePath);
         }
       };
-      const resolveOutputImagePath = (taskImagePath, taskFilePath2) => {
-        let resolvedPath;
-        if (outDir) {
-          const outputJsonDir = (0, import_path2.resolve)(outDir);
-          if (copyImages) {
-            const fileName = (0, import_path2.basename)(taskImagePath);
-            resolvedPath = fileName;
-          } else {
-            const absoluteImagePath = (0, import_path2.resolve)(process.cwd(), taskImagePath);
-            resolvedPath = (0, import_path2.relative)(outputJsonDir, absoluteImagePath);
-          }
-        } else {
-          const taskDir = (0, import_path2.dirname)(taskFilePath2);
-          resolvedPath = (0, import_path2.relative)(taskDir, taskImagePath);
-        }
+      const resolveOutputImagePath = (taskImagePath, _taskFilePath) => {
+        const relativePath = imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR && inputBaseDir ? (0, import_path2.relative)(inputBaseDir, taskImagePath) : (0, import_path2.basename)(taskImagePath);
+        const resolvedPath = relativePath;
         if (baseServerUrl !== void 0) {
           if (baseServerUrl === "") {
             return encodeURI(`/${resolvedPath}`);
-          } else {
-            const normalizedBaseUrl = baseServerUrl.replace(/\/+$/, "");
-            return encodeURI(`${normalizedBaseUrl}/${resolvedPath}`);
           }
+          const normalizedBaseUrl = baseServerUrl.replace(/\/+$/, "");
+          return encodeURI(`${normalizedBaseUrl}/${resolvedPath}`);
         }
         return resolvedPath;
       };
@@ -2168,18 +2512,23 @@ var init_enhance_label_studio = __esm({
     import_fs2 = require("fs");
     import_https2 = require("https");
     import_path3 = require("path");
+    init_constants();
     init_lib();
     enhanceFullLabelStudioConverters = async (inputTasks, taskFilePath, options) => {
       const {
         baseServerUrl,
-        outDir,
+        outDir: _outDir,
+        // Keep for potential future use
+        imageBaseDir,
+        copyImages: _copyImages,
+        inputBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -2187,6 +2536,11 @@ var init_enhance_label_studio = __esm({
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
+        adaptResizePaddingCheckWidth,
+        adaptResizeMinPaddingBrightness,
+        adaptResizeMinPaddingRatio,
+        adaptResizeUseAdaptiveThreshold,
+        adaptResizeAdaptiveBlockSize,
         precision
       } = options;
       const transformerParams = [
@@ -2206,7 +2560,12 @@ var init_enhance_label_studio = __esm({
             maxComponentSize: adaptResizeMaxComponentSize,
             outlierPercentile: adaptResizeOutlierPercentile,
             morphologySize: adaptResizeMorphologySize,
-            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion
+            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion,
+            paddingCheckWidth: adaptResizePaddingCheckWidth,
+            minPaddingBrightness: adaptResizeMinPaddingBrightness,
+            minPaddingRatio: adaptResizeMinPaddingRatio,
+            useAdaptiveThreshold: adaptResizeUseAdaptiveThreshold,
+            adaptiveBlockSize: adaptResizeAdaptiveBlockSize
           })
         ] : [],
         withOptions(roundTransformer, {
@@ -2223,13 +2582,13 @@ var init_enhance_label_studio = __esm({
           const urlPath = new URL(taskImagePath).pathname;
           const filename = (0, import_path3.basename)(urlPath);
           const localPath = (0, import_path3.join)(fileDir, filename);
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             (0, import_https2.get)(taskImagePath, (response) => {
               const fileStream = (0, import_fs2.createWriteStream)(localPath);
               response.pipe(fileStream);
               fileStream.on("finish", () => {
                 fileStream.close();
-                resolve3();
+                resolve4();
               });
               fileStream.on("error", reject);
             }).on("error", reject);
@@ -2239,19 +2598,15 @@ var init_enhance_label_studio = __esm({
         const cleanPath = taskImagePath.replace(/^\/+/, "");
         return (0, import_path3.join)(fileDir, cleanPath);
       };
-      const resolveOutputImagePath = (taskImagePath, taskFilePath2) => {
-        let resolvedPath = taskImagePath;
-        if (outDir) {
-          const relativePath = (0, import_path3.relative)(process.cwd(), taskFilePath2);
-          const relativeDir = (0, import_path3.dirname)(relativePath);
-          const outputSubDir = (0, import_path3.join)(outDir, relativeDir);
-          resolvedPath = (0, import_path3.relative)(outputSubDir, taskImagePath);
+      const resolveOutputImagePath = (taskImagePath, _taskFilePath) => {
+        const relativePath = imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR && inputBaseDir ? (0, import_path3.relative)(inputBaseDir, taskImagePath) : (0, import_path3.basename)(taskImagePath);
+        if (baseServerUrl === void 0) {
+          return relativePath;
         }
-        const newBaseServerUrl = baseServerUrl?.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "");
-        if (newBaseServerUrl) {
-          return encodeURI(`${newBaseServerUrl}/${resolvedPath}`);
+        if (baseServerUrl === "") {
+          return "/" + relativePath;
         }
-        return resolvedPath;
+        return new URL(relativePath, baseServerUrl).href;
       };
       const processor = new Processor({
         input: FullOCRLabelStudioInput,
@@ -2273,14 +2628,18 @@ var init_enhance_label_studio = __esm({
     enhanceMinLabelStudioConverters = async (inputTasks, taskFilePath, options) => {
       const {
         baseServerUrl,
-        outDir,
+        outDir: _outDir,
+        // Keep for potential future use
+        imageBaseDir,
+        copyImages: _copyImages,
+        inputBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -2288,6 +2647,11 @@ var init_enhance_label_studio = __esm({
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
+        adaptResizePaddingCheckWidth,
+        adaptResizeMinPaddingBrightness,
+        adaptResizeMinPaddingRatio,
+        adaptResizeUseAdaptiveThreshold,
+        adaptResizeAdaptiveBlockSize,
         precision
       } = options;
       const transformerParams = [
@@ -2307,7 +2671,12 @@ var init_enhance_label_studio = __esm({
             maxComponentSize: adaptResizeMaxComponentSize,
             outlierPercentile: adaptResizeOutlierPercentile,
             morphologySize: adaptResizeMorphologySize,
-            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion
+            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion,
+            paddingCheckWidth: adaptResizePaddingCheckWidth,
+            minPaddingBrightness: adaptResizeMinPaddingBrightness,
+            minPaddingRatio: adaptResizeMinPaddingRatio,
+            useAdaptiveThreshold: adaptResizeUseAdaptiveThreshold,
+            adaptiveBlockSize: adaptResizeAdaptiveBlockSize
           })
         ] : [],
         withOptions(roundTransformer, {
@@ -2324,13 +2693,13 @@ var init_enhance_label_studio = __esm({
           const urlPath = new URL(taskImagePath).pathname;
           const filename = (0, import_path3.basename)(urlPath);
           const localPath = (0, import_path3.join)(fileDir, filename);
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             (0, import_https2.get)(taskImagePath, (response) => {
               const fileStream = (0, import_fs2.createWriteStream)(localPath);
               response.pipe(fileStream);
               fileStream.on("finish", () => {
                 fileStream.close();
-                resolve3();
+                resolve4();
               });
               fileStream.on("error", reject);
             }).on("error", reject);
@@ -2340,19 +2709,15 @@ var init_enhance_label_studio = __esm({
         const cleanPath = taskImagePath.replace(/^\/+/, "");
         return (0, import_path3.join)(fileDir, cleanPath);
       };
-      const resolveOutputImagePath = (taskImagePath, taskFilePath2) => {
-        let resolvedPath = taskImagePath;
-        if (outDir) {
-          const relativePath = (0, import_path3.relative)(process.cwd(), taskFilePath2);
-          const relativeDir = (0, import_path3.dirname)(relativePath);
-          const outputSubDir = (0, import_path3.join)(outDir, relativeDir);
-          resolvedPath = (0, import_path3.relative)(outputSubDir, taskImagePath);
+      const resolveOutputImagePath = (taskImagePath, _taskFilePath) => {
+        const relativePath = imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR && inputBaseDir ? (0, import_path3.relative)(inputBaseDir, taskImagePath) : (0, import_path3.basename)(taskImagePath);
+        if (baseServerUrl === void 0) {
+          return relativePath;
         }
-        const newBaseServerUrl = baseServerUrl?.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "");
-        if (newBaseServerUrl) {
-          return encodeURI(`${newBaseServerUrl}/${resolvedPath}`);
+        if (baseServerUrl === "") {
+          return "/" + relativePath;
         }
-        return resolvedPath;
+        return new URL(relativePath, baseServerUrl).href;
       };
       const processor = new Processor({
         input: MinOCRLabelStudioInput,
@@ -2384,13 +2749,14 @@ var init_enhance_ppocr = __esm({
     init_lib();
     enhancePPOCRConverters = async (inputTasks, taskFilePath, options) => {
       const {
+        imageBaseDir: _imageBaseDir,
         sortVertical,
         sortHorizontal,
         normalizeShape,
         useOrientedBox,
         widthIncrement,
         heightIncrement,
-        adaptResize = false,
+        adaptResize,
         adaptResizeThreshold,
         adaptResizeMargin,
         adaptResizeMinComponentSize,
@@ -2398,6 +2764,11 @@ var init_enhance_ppocr = __esm({
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
+        adaptResizePaddingCheckWidth,
+        adaptResizeMinPaddingBrightness,
+        adaptResizeMinPaddingRatio,
+        adaptResizeUseAdaptiveThreshold,
+        adaptResizeAdaptiveBlockSize,
         precision
       } = options;
       const transformerParams = [
@@ -2417,7 +2788,12 @@ var init_enhance_ppocr = __esm({
             maxComponentSize: adaptResizeMaxComponentSize,
             outlierPercentile: adaptResizeOutlierPercentile,
             morphologySize: adaptResizeMorphologySize,
-            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion
+            maxHorizontalExpansion: adaptResizeMaxHorizontalExpansion,
+            paddingCheckWidth: adaptResizePaddingCheckWidth,
+            minPaddingBrightness: adaptResizeMinPaddingBrightness,
+            minPaddingRatio: adaptResizeMinPaddingRatio,
+            useAdaptiveThreshold: adaptResizeUseAdaptiveThreshold,
+            adaptiveBlockSize: adaptResizeAdaptiveBlockSize
           })
         ] : [],
         withOptions(roundTransformer, {
@@ -2463,6 +2839,32 @@ var init_enhance_ppocr = __esm({
   }
 });
 
+// src/converters/label-studio-output-to-ppocr.ts
+var outputLabelStudioToPPOCRConverters;
+var init_label_studio_output_to_ppocr = __esm({
+  "src/converters/label-studio-output-to-ppocr.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_lib();
+    outputLabelStudioToPPOCRConverters = async (inputTasks, taskFilePath) => {
+      const processor = new Processor({
+        input: OutputLabelStudioInput,
+        output: PPOCROutput
+      });
+      return await Promise.all(
+        inputTasks.map(async (task) => {
+          const outputData = await processor.process({
+            inputData: task,
+            taskFilePath,
+            resolveOutputImagePath: (taskImagePath) => decodeURI(taskImagePath)
+          });
+          return outputData;
+        })
+      );
+    };
+  }
+});
+
 // src/lib/index.ts
 var init_lib = __esm({
   "src/lib/index.ts"() {
@@ -2478,17 +2880,21 @@ var init_lib = __esm({
     init_schema();
     init_schema2();
     init_schema3();
+    init_schema4();
     init_input();
     init_output();
     init_input2();
     init_output2();
     init_input3();
     init_output3();
+    init_input4();
+    init_output4();
     init_config();
     init_label_studio_to_ppocr();
     init_ppocr_to_label_studio();
     init_enhance_label_studio();
     init_enhance_ppocr();
+    init_label_studio_output_to_ppocr();
     init_constants();
     init_geometry();
   }
@@ -2518,7 +2924,7 @@ var init_backup_utils = __esm({
 // src/lib/file-utils.ts
 async function findFiles(dirs, pattern, recursive) {
   const allFiles = [];
-  const regex = new RegExp(pattern);
+  const regex = pattern ? new RegExp(pattern) : null;
   async function scanDirectory(dirPath) {
     const entries = await (0, import_promises3.readdir)(dirPath, { withFileTypes: true });
     for (const entry of entries) {
@@ -2528,7 +2934,9 @@ async function findFiles(dirs, pattern, recursive) {
           await scanDirectory(fullPath);
         }
       } else if (entry.isFile()) {
-        if (regex.test(entry.name)) {
+        if (regex && regex.test(entry.name)) {
+          allFiles.push(fullPath);
+        } else if (!regex) {
           allFiles.push(fullPath);
         }
       }
@@ -2539,7 +2947,9 @@ async function findFiles(dirs, pattern, recursive) {
     if (dirStat.isDirectory()) {
       await scanDirectory(dir);
     } else if (dirStat.isFile()) {
-      if (regex.test(dir)) {
+      if (regex && regex.test(dir)) {
+        allFiles.push(dir);
+      } else if (!regex) {
         allFiles.push(dir);
       }
     }
@@ -2569,12 +2979,13 @@ async function convertToPPOCR(flags, ...inputDirs) {
     backup = DEFAULT_BACKUP,
     copyImages = DEFAULT_COPY_IMAGES,
     baseImageDir,
+    imageBaseDir = DEFAULT_IMAGE_BASE_DIR,
     sortVertical = DEFAULT_SORT_VERTICAL,
     sortHorizontal = DEFAULT_SORT_HORIZONTAL,
     normalizeShape = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    adaptResize = false,
+    adaptResize = DEFAULT_ADAPT_RESIZE,
     adaptResizeThreshold = DEFAULT_ADAPT_RESIZE_THRESHOLD,
     adaptResizeMargin = DEFAULT_ADAPT_RESIZE_MARGIN,
     adaptResizeMinComponentSize = DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE,
@@ -2594,11 +3005,12 @@ async function convertToPPOCR(flags, ...inputDirs) {
   }
   console.log(import_chalk.default.blue(`Found ${filePaths.length} files to process
 `));
+  const baseDir = inputDirs.length > 0 ? (0, import_path6.resolve)(inputDirs[0]) : process.cwd();
   for (const filePath of filePaths) {
     const file = (0, import_path6.basename)(filePath);
     const relativePath = (0, import_path6.relative)(process.cwd(), filePath);
     const relativeDir = (0, import_path6.dirname)(relativePath);
-    console.log(import_chalk.default.gray(`Processing file: ${filePath}`));
+    console.log(import_chalk.default.gray(`Processing file: "${filePath}"`));
     try {
       const fileData = await (0, import_promises4.readFile)(filePath, "utf-8");
       const labelStudioData = JSON.parse(fileData);
@@ -2621,7 +3033,8 @@ async function convertToPPOCR(flags, ...inputDirs) {
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
-        precision
+        precision,
+        imageBaseDir
       };
       const outputSubDir = outDir ? (0, import_path6.join)(outDir, relativeDir) : (0, import_path6.dirname)(filePath);
       if (isFull) {
@@ -2658,11 +3071,18 @@ async function convertToPPOCR(flags, ...inputDirs) {
               const cleanPath = imageUrl.startsWith("/") ? imageUrl.slice(1) : imageUrl;
               sourceImagePath = (0, import_path6.join)(taskFileDir, cleanPath);
             }
-            const destImagePath = (0, import_path6.join)(outputSubDir, (0, import_path6.basename)(sourceImagePath));
+            let destImagePath;
+            if (imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR) {
+              const relativeFromInput = (0, import_path6.relative)(baseDir, sourceImagePath);
+              destImagePath = (0, import_path6.join)(outDir, relativeFromInput);
+            } else {
+              const relativeFromTask = (0, import_path6.relative)(taskFileDir, sourceImagePath);
+              destImagePath = (0, import_path6.join)(outputSubDir, relativeFromTask);
+            }
             await (0, import_promises4.mkdir)((0, import_path6.dirname)(destImagePath), { recursive: true });
             await (0, import_promises4.copyFile)(sourceImagePath, destImagePath);
             console.log(
-              import_chalk.default.gray(`  \u2713 Copied image: ${(0, import_path6.basename)(sourceImagePath)}`)
+              import_chalk.default.gray(`  \u2713 Copied image: "${(0, import_path6.basename)(sourceImagePath)}"`)
             );
           } catch (error) {
             console.warn(
@@ -2685,14 +3105,14 @@ async function convertToPPOCR(flags, ...inputDirs) {
       if (backup) {
         const backupPath = await backupFileIfExists(outputPath);
         if (backupPath) {
-          console.log(import_chalk.default.gray(`  Backed up to: ${backupPath}`));
+          console.log(import_chalk.default.gray(`  Backed up to: "${backupPath}"`));
         }
       }
       await (0, import_promises4.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
-      console.log(import_chalk.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+      console.log(import_chalk.default.green(`\u2713 Converted "${file}" -> "${outputPath}"`));
     } catch (error) {
       console.error(
-        import_chalk.default.red(`\u2717 Failed to process ${file}:`),
+        import_chalk.default.red(`\u2717 Failed to process "${file}":`),
         error instanceof Error ? error.message : error
       );
     }
@@ -2740,12 +3160,13 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
     outDir,
     fileName,
     backup = DEFAULT_BACKUP,
+    imageBaseDir = DEFAULT_IMAGE_BASE_DIR,
     sortVertical = DEFAULT_SORT_VERTICAL,
     sortHorizontal = DEFAULT_SORT_HORIZONTAL,
     normalizeShape = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    adaptResize = false,
+    adaptResize = DEFAULT_ADAPT_RESIZE,
     adaptResizeThreshold = DEFAULT_ADAPT_RESIZE_THRESHOLD,
     adaptResizeMargin = DEFAULT_ADAPT_RESIZE_MARGIN,
     adaptResizeMinComponentSize = DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE,
@@ -2768,7 +3189,7 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
 `));
   for await (const filePath of filePaths) {
     const file = (0, import_path7.basename)(filePath);
-    console.log(import_chalk2.default.gray(`Processing file: ${filePath}`));
+    console.log(import_chalk2.default.gray(`Processing file: "${filePath}"`));
     try {
       const fileData = await (0, import_promises5.readFile)(filePath, "utf-8");
       const labelStudioData = JSON.parse(fileData);
@@ -2776,7 +3197,7 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
       if (outputMode !== DEFAULT_OUTPUT_MODE && !isFull) {
         console.log(
           import_chalk2.default.red(
-            `  Skipping file: ${filePath}
+            `  Skipping file: "${filePath}"
   Error: --outputMode can only be used with Full JSON format. This file is in Min JSON format which does not support annotations/predictions distinction.`
           )
         );
@@ -2798,7 +3219,8 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
-        precision
+        precision,
+        imageBaseDir
       };
       if (isFull) {
         outputTasks = await enhanceFullLabelStudioConverters(
@@ -2824,7 +3246,7 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
       if (backup) {
         const backupPath = await backupFileIfExists(outputFilePath);
         if (backupPath) {
-          console.log(import_chalk2.default.gray(`  Backed up to: ${backupPath}`));
+          console.log(import_chalk2.default.gray(`  Backed up to: "${backupPath}"`));
         }
       }
       await (0, import_promises5.writeFile)(
@@ -2832,10 +3254,10 @@ async function enhanceLabelStudio(flags, ...inputDirs) {
         JSON.stringify(outputTasks, null, 2),
         "utf-8"
       );
-      console.log(import_chalk2.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+      console.log(import_chalk2.default.green(`\u2713 Enhanced file saved: "${outputFilePath}"`));
     } catch (error) {
       console.error(
-        import_chalk2.default.red(`Error processing file ${file}:`),
+        import_chalk2.default.red(`Error processing file "${file}":`),
         error instanceof Error ? error.message : String(error)
       );
     }
@@ -2868,12 +3290,13 @@ async function enhancePPOCR(flags, ...inputDirs) {
     outDir,
     fileName,
     backup = DEFAULT_BACKUP,
+    imageBaseDir = DEFAULT_IMAGE_BASE_DIR,
     sortVertical = DEFAULT_SORT_VERTICAL,
     sortHorizontal = DEFAULT_SORT_HORIZONTAL,
     normalizeShape = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    adaptResize = false,
+    adaptResize = DEFAULT_ADAPT_RESIZE,
     adaptResizeThreshold = DEFAULT_ADAPT_RESIZE_THRESHOLD,
     adaptResizeMargin = DEFAULT_ADAPT_RESIZE_MARGIN,
     adaptResizeMinComponentSize = DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE,
@@ -2895,7 +3318,7 @@ async function enhancePPOCR(flags, ...inputDirs) {
 `));
   for (const filePath of filePaths) {
     const file = (0, import_path8.basename)(filePath);
-    console.log(import_chalk3.default.gray(`Processing file: ${filePath}`));
+    console.log(import_chalk3.default.gray(`Processing file: "${filePath}"`));
     try {
       const fileData = await (0, import_promises6.readFile)(filePath, "utf-8");
       const lines = fileData.trim().split("\n");
@@ -2927,7 +3350,7 @@ async function enhancePPOCR(flags, ...inputDirs) {
       }
       if (inputTasks.length === 0) {
         console.log(
-          import_chalk3.default.yellow(`  Skipping file with no valid data: ${filePath}`)
+          import_chalk3.default.yellow(`  Skipping file with no valid data: "${filePath}"`)
         );
         continue;
       }
@@ -2945,7 +3368,8 @@ async function enhancePPOCR(flags, ...inputDirs) {
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
-        precision
+        precision,
+        imageBaseDir
       };
       const outputTasks = await enhancePPOCRConverters(
         inputTasks,
@@ -2963,14 +3387,14 @@ async function enhancePPOCR(flags, ...inputDirs) {
       if (backup) {
         const backupPath = await backupFileIfExists(outputFilePath);
         if (backupPath) {
-          console.log(import_chalk3.default.gray(`  Backed up to: ${backupPath}`));
+          console.log(import_chalk3.default.gray(`  Backed up to: "${backupPath}"`));
         }
       }
       await (0, import_promises6.writeFile)(outputFilePath, outputTasks.join("\n"), "utf-8");
-      console.log(import_chalk3.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+      console.log(import_chalk3.default.green(`\u2713 Enhanced file saved: "${outputFilePath}"`));
     } catch (error) {
       console.error(
-        import_chalk3.default.red(`Error processing file ${file}:`),
+        import_chalk3.default.red(`Error processing file "${file}":`),
         error instanceof Error ? error.message : String(error)
       );
     }
@@ -2992,9 +3416,98 @@ var init_impl3 = __esm({
   }
 });
 
-// src/commands/toLabelStudio/impl.ts
+// src/commands/labelStudioOutputToPPOCR/impl.ts
 var impl_exports4 = {};
 __export(impl_exports4, {
+  labelStudioOutputToPPOCR: () => labelStudioOutputToPPOCR
+});
+async function labelStudioOutputToPPOCR(flags, ...inputDirs) {
+  const {
+    outDir,
+    fileName = DEFAULT_PPOCR_FILE_NAME,
+    backup = DEFAULT_BACKUP,
+    recursive = DEFAULT_RECURSIVE,
+    filePattern = void 0,
+    removeBaseImageDir = DEFAULT_LABEL_STUDIO_OUTPUT_IMAGE_BASE_DIR
+  } = flags;
+  console.log(import_chalk4.default.blue("Finding files..."));
+  const filePaths = await findFiles(inputDirs, filePattern, recursive);
+  if (filePaths.length === 0) {
+    console.log(import_chalk4.default.yellow("No files found matching the pattern."));
+    return;
+  }
+  console.log(import_chalk4.default.blue(`Found ${filePaths.length} files to process
+`));
+  let masterOutputTasks = [];
+  for (const filePath of filePaths) {
+    console.log(import_chalk4.default.gray(`Processing file: "${filePath}"`));
+    const fileData = await (0, import_promises7.readFile)(filePath, "utf-8");
+    const labelStudioData = JSON.parse(fileData);
+    const [outputTask] = await outputLabelStudioToPPOCRConverters(
+      [labelStudioData],
+      filePath
+    );
+    masterOutputTasks = masterOutputTasks.concat([
+      {
+        ...outputTask,
+        imagePath: outputTask.imagePath.replace(removeBaseImageDir, "")
+      }
+    ]);
+  }
+  const groupTaskByImagePath = (0, import_es_toolkit4.groupBy)(
+    masterOutputTasks,
+    (task) => (0, import_path9.dirname)(task.imagePath)
+  );
+  for (const [baseOutputImageDir, tasks] of Object.entries(
+    groupTaskByImagePath
+  )) {
+    const subImageDir = baseOutputImageDir.split("/").slice(-1)[0];
+    const outputImageDir = (0, import_path9.resolve)(outDir, baseOutputImageDir);
+    await (0, import_promises7.mkdir)(outputImageDir, { recursive: true });
+    const outputPath = (0, import_path9.join)(outputImageDir, `${fileName}`);
+    const outputLines = [];
+    for (const task of tasks) {
+      const imagePath = removeBaseImageDir ? task.imagePath.replace(removeBaseImageDir, "") : task.imagePath;
+      const imageFileName = (0, import_path9.basename)(imagePath);
+      PPOCRLabelSchema.parse(task.data);
+      const jsonArray = JSON.stringify(task.data);
+      outputLines.push(`${subImageDir}/${imageFileName}	${jsonArray}`);
+      console.log(
+        import_chalk4.default.green(
+          `\u2713 Saved image group: "${imagePath}" to "${outputPath}"`
+        )
+      );
+    }
+    if (backup) {
+      const backupPath = await backupFileIfExists(outputPath);
+      if (backupPath) {
+        console.log(import_chalk4.default.gray(`  Backed up to: "${backupPath}"`));
+      }
+    }
+    await (0, import_promises7.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
+  }
+  console.log(import_chalk4.default.green("\n\u2713 Conversion completed!"));
+}
+var import_promises7, import_path9, import_chalk4, import_es_toolkit4;
+var init_impl4 = __esm({
+  "src/commands/labelStudioOutputToPPOCR/impl.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises7 = require("fs/promises");
+    import_path9 = require("path");
+    import_chalk4 = __toESM(require("chalk"), 1);
+    import_es_toolkit4 = require("es-toolkit");
+    init_constants();
+    init_lib();
+    init_lib();
+    init_backup_utils();
+    init_file_utils();
+  }
+});
+
+// src/commands/toLabelStudio/impl.ts
+var impl_exports5 = {};
+__export(impl_exports5, {
   convertToLabelStudio: () => convertToLabelStudio
 });
 async function convertToLabelStudio(flags, ...inputDirs) {
@@ -3003,6 +3516,7 @@ async function convertToLabelStudio(flags, ...inputDirs) {
     fileName,
     backup = DEFAULT_BACKUP,
     copyImages = DEFAULT_COPY_IMAGES,
+    imageBaseDir = DEFAULT_IMAGE_BASE_DIR,
     defaultLabelName = DEFAULT_LABEL_NAME,
     toFullJson = DEFAULT_LABEL_STUDIO_FULL_JSON,
     createFilePerImage = DEFAULT_CREATE_FILE_PER_IMAGE,
@@ -3014,7 +3528,7 @@ async function convertToLabelStudio(flags, ...inputDirs) {
     normalizeShape = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    adaptResize = false,
+    adaptResize = DEFAULT_ADAPT_RESIZE,
     adaptResizeThreshold = DEFAULT_ADAPT_RESIZE_THRESHOLD,
     adaptResizeMargin = DEFAULT_ADAPT_RESIZE_MARGIN,
     adaptResizeMinComponentSize = DEFAULT_ADAPT_RESIZE_MIN_COMPONENT_SIZE,
@@ -3029,38 +3543,38 @@ async function convertToLabelStudio(flags, ...inputDirs) {
   } = flags;
   if (outputMode !== DEFAULT_OUTPUT_MODE && !toFullJson) {
     console.log(
-      import_chalk4.default.red(
+      import_chalk5.default.red(
         "Error: --outputMode can only be used with --toFullJson (Full JSON format). Min JSON format does not support annotations/predictions distinction."
       )
     );
     return;
   }
-  console.log(import_chalk4.default.blue("Finding files..."));
+  console.log(import_chalk5.default.blue("Finding files..."));
   const filePaths = await findFiles(inputDirs, filePattern, recursive);
   if (filePaths.length === 0) {
-    console.log(import_chalk4.default.yellow("No files found matching the pattern."));
+    console.log(import_chalk5.default.yellow("No files found matching the pattern."));
     return;
   }
-  console.log(import_chalk4.default.blue(`Found ${filePaths.length} files to process
+  console.log(import_chalk5.default.blue(`Found ${filePaths.length} files to process
 `));
-  const resolvedOutDir = outDir ? (0, import_path9.resolve)(outDir) : void 0;
+  const resolvedOutDir = outDir ? (0, import_path10.resolve)(outDir) : void 0;
   let fileListPath = null;
   if (createFileListForServing && resolvedOutDir) {
-    fileListPath = (0, import_path9.join)(resolvedOutDir, fileListName);
-    await (0, import_promises7.mkdir)(resolvedOutDir, { recursive: true });
-    await (0, import_promises7.writeFile)(fileListPath, "", "utf-8");
+    fileListPath = (0, import_path10.join)(resolvedOutDir, fileListName);
+    await (0, import_promises8.mkdir)(resolvedOutDir, { recursive: true });
+    await (0, import_promises8.writeFile)(fileListPath, "", "utf-8");
   }
-  const baseDir = inputDirs.length > 0 ? (0, import_path9.resolve)(inputDirs[0]) : process.cwd();
+  const baseDir = inputDirs.length > 0 ? (0, import_path10.resolve)(inputDirs[0]) : process.cwd();
   for (const filePath of filePaths) {
-    const file = (0, import_path9.basename)(filePath);
-    const relativePath = (0, import_path9.relative)(baseDir, filePath);
-    const relativeDir = (0, import_path9.dirname)(relativePath);
-    console.log(import_chalk4.default.gray(`Processing file: ${filePath}`));
+    const file = (0, import_path10.basename)(filePath);
+    const relativePath = (0, import_path10.relative)(baseDir, filePath);
+    const relativeDir = (0, import_path10.dirname)(relativePath);
+    console.log(import_chalk5.default.gray(`Processing file: "${filePath}"`));
     try {
-      const fileData = await (0, import_promises7.readFile)(filePath, "utf-8");
+      const fileData = await (0, import_promises8.readFile)(filePath, "utf-8");
       const trimmedData = fileData.trim();
       if (trimmedData === "") {
-        console.log(import_chalk4.default.yellow(`  Skipping empty file: ${filePath}`));
+        console.log(import_chalk5.default.yellow(`  Skipping empty file: "${filePath}"`));
         continue;
       }
       const lines = trimmedData.split("\n");
@@ -3095,17 +3609,20 @@ async function convertToLabelStudio(flags, ...inputDirs) {
       }
       if (inputTasks.length === 0) {
         console.log(
-          import_chalk4.default.yellow(`  Skipping file with no valid data: ${filePath}`)
+          import_chalk5.default.yellow(`  Skipping file with no valid data: "${filePath}"`)
         );
         continue;
       }
       let outputTasks = [];
-      const converterOutputDir = resolvedOutDir ? (0, import_path9.join)(resolvedOutDir, relativeDir) : (0, import_path9.dirname)(filePath);
+      const converterOutputDir = resolvedOutDir ? (0, import_path10.join)(resolvedOutDir, relativeDir) : (0, import_path10.dirname)(filePath);
       const convertParams = {
         defaultLabelName,
         baseServerUrl,
+        outputMode,
         outDir: converterOutputDir,
-        copyImages: resolvedOutDir ? copyImages : false
+        copyImages: resolvedOutDir ? copyImages : false,
+        inputBaseDir: baseDir,
+        outputRootDir: resolvedOutDir
       };
       const enhanceParams = {
         sortVertical,
@@ -3121,7 +3638,8 @@ async function convertToLabelStudio(flags, ...inputDirs) {
         adaptResizeOutlierPercentile,
         adaptResizeMorphologySize,
         adaptResizeMaxHorizontalExpansion,
-        precision
+        precision,
+        imageBaseDir
       };
       if (toFullJson) {
         outputTasks = await ppocrToFullLabelStudioConverters(
@@ -3143,24 +3661,31 @@ async function convertToLabelStudio(flags, ...inputDirs) {
         );
       }
       if (resolvedOutDir && copyImages) {
-        const taskFileDir = (0, import_path9.dirname)(filePath);
-        const outputSubDir2 = (0, import_path9.join)(resolvedOutDir, relativeDir);
+        const taskFileDir = (0, import_path10.dirname)(filePath);
+        const outputSubDir2 = (0, import_path10.join)(resolvedOutDir, relativeDir);
         for (const task of inputTasks) {
           try {
             const parts = task.imagePath.split("/");
             const folderName = parts.length > 1 ? parts[0] : "";
             const fileName2 = parts.length > 1 ? parts.slice(1).join("/") : task.imagePath;
-            const sourceImagePath = folderName ? (0, import_path9.resolve)((0, import_path9.dirname)(taskFileDir), folderName, fileName2) : (0, import_path9.resolve)(taskFileDir, fileName2);
-            const destImagePath = (0, import_path9.join)(outputSubDir2, (0, import_path9.basename)(sourceImagePath));
-            await (0, import_promises7.mkdir)((0, import_path9.dirname)(destImagePath), { recursive: true });
-            await (0, import_promises7.copyFile)(sourceImagePath, destImagePath);
+            const sourceImagePath = folderName ? (0, import_path10.resolve)((0, import_path10.dirname)(taskFileDir), folderName, fileName2) : (0, import_path10.resolve)(taskFileDir, fileName2);
+            let destImagePath;
+            if (imageBaseDir === IMAGE_BASE_DIR_INPUT_DIR) {
+              const relativeFromInput = (0, import_path10.relative)(baseDir, sourceImagePath);
+              destImagePath = (0, import_path10.join)(resolvedOutDir, relativeFromInput);
+            } else {
+              const relativeFromTask = (0, import_path10.relative)(taskFileDir, sourceImagePath);
+              destImagePath = (0, import_path10.join)(outputSubDir2, relativeFromTask);
+            }
+            await (0, import_promises8.mkdir)((0, import_path10.dirname)(destImagePath), { recursive: true });
+            await (0, import_promises8.copyFile)(sourceImagePath, destImagePath);
             console.log(
-              import_chalk4.default.gray(`  \u2713 Copied image: ${(0, import_path9.basename)(sourceImagePath)}`)
+              import_chalk5.default.gray(`  \u2713 Copied image: "${(0, import_path10.basename)(sourceImagePath)}"`)
             );
           } catch (error) {
             console.warn(
-              import_chalk4.default.yellow(
-                `  \u26A0 Failed to copy image ${task.imagePath}: ${error instanceof Error ? error.message : error}`
+              import_chalk5.default.yellow(
+                `  \u26A0 Failed to copy image "${task.imagePath}": ${error instanceof Error ? error.message : error}`
               )
             );
           }
@@ -3170,22 +3695,24 @@ async function convertToLabelStudio(flags, ...inputDirs) {
         for await (const taskOutput of outputTasks) {
           const imageFilePath = toFullJson ? taskOutput.data.ocr : taskOutput.ocr;
           const imageBaseName = imageFilePath.split("/").pop().replace(/\//g, "_").replace(/\.[^.]+$/, "");
-          const outputSubDir2 = resolvedOutDir ? (0, import_path9.join)(resolvedOutDir, relativeDir) : (0, import_path9.dirname)(filePath);
-          await (0, import_promises7.mkdir)(outputSubDir2, { recursive: true });
-          const individualOutputPath = (0, import_path9.join)(
+          const outputSubDir2 = resolvedOutDir ? (0, import_path10.join)(resolvedOutDir, relativeDir) : (0, import_path10.dirname)(filePath);
+          await (0, import_promises8.mkdir)(outputSubDir2, { recursive: true });
+          const individualOutputPath = (0, import_path10.join)(
             outputSubDir2,
             `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
           );
-          await (0, import_promises7.writeFile)(
+          await (0, import_promises8.writeFile)(
             individualOutputPath,
             JSON.stringify(taskOutput, null, 2),
             "utf-8"
           );
           console.log(
-            import_chalk4.default.gray(`  \u2713 Created individual file: ${individualOutputPath}`)
+            import_chalk5.default.gray(
+              `  \u2713 Created individual file: "${individualOutputPath}"`
+            )
           );
           if (fileListPath) {
-            await (0, import_promises7.writeFile)(fileListPath, `${imageFilePath}
+            await (0, import_promises8.writeFile)(fileListPath, `${imageFilePath}
 `, {
               encoding: "utf-8",
               flag: "a"
@@ -3194,41 +3721,41 @@ async function convertToLabelStudio(flags, ...inputDirs) {
         }
       }
       const baseName = fileName || file.replace(".txt", "");
-      const outputSubDir = resolvedOutDir ? (0, import_path9.join)(resolvedOutDir, relativeDir) : (0, import_path9.dirname)(filePath);
-      await (0, import_promises7.mkdir)(outputSubDir, { recursive: true });
-      const outputPath = (0, import_path9.join)(
+      const outputSubDir = resolvedOutDir ? (0, import_path10.join)(resolvedOutDir, relativeDir) : (0, import_path10.dirname)(filePath);
+      await (0, import_promises8.mkdir)(outputSubDir, { recursive: true });
+      const outputPath = (0, import_path10.join)(
         outputSubDir,
         fileName ? `${fileName}.json` : `${baseName}_${toFullJson ? "full" : "min"}.json`
       );
       if (backup) {
         const backupPath = await backupFileIfExists(outputPath);
         if (backupPath) {
-          console.log(import_chalk4.default.gray(`  \u2713 Created backup: ${backupPath}`));
+          console.log(import_chalk5.default.gray(`  \u2713 Created backup: ${backupPath}`));
         }
       }
-      await (0, import_promises7.writeFile)(
+      await (0, import_promises8.writeFile)(
         outputPath,
         JSON.stringify(outputTasks, null, 2),
         "utf-8"
       );
-      console.log(import_chalk4.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+      console.log(import_chalk5.default.green(`\u2713 Converted "${file}" -> "${outputPath}"`));
     } catch (error) {
       console.error(
-        import_chalk4.default.red(`\u2717 Failed to process ${file}:`),
+        import_chalk5.default.red(`\u2717 Failed to process "${file}":`),
         error instanceof Error ? error.message : error
       );
     }
   }
-  console.log(import_chalk4.default.green("\n\u2713 Conversion completed!"));
+  console.log(import_chalk5.default.green("\n\u2713 Conversion completed!"));
 }
-var import_promises7, import_path9, import_chalk4;
-var init_impl4 = __esm({
+var import_promises8, import_path10, import_chalk5;
+var init_impl5 = __esm({
   "src/commands/toLabelStudio/impl.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises7 = require("fs/promises");
-    import_path9 = require("path");
-    import_chalk4 = __toESM(require("chalk"), 1);
+    import_promises8 = require("fs/promises");
+    import_path10 = require("path");
+    import_chalk5 = __toESM(require("chalk"), 1);
     init_constants();
     init_lib();
     init_backup_utils();
@@ -3238,15 +3765,15 @@ var init_impl4 = __esm({
 
 // src/bin/bash-complete.ts
 init_cjs_shims();
-var import_core6 = require("@stricli/core");
+var import_core7 = require("@stricli/core");
 
 // src/app.ts
 init_cjs_shims();
 var import_auto_complete = require("@stricli/auto-complete");
-var import_core5 = require("@stricli/core");
+var import_core6 = require("@stricli/core");
 
 // package.json
-var version = "1.4.0";
+var version = "1.5.0";
 var description = "Convert between Label Studio OCR format and PPOCRLabelv2 format";
 
 // src/commands/enhance-labelstudio/command.ts
@@ -3337,14 +3864,61 @@ var enhancePPOCRCommand = (0, import_core2.buildCommand)({
   }
 });
 
-// src/commands/toLabelStudio/command.ts
+// src/commands/labelStudioOutputToPPOCR/commands.ts
 init_cjs_shims();
 var import_core3 = require("@stricli/core");
+var import_es_toolkit5 = require("es-toolkit");
 init_constants();
 init_lib();
-var toLabelStudioCommand = (0, import_core3.buildCommand)({
+var labelStudioOutputToPPOCRCommand = (0, import_core3.buildCommand)({
   loader: async () => {
-    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl4(), impl_exports4));
+    const { labelStudioOutputToPPOCR: labelStudioOutputToPPOCR2 } = await Promise.resolve().then(() => (init_impl4(), impl_exports4));
+    return labelStudioOutputToPPOCR2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing Label Studio files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      ...(0, import_es_toolkit5.pick)(baseFileIOFlagOptions, ["recursive", "backup", "filePattern"]),
+      outDir: {
+        kind: "parsed",
+        brief: "Output directory.",
+        parse: String,
+        optional: false
+      },
+      fileName: {
+        kind: "parsed",
+        brief: `Output PPOCR file name. Default: "${DEFAULT_PPOCR_FILE_NAME}"`,
+        parse: String,
+        optional: true
+      },
+      removeBaseImageDir: {
+        kind: "parsed",
+        parse: String,
+        brief: `Remove base image directory from image paths in output. Default: "${DEFAULT_LABEL_STUDIO_OUTPUT_IMAGE_BASE_DIR}"`,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Convert Label Studio output files to PPOCRLabel format"
+  }
+});
+
+// src/commands/toLabelStudio/command.ts
+init_cjs_shims();
+var import_core4 = require("@stricli/core");
+init_constants();
+init_lib();
+var toLabelStudioCommand = (0, import_core4.buildCommand)({
+  loader: async () => {
+    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl5(), impl_exports5));
     return convertToLabelStudio2;
   },
   parameters: {
@@ -3419,10 +3993,10 @@ var toLabelStudioCommand = (0, import_core3.buildCommand)({
 
 // src/commands/toPPOCR/commands.ts
 init_cjs_shims();
-var import_core4 = require("@stricli/core");
+var import_core5 = require("@stricli/core");
 init_constants();
 init_lib();
-var toPPOCRCommand = (0, import_core4.buildCommand)({
+var toPPOCRCommand = (0, import_core5.buildCommand)({
   loader: async () => {
     const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
     return convertToPPOCR2;
@@ -3465,12 +4039,13 @@ var toPPOCRCommand = (0, import_core4.buildCommand)({
 });
 
 // src/app.ts
-var routes = (0, import_core5.buildRouteMap)({
+var routes = (0, import_core6.buildRouteMap)({
   routes: {
     toLabelStudio: toLabelStudioCommand,
     toPPOCR: toPPOCRCommand,
     "enhance-labelstudio": enhanceLabelStudioCommand,
     "enhance-ppocr": enhancePPOCRCommand,
+    "label-studio-output-to-ppocr": labelStudioOutputToPPOCRCommand,
     install: (0, import_auto_complete.buildInstallCommand)("label-studio-converter", {
       bash: "__label-studio-converter_bash_complete"
     }),
@@ -3484,7 +4059,7 @@ var routes = (0, import_core5.buildRouteMap)({
     }
   }
 });
-var app = (0, import_core5.buildApplication)(routes, {
+var app = (0, import_core6.buildApplication)(routes, {
   name: "label-studio-converter",
   versionInfo: {
     currentVersion: version
@@ -3511,9 +4086,9 @@ function buildContext(process2) {
   if (process.env.COMP_LINE?.endsWith(" ")) {
     inputs.push("");
   }
-  await (0, import_core6.proposeCompletions)(app, inputs, buildContext(process));
+  await (0, import_core7.proposeCompletions)(app, inputs, buildContext(process));
   try {
-    for (const { completion } of await (0, import_core6.proposeCompletions)(
+    for (const { completion } of await (0, import_core7.proposeCompletions)(
       app,
       inputs,
       buildContext(process)