合同：打印模板调整

@@ -1194,7 +1194,7 @@ public class ContractDistributorStandardController extends DefaultBaseController
                             addFormulaComponent(formulaComponentList, line.getWidth(), line.getWidthTolPos(), line.getWidthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
 
-                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3(formulaComponentList);
+                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3Compact(formulaComponentList);
                             if (StringUtils.isNotBlank(latex)) {
                                 specImageCells.add(new SpecImageCell(startRow, 5, latex));
                             }
@@ -1238,7 +1238,7 @@ public class ContractDistributorStandardController extends DefaultBaseController
                             addFormulaComponent(formulaComponentList, line.getWidth(), line.getWidthTolPos(), line.getWidthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
 
-                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3(formulaComponentList);
+                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3Compact(formulaComponentList);
                             if (StringUtils.isNotBlank(latex)) {
                                 specImageCells.add(new SpecImageCell(startRow, 9, latex));
                             }
@@ -1253,13 +1253,14 @@ public class ContractDistributorStandardController extends DefaultBaseController
                         }
                     }
 
-                    double specMinScale = 1.0;
                     for (SpecImageCell specCell : specImageCells) {
-                        double scale = LatexFormulaExcelExporterUtil.calculateFitScale(workbook, sheet, specCell.latex, specCell.rowIndex, specCell.colIndex);
-                        specMinScale = Math.min(specMinScale, scale);
-                    }
-                    for (SpecImageCell specCell : specImageCells) {
-                        LatexFormulaExcelExporterUtil.insertLatexImageToCellWithMaxScale(workbook, sheet, specCell.latex, specCell.rowIndex, specCell.colIndex, specMinScale);
+                        LatexFormulaExcelExporterUtil.insertContractLatexImageToCellFillTemplate(
+                                workbook,
+                                sheet,
+                                specCell.latex,
+                                specCell.rowIndex,
+                                specCell.colIndex
+                        );
                     }
 
                     // --- 填充全局变量 ---

@@ -109,7 +109,43 @@ public class LatexFormulaExcelExporterUtil {
         return "\\mathbf{\\mathrm{" + actual + "}}";
     }
 
+    public static String convertToContractSpecLatexSingleLineFixed3Compact(List<FormulaComponent> componentList) {
+        if (CollectionUtils.isEmpty(componentList)) {
+            return "";
+        }
+
+        int nonNullCount = 0;
+        for (FormulaComponent comp : componentList) {
+            if (comp != null && comp.getBase() != null) {
+                nonNullCount++;
+            }
+        }
+        if (nonNullCount <= 0) {
+            return "";
+        }
+
+        String actual = buildLatexLine(componentList, 0, componentList.size(), "\\!\\times\\!");
+        if (actual.isEmpty()) {
+            return "";
+        }
+
+        int missing = Math.max(0, 3 - nonNullCount);
+        if (missing > 0) {
+            StringBuilder phantom = new StringBuilder();
+            for (int i = 0; i < missing; i++) {
+                phantom.append("\\!\\times\\!000^{+00}_{+00}");
+            }
+            actual = actual + "\\phantom{" + phantom + "}";
+        }
+
+        return "\\mathbf{\\mathrm{" + actual + "}}";
+    }
+
     private static String buildLatexLine(List<FormulaComponent> componentList, int startIndex, int endIndexExclusive) {
+        return buildLatexLine(componentList, startIndex, endIndexExclusive, " \\times ");
+    }
+
+    private static String buildLatexLine(List<FormulaComponent> componentList, int startIndex, int endIndexExclusive, String separator) {
         StringBuilder latex = new StringBuilder();
         boolean first = true;
         int end = Math.min(componentList.size(), endIndexExclusive);
@@ -119,7 +155,7 @@ public class LatexFormulaExcelExporterUtil {
                 continue;
             }
             if (!first) {
-                latex.append(" \\times ");
+                latex.append(separator);
             }
             first = false;
 
@@ -253,6 +289,29 @@ public class LatexFormulaExcelExporterUtil {
         insertLatexImageToRegion(workbook, sheet, latex, rowIndex, colIndex, rowRange, colRange, 16, null);
     }
 
+    /**
+     * 合同规格专用：按照模板单元格区域高度优先铺满，并根据区域大小动态选择更合适的渲染字号。
+     */
+    public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                  int rowIndex, int colIndex) throws IOException {
+        int baseFontSize = Math.max(16, resolveCellFontSize(workbook, sheet, rowIndex, colIndex));
+        CellRangeAddress mergedRegion = findMergedRegion(sheet, rowIndex, colIndex);
+        if (mergedRegion != null) {
+            insertContractLatexImageToRegionFillTemplate(
+                    workbook,
+                    sheet,
+                    latex,
+                    mergedRegion.getFirstRow(),
+                    mergedRegion.getFirstColumn(),
+                    mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
+                    mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
+                    baseFontSize
+            );
+            return;
+        }
+        insertContractLatexImageToRegionFillTemplate(workbook, sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize);
+    }
+
     private static final int EMU_PER_PX = 9525;
 
     public static void insertLatexImageToCellWithMaxScale(Workbook workbook, Sheet sheet, String latex, int rowIndex, int colIndex,
@@ -417,6 +476,96 @@ public class LatexFormulaExcelExporterUtil {
         drawing.createPicture(anchor, pictureIdx);
     }
 
+    private static void insertContractLatexImageToRegionFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                     int rowIndex, int colIndex, int rowRange, int colRange,
+                                                                     int baseFontSize) throws IOException {
+        int regionWidthPx = 0;
+        for (int c = colIndex; c < colIndex + colRange; c++) {
+            regionWidthPx += getColumnWidthPx(sheet, c);
+        }
+        int regionHeightPx = 0;
+        for (int r = rowIndex; r < rowIndex + rowRange; r++) {
+            regionHeightPx += getRowHeightPx(sheet, r);
+        }
+
+        int paddingXPx = 4;
+        int paddingYPx = 2;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        RenderedLatexImage renderedImage = renderBestFitLatexImageByHeight(
+                latex,
+                baseFontSize,
+                availableHeightPx
+        );
+        if (renderedImage.image == null) {
+            return;
+        }
+
+        byte[] imageBytes = renderedImage.imageBytes;
+        BufferedImage image = renderedImage.image;
+        int scaledHeightPx = availableHeightPx;
+        int widthByHeightPx = Math.max(1, (int) Math.round(
+                (double) image.getWidth() * scaledHeightPx / Math.max(1, image.getHeight())
+        ));
+        int scaledWidthPx = Math.min(availableWidthPx, widthByHeightPx);
+
+        int offsetXPx = Math.max(paddingXPx, (regionWidthPx - scaledWidthPx) / 2);
+        int offsetYPx = Math.max(paddingYPx, (regionHeightPx - scaledHeightPx) / 2);
+
+        int pictureIdx = workbook.addPicture(imageBytes, Workbook.PICTURE_TYPE_PNG);
+        Drawing<?> drawing = sheet.createDrawingPatriarch();
+        ClientAnchor anchor = workbook.getCreationHelper().createClientAnchor();
+        anchor.setAnchorType(ClientAnchor.AnchorType.MOVE_DONT_RESIZE);
+
+        AnchorCoord x1 = resolveAnchorX(sheet, colIndex, colRange, offsetXPx);
+        AnchorCoord x2 = resolveAnchorX(sheet, colIndex, colRange, offsetXPx + scaledWidthPx);
+        AnchorCoord y1 = resolveAnchorY(sheet, rowIndex, rowRange, offsetYPx);
+        AnchorCoord y2 = resolveAnchorY(sheet, rowIndex, rowRange, offsetYPx + scaledHeightPx);
+
+        anchor.setCol1(x1.index);
+        anchor.setCol2(x2.index);
+        anchor.setRow1(y1.index);
+        anchor.setRow2(y2.index);
+
+        if (anchor instanceof org.apache.poi.hssf.usermodel.HSSFClientAnchor) {
+            int dx1 = pxToHssfDx(sheet, x1.index, x1.offsetPx);
+            int dx2 = pxToHssfDx(sheet, x2.index, x2.offsetPx);
+            int dy1 = pxToHssfDy(sheet, y1.index, y1.offsetPx);
+            int dy2 = pxToHssfDy(sheet, y2.index, y2.offsetPx);
+
+            if (x2.index == x1.index && dx2 <= dx1) {
+                dx2 = Math.min(1023, dx1 + 1);
+            }
+            if (y2.index == y1.index && dy2 <= dy1) {
+                dy2 = Math.min(255, dy1 + 1);
+            }
+
+            anchor.setDx1(dx1);
+            anchor.setDx2(dx2);
+            anchor.setDy1(dy1);
+            anchor.setDy2(dy2);
+        } else {
+            int dx1 = x1.offsetPx * EMU_PER_PX;
+            int dx2 = x2.offsetPx * EMU_PER_PX;
+            int dy1 = y1.offsetPx * EMU_PER_PX;
+            int dy2 = y2.offsetPx * EMU_PER_PX;
+
+            if (x2.index == x1.index && dx2 <= dx1) {
+                dx2 = dx1 + 1;
+            }
+            if (y2.index == y1.index && dy2 <= dy1) {
+                dy2 = dy1 + 1;
+            }
+
+            anchor.setDx1(dx1);
+            anchor.setDx2(dx2);
+            anchor.setDy1(dy1);
+            anchor.setDy2(dy2);
+        }
+
+        drawing.createPicture(anchor, pictureIdx);
+    }
+
     private static int getColumnWidthPx(Sheet sheet, int colIndex) {
         int widthUnits = sheet.getColumnWidth(colIndex);
         return Math.max(1, (int) Math.round(widthUnits / 256.0 * 7.0 + 5));
@@ -428,6 +577,148 @@ public class LatexFormulaExcelExporterUtil {
         return Math.max(1, (int) Math.round(points * 96.0 / 72.0));
     }
 
+    private static RenderedLatexImage renderBestFitLatexImageByHeight(String latex, int preferredFontSize,
+                                                                      int targetHeightPx) throws IOException {
+        int minFontSize = 8;
+        int maxFontSize = Math.max(minFontSize, preferredFontSize + 40);
+        maxFontSize = Math.min(96, maxFontSize);
+        int left = minFontSize;
+        int right = maxFontSize;
+        RenderedLatexImage best = renderLatexImage(latex, minFontSize);
+
+        while (left <= right) {
+            int mid = (left + right) >>> 1;
+            RenderedLatexImage candidate = renderLatexImage(latex, mid);
+            if (candidate.image != null && candidate.image.getHeight() <= targetHeightPx) {
+                best = candidate;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return best;
+    }
+
+    private static RenderedLatexImage renderLatexImage(String latex, int fontSize) throws IOException {
+        byte[] imageBytes = latexToContractImageBytes(latex, fontSize);
+        BufferedImage image;
+        try (ByteArrayInputStream in = new ByteArrayInputStream(imageBytes)) {
+            image = ImageIO.read(in);
+        }
+        return new RenderedLatexImage(imageBytes, image);
+    }
+
+    private static byte[] latexToContractImageBytes(String latex, int fontSize) throws IOException {
+        try {
+            double scale = 5.0;
+            TeXFormula formula = new TeXFormula(latex);
+            TeXIcon icon = formula.createTeXIcon(TeXConstants.STYLE_DISPLAY, fontSize);
+
+            int baseWidth = icon.getIconWidth();
+            int baseHeight = icon.getIconHeight();
+            if (baseWidth <= 0 || baseHeight <= 0) {
+                return new byte[0];
+            }
+
+            int maxWidth = 4200;
+            int maxHeight = 3200;
+            double widthScale = (double) maxWidth / baseWidth;
+            double heightScale = (double) maxHeight / baseHeight;
+            scale = Math.min(scale, Math.min(widthScale, heightScale));
+            scale = Math.max(1.0, scale);
+
+            int scaledWidth = Math.max(1, (int) Math.ceil(baseWidth * scale));
+            int scaledHeight = Math.max(1, (int) Math.ceil(baseHeight * scale));
+            BufferedImage image = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_RGB);
+            Graphics2D g2 = image.createGraphics();
+            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+            g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+            g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
+            g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
+            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+
+            java.awt.Font renderFont = new java.awt.Font("宋体", java.awt.Font.BOLD, fontSize);
+            g2.setFont(renderFont);
+            g2.setColor(Color.WHITE);
+            g2.fillRect(0, 0, scaledWidth, scaledHeight);
+            g2.scale(scale, scale);
+
+            JLabel label = new JLabel();
+            label.setFont(renderFont);
+            label.setForeground(Color.BLACK);
+            icon.paintIcon(label, g2, 0, 0);
+            g2.dispose();
+
+            image = trimWhitespace(image, 248, 0);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ImageIO.write(image, "png", baos);
+            return baos.toByteArray();
+        } catch (Exception e) {
+            throw new IOException("合同规格图片渲染失败: " + e.getMessage(), e);
+        }
+    }
+
+    private static BufferedImage trimWhitespace(BufferedImage source, int whiteThreshold, int marginPx) {
+        if (source == null || source.getWidth() <= 0 || source.getHeight() <= 0) {
+            return source;
+        }
+
+        int minX = source.getWidth();
+        int minY = source.getHeight();
+        int maxX = -1;
+        int maxY = -1;
+
+        for (int y = 0; y < source.getHeight(); y++) {
+            for (int x = 0; x < source.getWidth(); x++) {
+                if (!isNearWhite(source.getRGB(x, y), whiteThreshold)) {
+                    minX = Math.min(minX, x);
+                    minY = Math.min(minY, y);
+                    maxX = Math.max(maxX, x);
+                    maxY = Math.max(maxY, y);
+                }
+            }
+        }
+
+        if (maxX < minX || maxY < minY) {
+            return source;
+        }
+
+        int cropMinX = Math.max(0, minX - marginPx);
+        int cropMinY = Math.max(0, minY - marginPx);
+        int cropMaxX = Math.min(source.getWidth() - 1, maxX + marginPx);
+        int cropMaxY = Math.min(source.getHeight() - 1, maxY + marginPx);
+        int cropWidth = cropMaxX - cropMinX + 1;
+        int cropHeight = cropMaxY - cropMinY + 1;
+
+        if (cropWidth >= source.getWidth() && cropHeight >= source.getHeight()) {
+            return source;
+        }
+
+        BufferedImage trimmed = new BufferedImage(cropWidth, cropHeight, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g2 = trimmed.createGraphics();
+        g2.drawImage(source.getSubimage(cropMinX, cropMinY, cropWidth, cropHeight), 0, 0, null);
+        g2.dispose();
+        return trimmed;
+    }
+
+    private static boolean isNearWhite(int rgb, int whiteThreshold) {
+        int red = (rgb >> 16) & 0xFF;
+        int green = (rgb >> 8) & 0xFF;
+        int blue = rgb & 0xFF;
+        return red >= whiteThreshold && green >= whiteThreshold && blue >= whiteThreshold;
+    }
+
+    private static class RenderedLatexImage {
+        final byte[] imageBytes;
+        final BufferedImage image;
+
+        private RenderedLatexImage(byte[] imageBytes, BufferedImage image) {
+            this.imageBytes = imageBytes;
+            this.image = image;
+        }
+    }
+
     private static class AnchorCoord {
         final int index;
         final int offsetPx;