Upload imageProcessor.js

src/lib/imageProcessor.js

@@ -6,13 +6,18 @@ const sharp = require('sharp')
  */
 class ImageProcessor {
   constructor() {
-    // 长图阈值：高度超过宽度*2.5倍（更合理的阈值）
-    this.LONG_IMAGE_RATIO = 2.5
+    // 长图阈值：高度超过宽度*3倍（更合理的阈值）
+    this.LONG_IMAGE_RATIO = 3
     // 重叠像素范围
     this.OVERLAP_MIN = 50
     this.OVERLAP_MAX = 100
     // 默认重叠像素
     this.DEFAULT_OVERLAP = 75
+
+    // 智能切割参数 - 针对模型识别效果优化
+    this.OPTIMAL_SEGMENT_HEIGHT = 3000  // 理想片段高度
+    this.MAX_SEGMENT_HEIGHT = 3500      // 最大片段高度
+    this.MIN_SEGMENT_HEIGHT = 2500      // 最小片段高度
   }
 
   /**
@@ -48,7 +53,71 @@ class ImageProcessor {
   }
 
   /**
-   * 计算切割参数
+   * 计算最优片段高度
+   * @param {number} width - 图片宽度
+   * @param {number} height - 图片高度
+   * @param {number} overlap - 重叠像素数
+   * @returns {Object} 包含最优高度和片段数的对象
+   */
+  calculateOptimalSegmentHeight(width, height, overlap = this.DEFAULT_OVERLAP) {
+    // 如果图片高度小于最大片段高度，直接返回原高度
+    if (height <= this.MAX_SEGMENT_HEIGHT) {
+      return {
+        segmentHeight: height,
+        segmentCount: 1,
+        strategy: 'single_segment'
+      }
+    }
+
+    // 计算理想的片段数量（基于理想高度）
+    const idealSegmentCount = Math.ceil(height / this.OPTIMAL_SEGMENT_HEIGHT)
+
+    // 计算每个片段的理想高度（不考虑重叠）
+    const baseSegmentHeight = Math.floor(height / idealSegmentCount)
+
+    // 检查是否在合理范围内
+    if (baseSegmentHeight >= this.MIN_SEGMENT_HEIGHT && baseSegmentHeight <= this.MAX_SEGMENT_HEIGHT) {
+      return {
+        segmentHeight: baseSegmentHeight,
+        segmentCount: idealSegmentCount,
+        strategy: 'optimal_division'
+      }
+    }
+
+    // 如果理想高度太小，减少片段数量
+    if (baseSegmentHeight < this.MIN_SEGMENT_HEIGHT) {
+      const adjustedSegmentCount = Math.max(1, Math.floor(height / this.MIN_SEGMENT_HEIGHT))
+      const adjustedSegmentHeight = Math.floor(height / adjustedSegmentCount)
+
+      return {
+        segmentHeight: Math.min(adjustedSegmentHeight, this.MAX_SEGMENT_HEIGHT),
+        segmentCount: adjustedSegmentCount,
+        strategy: 'min_height_constraint'
+      }
+    }
+
+    // 如果理想高度太大，增加片段数量
+    if (baseSegmentHeight > this.MAX_SEGMENT_HEIGHT) {
+      const adjustedSegmentCount = Math.ceil(height / this.MAX_SEGMENT_HEIGHT)
+      const adjustedSegmentHeight = Math.floor(height / adjustedSegmentCount)
+
+      return {
+        segmentHeight: adjustedSegmentHeight,
+        segmentCount: adjustedSegmentCount,
+        strategy: 'max_height_constraint'
+      }
+    }
+
+    // 兜底策略：使用最大高度
+    return {
+      segmentHeight: this.MAX_SEGMENT_HEIGHT,
+      segmentCount: Math.ceil(height / this.MAX_SEGMENT_HEIGHT),
+      strategy: 'fallback'
+    }
+  }
+
+  /**
+   * 计算切割参数（智能自适应版本）
    * @param {number} width - 图片宽度
    * @param {number} height - 图片高度
    * @param {number} overlap - 重叠像素数
@@ -56,26 +125,39 @@ class ImageProcessor {
    */
   calculateCropRegions(width, height, overlap = this.DEFAULT_OVERLAP) {
     const regions = []
-    const maxHeight = width * this.LONG_IMAGE_RATIO // 每个片段的最大高度
-    
+
+    // 计算最优片段高度
+    const optimalConfig = this.calculateOptimalSegmentHeight(width, height, overlap)
+    const { segmentHeight: baseSegmentHeight, segmentCount, strategy } = optimalConfig
+
+    console.log(`[智能切割] 图片尺寸: ${width}x${height}, 策略: ${strategy}, 预计片段数: ${segmentCount}, 基础高度: ${baseSegmentHeight}`)
+
     let currentTop = 0
     let segmentIndex = 0
-    
-    while (currentTop < height) {
+
+    while (currentTop < height && segmentIndex < segmentCount * 2) { // 防止无限循环
       const remainingHeight = height - currentTop
-      let segmentHeight = Math.min(maxHeight, remainingHeight)
-      
+      let segmentHeight = Math.min(baseSegmentHeight, remainingHeight)
+
       // 如果不是第一个片段，需要向上扩展重叠区域
       if (segmentIndex > 0) {
-        currentTop = Math.max(0, currentTop - overlap)
-        segmentHeight = Math.min(maxHeight + overlap, height - currentTop)
+        const overlapTop = Math.min(overlap, currentTop)
+        currentTop = currentTop - overlapTop
+        segmentHeight = Math.min(baseSegmentHeight + overlapTop, height - currentTop)
       }
-      
+
       // 如果不是最后一个片段，需要向下扩展重叠区域
-      if (currentTop + segmentHeight < height) {
-        segmentHeight = Math.min(segmentHeight + overlap, height - currentTop)
+      const isLastSegment = (currentTop + segmentHeight >= height) || (segmentIndex >= segmentCount - 1)
+      if (!isLastSegment) {
+        const overlapBottom = Math.min(overlap, remainingHeight - segmentHeight)
+        segmentHeight = Math.min(segmentHeight + overlapBottom, height - currentTop)
       }
-      
+
+      // 确保片段高度在合理范围内
+      segmentHeight = Math.max(segmentHeight, this.MIN_SEGMENT_HEIGHT)
+      segmentHeight = Math.min(segmentHeight, this.MAX_SEGMENT_HEIGHT)
+      segmentHeight = Math.min(segmentHeight, height - currentTop) // 不能超出图片边界
+
       regions.push({
         top: currentTop,
         left: 0,
@@ -83,14 +165,30 @@ class ImageProcessor {
         height: segmentHeight,
         segmentIndex: segmentIndex,
         isFirst: segmentIndex === 0,
-        isLast: currentTop + segmentHeight >= height
+        isLast: currentTop + segmentHeight >= height,
+        strategy: strategy
       })
-      
-      // 移动到下一个片段的起始位置（考虑重叠）
-      currentTop += (segmentIndex === 0 ? maxHeight : maxHeight - overlap)
+
+      console.log(`[切割片段] 片段${segmentIndex + 1}: top=${currentTop}, height=${segmentHeight}, 范围=[${currentTop}, ${currentTop + segmentHeight}]`)
+
+      // 移动到下一个片段的起始位置
+      if (segmentIndex === 0) {
+        // 第一个片段：直接移动基础高度
+        currentTop += baseSegmentHeight
+      } else {
+        // 后续片段：移动基础高度减去重叠
+        currentTop += Math.max(baseSegmentHeight - overlap, 1)
+      }
+
       segmentIndex++
+
+      // 如果已经覆盖了整个图片，退出循环
+      if (currentTop >= height) {
+        break
+      }
     }
-    
+
+    console.log(`[切割完成] 实际生成${regions.length}个片段`)
     return regions
   }
 
@@ -172,13 +270,18 @@ class ImageProcessor {
       }
 
       const { width, height, format } = detection
+
+      // 计算最优切割配置
+      const optimalConfig = this.calculateOptimalSegmentHeight(width, height, overlap)
       const regions = this.calculateCropRegions(width, height, overlap)
       const segments = []
 
       // 选择最优输出格式
       const outputFormat = this.getOptimalOutputFormat(format)
 
-      console.log(`检测到长图 ${width}x${height} (${format})，将切割为 ${regions.length} 个片段，输出格式: ${outputFormat}`)
+      console.log(`检测到长图 ${width}x${height} (${format})，智能切割策略: ${optimalConfig.strategy}`)
+      console.log(`切割配置: 目标高度=${optimalConfig.segmentHeight}px, 预计片段=${optimalConfig.segmentCount}个, 实际片段=${regions.length}个`)
+      console.log(`输出格式: ${outputFormat}, 重叠像素: ${overlap}px`)
 
       for (const region of regions) {
         const sharpInstance = sharp(imageBuffer)
@@ -206,6 +309,7 @@ class ImageProcessor {
             segmentHeight: region.height,
             originalFormat: format,
             outputFormat: outputFormat,
+            strategy: region.strategy,
             cropRegion: {
               top: region.top,
               left: region.left,
@@ -215,7 +319,8 @@ class ImageProcessor {
           }
         })
 
-        console.log(`生成片段 ${region.segmentIndex + 1}/${regions.length}: ${region.width}x${region.height} (top: ${region.top})`)
+        const heightStatus = region.height <= 3000 ? '✓理想' : region.height <= 3500 ? '✓良好' : '⚠超限'
+        console.log(`生成片段 ${region.segmentIndex + 1}/${regions.length}: ${region.width}x${region.height} (${heightStatus}) [${region.top}-${region.top + region.height}]`)
       }
 
       return segments