Upload public.js

backend/src/routes/public.js

@@ -19,8 +19,10 @@ const generateSlideHTML = (pptData, slideIndex, title) => {
   const slide = pptData.slides[slideIndex];
   const theme = pptData.theme || {};
   
-  // 精确计算PPT内容的真实尺寸 - 使用编辑器的实际尺寸数据
+  // 精确计算PPT内容的真实尺寸 - 基于填满画布的图像元素推断
   const calculatePptDimensions = (slide) => {
+    console.log('开始计算PPT尺寸，当前slide元素数量:', slide.elements?.length || 0);
+    
     // 1. 优先使用PPT数据中的viewportSize和viewportRatio（编辑器的真实尺寸）
     if (pptData.viewportSize && pptData.viewportRatio) {
       const result = {
@@ -61,65 +63,124 @@ const generateSlideHTML = (pptData, slideIndex, title) => {
       return result;
     }
     
-    // 5. 根据元素分布计算合适的尺寸
-    if (!slide.elements || slide.elements.length === 0) {
-      // 如果没有元素，使用标准PPT尺寸 - 使用PPTist默认尺寸
-      const result = { width: 900, height: 506 }; // 16:9标准比例 (viewportSize: 900, viewportRatio: 0.5625)
-      console.log(`使用默认尺寸: ${result.width}x${result.height} (16:9比例)`);
-      return result;
-    }
-    
-    let maxRight = 0;
-    let maxBottom = 0;
-    let minLeft = Infinity;
-    let minTop = Infinity;
-    
-    // 计算所有元素的实际边界
-    slide.elements.forEach(element => {
-      const left = element.left || 0;
-      const top = element.top || 0;
-      const width = element.width || 0;
-      const height = element.height || 0;
+    // 5. 基于填满画布的图像元素精确推断PPT尺寸
+    if (slide.elements && slide.elements.length > 0) {
+      // 寻找可能填满画布的图像元素（left=0, top=0 或接近0，且尺寸较大）
+      const candidateImages = slide.elements.filter(element => 
+        element.type === 'image' && 
+        Math.abs(element.left || 0) <= 10 &&  // 允许小偏差
+        Math.abs(element.top || 0) <= 10 &&   // 允许小偏差
+        (element.width || 0) >= 800 &&        // 宽度至少800
+        (element.height || 0) >= 400          // 高度至少400
+      );
       
-      const elementRight = left + width;
-      const elementBottom = top + height;
+      if (candidateImages.length > 0) {
+        // 使用面积最大的图像作为画布尺寸参考
+        const referenceImage = candidateImages.reduce((max, current) => {
+          const maxArea = (max.width || 0) * (max.height || 0);
+          const currentArea = (current.width || 0) * (current.height || 0);
+          return currentArea > maxArea ? current : max;
+        });
+        
+        const result = {
+          width: Math.ceil(referenceImage.width || 1000),
+          height: Math.ceil(referenceImage.height || 562)
+        };
+        
+        console.log(`基于填满画布的图像推断PPT尺寸: ${result.width}x${result.height} (参考图像: ${referenceImage.id})`);
+        console.log(`参考图像信息: left=${referenceImage.left}, top=${referenceImage.top}, width=${referenceImage.width}, height=${referenceImage.height}`);
+        
+        return result;
+      }
       
-      maxRight = Math.max(maxRight, elementRight);
-      maxBottom = Math.max(maxBottom, elementBottom);
-      minLeft = Math.min(minLeft, left);
-      minTop = Math.min(minTop, top);
-    });
-    
-    // 重置无限值
-    if (minLeft === Infinity) minLeft = 0;
-    if (minTop === Infinity) minTop = 0;
-    
-    // 计算内容区域的实际尺寸
-    const contentWidth = maxRight - minLeft;
-    const contentHeight = maxBottom - minTop;
-    
-    // 添加适当的边距，确保内容不被裁切
-    const paddingX = Math.max(40, Math.abs(minLeft));
-    const paddingY = Math.max(40, Math.abs(minTop));
-    
-    // 计算最终的PPT尺寸，但限制在合理范围内
-    let finalWidth = Math.max(contentWidth + paddingX * 2, 900);
-    let finalHeight = Math.max(contentHeight + paddingY * 2, 506);
-    
-    // 如果计算出的尺寸过大，使用标准比例缩放
-    if (finalWidth > 1920 || finalHeight > 1080) {
-      const scale = Math.min(1920 / finalWidth, 1080 / finalHeight);
-      finalWidth = Math.ceil(finalWidth * scale);
-      finalHeight = Math.ceil(finalHeight * scale);
+      // 如果没有找到填满画布的图像，回退到边界计算
+      let maxRight = 0;
+      let maxBottom = 0;
+      let minLeft = Infinity;
+      let minTop = Infinity;
+      
+      // 计算所有元素的实际边界
+      slide.elements.forEach(element => {
+        const left = element.left || 0;
+        const top = element.top || 0;
+        const width = element.width || 0;
+        const height = element.height || 0;
+        
+        const elementRight = left + width;
+        const elementBottom = top + height;
+        
+        maxRight = Math.max(maxRight, elementRight);
+        maxBottom = Math.max(maxBottom, elementBottom);
+        minLeft = Math.min(minLeft, left);
+        minTop = Math.min(minTop, top);
+        
+        console.log(`元素 ${element.id}: type=${element.type}, left=${left}, top=${top}, width=${width}, height=${height}, right=${elementRight}, bottom=${elementBottom}`);
+      });
+      
+      // 重置无限值
+      if (minLeft === Infinity) minLeft = 0;
+      if (minTop === Infinity) minTop = 0;
+      
+      console.log(`元素边界: minLeft=${minLeft}, minTop=${minTop}, maxRight=${maxRight}, maxBottom=${maxBottom}`);
+      
+      // 根据实际元素分布确定画布尺寸
+      const canvasLeft = Math.min(0, minLeft);
+      const canvasTop = Math.min(0, minTop);
+      const canvasRight = Math.max(maxRight, 1000); // 最小宽度1000（基于GitHub数据）
+      const canvasBottom = Math.max(maxBottom, 562);  // 最小高度562（基于GitHub数据）
+      
+      // 计算最终的画布尺寸
+      let finalWidth = canvasRight - canvasLeft;
+      let finalHeight = canvasBottom - canvasTop;
+      
+      // 基于从GitHub仓库观察到的实际比例进行智能调整
+      const currentRatio = finalWidth / finalHeight;
+      console.log(`当前计算比例: ${currentRatio.toFixed(3)}`);
+      
+      // 从GitHub数据分析：1000x562.5 ≈ 1.78 (接近16:9的1.77)
+      const targetRatio = 1000 / 562.5; // ≈ 1.778
+      
+      // 如果比例接近观察到的标准比例，调整为精确比例
+      if (Math.abs(currentRatio - targetRatio) < 0.2) {
+        if (finalWidth > finalHeight * targetRatio) {
+          finalHeight = finalWidth / targetRatio;
+        } else {
+          finalWidth = finalHeight * targetRatio;
+        }
+        console.log(`调整为GitHub观察到的标准比例: ${targetRatio.toFixed(3)}`);
+      }
+      // 如果比例接近16:9，调整为标准16:9
+      else if (Math.abs(currentRatio - 16/9) < 0.1) {
+        if (finalWidth > finalHeight * 16/9) {
+          finalHeight = finalWidth / (16/9);
+        } else {
+          finalWidth = finalHeight * (16/9);
+        }
+        console.log(`调整为16:9比例`);
+      }
+      // 如果比例接近4:3，调整为标准4:3
+      else if (Math.abs(currentRatio - 4/3) < 0.1) {
+        if (finalWidth > finalHeight * 4/3) {
+          finalHeight = finalWidth / (4/3);
+        } else {
+          finalWidth = finalHeight * (4/3);
+        }
+        console.log(`调整为4:3比例`);
+      }
+      
+      // 确保尺寸为偶数（避免半像素问题）
+      finalWidth = Math.ceil(finalWidth / 2) * 2;
+      finalHeight = Math.ceil(finalHeight / 2) * 2;
+      
+      const result = { width: finalWidth, height: finalHeight };
+      console.log(`根据元素边界计算最终尺寸: ${result.width}x${result.height}, 比例: ${(result.width/result.height).toFixed(3)}`);
+      
+      return result;
     }
     
-    // 确保尺寸为偶数（避免半像素问题）
-    finalWidth = Math.ceil(finalWidth / 2) * 2;
-    finalHeight = Math.ceil(finalHeight / 2) * 2;
-    
-    const result = { width: finalWidth, height: finalHeight };
-    console.log(`根据元素计算尺寸: ${result.width}x${result.height}`);
-    
+    // 6. 如果没有元素，使用从GitHub数据分析得出的标准尺寸
+    const result = { width: 1000, height: 562 }; // 基于GitHub仓库中观察到的实际数据
+    console.log(`使用GitHub数据分析的默认尺寸: ${result.width}x${result.height} (1000x562, 比例≈1.78)`);
     return result;
   };