Merge branch 'master_after0506' into master_after0506_report02

@@ -1194,7 +1194,7 @@ public class ContractDistributorStandardController extends DefaultBaseController
                             addFormulaComponent(formulaComponentList, line.getWidth(), line.getWidthTolPos(), line.getWidthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getWidth(), line.getWidthTolPos(), line.getWidthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
 
 
-                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3(formulaComponentList);
+                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3Compact(formulaComponentList);
                             if (StringUtils.isNotBlank(latex)) {
                             if (StringUtils.isNotBlank(latex)) {
                                 specImageCells.add(new SpecImageCell(startRow, 5, 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.getWidth(), line.getWidthTolPos(), line.getWidthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
                             addFormulaComponent(formulaComponentList, line.getLength(), line.getLengthTolPos(), line.getLengthTolNeg());
 
 
-                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3(formulaComponentList);
+                            String latex = LatexFormulaExcelExporterUtil.convertToContractSpecLatexSingleLineFixed3Compact(formulaComponentList);
                             if (StringUtils.isNotBlank(latex)) {
                             if (StringUtils.isNotBlank(latex)) {
                                 specImageCells.add(new SpecImageCell(startRow, 9, latex));
                                 specImageCells.add(new SpecImageCell(startRow, 9, latex));
                             }
                             }
@@ -1253,13 +1253,42 @@ public class ContractDistributorStandardController extends DefaultBaseController
                         }
                         }
                     }
                     }
 
 
-                    double specMinScale = 1.0;
+                    int contractSpecFontSize = Integer.MAX_VALUE;
                     for (SpecImageCell specCell : specImageCells) {
                     for (SpecImageCell specCell : specImageCells) {
-                        double scale = LatexFormulaExcelExporterUtil.calculateFitScale(workbook, sheet, specCell.latex, specCell.rowIndex, specCell.colIndex);
-                        specMinScale = Math.min(specMinScale, scale);
+                        int currentFontSize = LatexFormulaExcelExporterUtil.calculateContractReferenceFontSize(
+                                workbook,
+                                sheet,
+                                specCell.rowIndex,
+                                specCell.colIndex
+                        );
+                        contractSpecFontSize = Math.min(contractSpecFontSize, currentFontSize);
                     }
                     }
+                    if (contractSpecFontSize == Integer.MAX_VALUE) {
+                        contractSpecFontSize = 16;
+                    }
+
+                    double contractSpecScale = 1.0;
+                    for (SpecImageCell specCell : specImageCells) {
+                        double currentScale = LatexFormulaExcelExporterUtil.calculateContractReferenceFitScale(
+                                workbook,
+                                sheet,
+                                specCell.rowIndex,
+                                specCell.colIndex,
+                                contractSpecFontSize
+                        );
+                        contractSpecScale = Math.min(contractSpecScale, currentScale);
+                    }
+
                     for (SpecImageCell specCell : specImageCells) {
                     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,
+                                contractSpecFontSize,
+                                contractSpecScale
+                        );
                     }
                     }
 
 
                     // --- 填充全局变量 ---
                     // --- 填充全局变量 ---

@@ -444,7 +444,7 @@ public class PurchaseOrderInfoController extends DefaultBaseController {
                     dataMap.put("supplyUnit", supplyUnitDicItem == null ? "" : supplyUnitDicItem.getName());
                     dataMap.put("supplyUnit", supplyUnitDicItem == null ? "" : supplyUnitDicItem.getName());
                     dataMap.put("orderNo", data.getOrderNo());
                     dataMap.put("orderNo", data.getOrderNo());
                     dataMap.put("orderingUnitName", data.getOrderingUnitName());
                     dataMap.put("orderingUnitName", data.getOrderingUnitName());
-                    dataMap.put("workshopName", data.getWorkshopName());
+                    dataMap.put("workshopName", data.getWorkshopName() == null ? "" : data.getWorkshopName());
                     dataMap.put("customerTier", data.getCustomerTier());
                     dataMap.put("customerTier", data.getCustomerTier());
                     dataMap.put("orderDate", data.getOrderDate() == null ? "" : data.getOrderDate().format(dateFormatter));
                     dataMap.put("orderDate", data.getOrderDate() == null ? "" : data.getOrderDate().format(dateFormatter));
 
 

@@ -243,6 +243,7 @@ public class BusinessDataExportHandler implements ExportHandler {
                     SysDataDicItem supplyUnitDicItem = sysDataDicItemService.findByCode("SUPPLIER", orderInfo.getSupplyUnit());
                     SysDataDicItem supplyUnitDicItem = sysDataDicItemService.findByCode("SUPPLIER", orderInfo.getSupplyUnit());
                     dataMap.put("supplyUnit", supplyUnitDicItem == null ? "" : supplyUnitDicItem.getName());
                     dataMap.put("supplyUnit", supplyUnitDicItem == null ? "" : supplyUnitDicItem.getName());
                     dataMap.put("orderNo", orderInfo.getOrderNo());
                     dataMap.put("orderNo", orderInfo.getOrderNo());
+                    dataMap.put("workshopName", orderInfo.getWorkshopName() == null ? "" : orderInfo.getWorkshopName());
                     dataMap.put("orderingUnitName", orderInfo.getOrderingUnitName());
                     dataMap.put("orderingUnitName", orderInfo.getOrderingUnitName());
                     dataMap.put("customerTier", orderInfo.getCustomerTier());
                     dataMap.put("customerTier", orderInfo.getCustomerTier());
                     dataMap.put("orderDate", orderInfo.getOrderDate() == null ? "" : orderInfo.getOrderDate().format(dateFormatter));
                     dataMap.put("orderDate", orderInfo.getOrderDate() == null ? "" : orderInfo.getOrderDate().format(dateFormatter));
@@ -288,7 +289,8 @@ public class BusinessDataExportHandler implements ExportHandler {
                         }
                         }
                         File pdfFile = ExcelUtil.convertExcelToPdf(tempExcel, "/usr/bin/libreoffice --headless --convert-to pdf --outdir %s %s");
                         File pdfFile = ExcelUtil.convertExcelToPdf(tempExcel, "/usr/bin/libreoffice --headless --convert-to pdf --outdir %s %s");
                         try (InputStream pdfIn = new FileInputStream(pdfFile)) {
                         try (InputStream pdfIn = new FileInputStream(pdfFile)) {
-                            ZipEntry entry = new ZipEntry(orderInfo.getOrderNo() + "-订货单打印-" + createTime + ".pdf");
+                            ZipEntry entry = new ZipEntry(orderInfo.getOrderNo() + "-"
+                                    + orderInfo.getOrderingUnitName() + "-" + orderInfo.getWorkshopName() + "-订货单打印" + ".pdf");
                             zos.putNextEntry(entry);
                             zos.putNextEntry(entry);
                             byte[] buffer = new byte[8192];
                             byte[] buffer = new byte[8192];
                             int len;
                             int len;
@@ -307,7 +309,8 @@ public class BusinessDataExportHandler implements ExportHandler {
                     } else {
                     } else {
                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
                         workbook.write(baos);
                         workbook.write(baos);
-                        ZipEntry entry = new ZipEntry(orderInfo.getOrderNo() + "-订货单打印-" + createTime + ".xlsx");
+                        ZipEntry entry = new ZipEntry(orderInfo.getOrderNo() + "-"
+                                + orderInfo.getOrderingUnitName() + "-" + orderInfo.getWorkshopName() + "-订货单打印" + ".xlsx");
                         zos.putNextEntry(entry);
                         zos.putNextEntry(entry);
                         zos.write(baos.toByteArray());
                         zos.write(baos.toByteArray());
                         zos.closeEntry();
                         zos.closeEntry();

@@ -24,6 +24,9 @@ import java.util.List;
 @Slf4j
 @Slf4j
 public class LatexFormulaExcelExporterUtil {
 public class LatexFormulaExcelExporterUtil {
 
 
+    private static final String CONTRACT_SPEC_REFERENCE_LATEX =
+            "\\mathbf{\\mathrm{22^{+0.2}_{+0.1}\\!\\times\\!22^{+0.2}_{+0.1}\\!\\times\\!22^{+0.2}_{+0.1}}}";
+
     public static String convertToLatex(List<FormulaComponent> componentList) {
     public static String convertToLatex(List<FormulaComponent> componentList) {
         if (CollectionUtils.isEmpty(componentList)) {
         if (CollectionUtils.isEmpty(componentList)) {
             return "";
             return "";
@@ -97,11 +100,45 @@ public class LatexFormulaExcelExporterUtil {
             return "";
             return "";
         }
         }
 
 
+        String referenceComponentLatex = resolveReferenceComponentLatex(componentList);
         int missing = Math.max(0, 3 - nonNullCount);
         int missing = Math.max(0, 3 - nonNullCount);
         if (missing > 0) {
         if (missing > 0) {
             StringBuilder phantom = new StringBuilder();
             StringBuilder phantom = new StringBuilder();
             for (int i = 0; i < missing; i++) {
             for (int i = 0; i < missing; i++) {
-                phantom.append(" \\times 000^{+00}_{+00}");
+                phantom.append(" \\times ").append(referenceComponentLatex);
+            }
+            actual = actual + "\\phantom{" + phantom + "}";
+        }
+
+        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 "";
+        }
+
+        String referenceComponentLatex = resolveReferenceComponentLatex(componentList);
+        int missing = Math.max(0, 3 - nonNullCount);
+        if (missing > 0) {
+            StringBuilder phantom = new StringBuilder();
+            for (int i = 0; i < missing; i++) {
+                phantom.append("\\!\\times\\!").append(referenceComponentLatex);
             }
             }
             actual = actual + "\\phantom{" + phantom + "}";
             actual = actual + "\\phantom{" + phantom + "}";
         }
         }
@@ -110,6 +147,10 @@ public class LatexFormulaExcelExporterUtil {
     }
     }
 
 
     private static String buildLatexLine(List<FormulaComponent> componentList, int startIndex, int endIndexExclusive) {
     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();
         StringBuilder latex = new StringBuilder();
         boolean first = true;
         boolean first = true;
         int end = Math.min(componentList.size(), endIndexExclusive);
         int end = Math.min(componentList.size(), endIndexExclusive);
@@ -119,24 +160,48 @@ public class LatexFormulaExcelExporterUtil {
                 continue;
                 continue;
             }
             }
             if (!first) {
             if (!first) {
-                latex.append(" \\times ");
+                latex.append(separator);
             }
             }
             first = false;
             first = false;
+            latex.append(buildLatexComponent(comp));
+        }
+        return latex.toString();
+    }
 
 
-            latex.append(formatScientificNotation(comp.getBase()));
-            if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) >= 0) {
-                latex.append("^{+").append(formatScientificNotation(comp.getSup())).append("}");
+    private static String resolveReferenceComponentLatex(List<FormulaComponent> componentList) {
+        String reference = "000^{+00}_{+00}";
+        int maxLength = reference.length();
+        for (FormulaComponent comp : componentList) {
+            if (comp == null || comp.getBase() == null) {
+                continue;
             }
             }
-            if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) < 0) {
-                latex.append("^{").append(formatScientificNotation(comp.getSup())).append("}");
+            String candidate = buildLatexComponent(comp);
+            if (candidate.length() > maxLength) {
+                reference = candidate;
+                maxLength = candidate.length();
             }
             }
+        }
+        return reference;
+    }
 
 
-            if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) >= 0) {
-                latex.append("_{+").append(formatScientificNotation(comp.getSub())).append("}");
-            }
-            if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) < 0) {
-                latex.append("_{").append(formatScientificNotation(comp.getSub())).append("}");
-            }
+    private static String buildLatexComponent(FormulaComponent comp) {
+        if (comp == null || comp.getBase() == null) {
+            return "";
+        }
+        StringBuilder latex = new StringBuilder();
+        latex.append(formatScientificNotation(comp.getBase()));
+        if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) >= 0) {
+            latex.append("^{+").append(formatScientificNotation(comp.getSup())).append("}");
+        }
+        if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) < 0) {
+            latex.append("^{").append(formatScientificNotation(comp.getSup())).append("}");
+        }
+
+        if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) >= 0) {
+            latex.append("_{+").append(formatScientificNotation(comp.getSub())).append("}");
+        }
+        if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) < 0) {
+            latex.append("_{").append(formatScientificNotation(comp.getSub())).append("}");
         }
         }
         return latex.toString();
         return latex.toString();
     }
     }
@@ -253,6 +318,86 @@ public class LatexFormulaExcelExporterUtil {
         insertLatexImageToRegion(workbook, sheet, latex, rowIndex, colIndex, rowRange, colRange, 16, null);
         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));
+        insertContractLatexImageToCellFillTemplate(workbook, sheet, latex, rowIndex, colIndex, baseFontSize);
+    }
+
+    public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                  int rowIndex, int colIndex, int baseFontSize) throws IOException {
+        insertContractLatexImageToCellFillTemplate(workbook, sheet, latex, rowIndex, colIndex, baseFontSize, null);
+    }
+
+    public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                  int rowIndex, int colIndex, int baseFontSize,
+                                                                  Double maxScale) throws IOException {
+        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,
+                    maxScale
+            );
+            return;
+        }
+        insertContractLatexImageToRegionFillTemplate(workbook, sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize, maxScale);
+    }
+
+    public static int calculateContractBestFontSize(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) {
+            return calculateContractBestFontSizeForRegion(
+                    sheet,
+                    latex,
+                    mergedRegion.getFirstRow(),
+                    mergedRegion.getFirstColumn(),
+                    mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
+                    mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
+                    baseFontSize
+            );
+        }
+        return calculateContractBestFontSizeForRegion(sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize);
+    }
+
+    public static int calculateContractReferenceFontSize(Workbook workbook, Sheet sheet,
+                                                         int rowIndex, int colIndex) throws IOException {
+        return calculateContractBestFontSize(workbook, sheet, CONTRACT_SPEC_REFERENCE_LATEX, rowIndex, colIndex);
+    }
+
+    public static double calculateContractFitScale(Workbook workbook, Sheet sheet, String latex,
+                                                   int rowIndex, int colIndex, int fontSize) throws IOException {
+        CellRangeAddress mergedRegion = findMergedRegion(sheet, rowIndex, colIndex);
+        if (mergedRegion != null) {
+            return calculateContractFitScaleForRegion(
+                    sheet,
+                    latex,
+                    mergedRegion.getFirstRow(),
+                    mergedRegion.getFirstColumn(),
+                    mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
+                    mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
+                    fontSize
+            );
+        }
+        return calculateContractFitScaleForRegion(sheet, latex, rowIndex, colIndex, 1, 1, fontSize);
+    }
+
+    public static double calculateContractReferenceFitScale(Workbook workbook, Sheet sheet,
+                                                            int rowIndex, int colIndex, int fontSize) throws IOException {
+        return calculateContractFitScale(workbook, sheet, CONTRACT_SPEC_REFERENCE_LATEX, rowIndex, colIndex, fontSize);
+    }
+
     private static final int EMU_PER_PX = 9525;
     private static final int EMU_PER_PX = 9525;
 
 
     public static void insertLatexImageToCellWithMaxScale(Workbook workbook, Sheet sheet, String latex, int rowIndex, int colIndex,
     public static void insertLatexImageToCellWithMaxScale(Workbook workbook, Sheet sheet, String latex, int rowIndex, int colIndex,
@@ -417,6 +562,148 @@ public class LatexFormulaExcelExporterUtil {
         drawing.createPicture(anchor, pictureIdx);
         drawing.createPicture(anchor, pictureIdx);
     }
     }
 
 
+    private static void insertContractLatexImageToRegionFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                     int rowIndex, int colIndex, int rowRange, int colRange,
+                                                                     int baseFontSize, Double maxScale) 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 = 6;
+        int paddingYPx = 4;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        RenderedLatexImage renderedImage = renderLatexImage(latex, baseFontSize);
+        if (renderedImage.image == null) {
+            return;
+        }
+
+        byte[] imageBytes = renderedImage.imageBytes;
+        BufferedImage image = renderedImage.image;
+        double scale = Math.min(
+                1.0,
+                Math.min(
+                        (double) availableWidthPx / Math.max(1, image.getWidth()),
+                        (double) availableHeightPx / Math.max(1, image.getHeight())
+                )
+        );
+        if (maxScale != null) {
+            scale = Math.min(scale, maxScale);
+        }
+        int scaledWidthPx = Math.max(1, (int) Math.round(image.getWidth() * scale));
+        int scaledHeightPx = Math.max(1, (int) Math.round(image.getHeight() * scale));
+
+        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 calculateContractBestFontSizeForRegion(Sheet sheet, String latex,
+                                                              int rowIndex, int colIndex, int rowRange, int colRange,
+                                                              int preferredFontSize) 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 = 3;
+        int paddingYPx = 1;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        return renderBestFitLatexFontSize(latex, preferredFontSize, availableWidthPx, availableHeightPx);
+    }
+
+    private static double calculateContractFitScaleForRegion(Sheet sheet, String latex,
+                                                             int rowIndex, int colIndex, int rowRange, int colRange,
+                                                             int fontSize) 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 = 6;
+        int paddingYPx = 4;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        RenderedLatexImage renderedImage = renderLatexImage(latex, fontSize);
+        if (renderedImage.image == null) {
+            return 1.0;
+        }
+
+        return Math.min(
+                1.0,
+                Math.min(
+                        (double) availableWidthPx / Math.max(1, renderedImage.image.getWidth()),
+                        (double) availableHeightPx / Math.max(1, renderedImage.image.getHeight())
+                )
+        );
+    }
+
     private static int getColumnWidthPx(Sheet sheet, int colIndex) {
     private static int getColumnWidthPx(Sheet sheet, int colIndex) {
         int widthUnits = sheet.getColumnWidth(colIndex);
         int widthUnits = sheet.getColumnWidth(colIndex);
         return Math.max(1, (int) Math.round(widthUnits / 256.0 * 7.0 + 5));
         return Math.max(1, (int) Math.round(widthUnits / 256.0 * 7.0 + 5));
@@ -428,6 +715,155 @@ public class LatexFormulaExcelExporterUtil {
         return Math.max(1, (int) Math.round(points * 96.0 / 72.0));
         return Math.max(1, (int) Math.round(points * 96.0 / 72.0));
     }
     }
 
 
+    private static int renderBestFitLatexFontSize(String latex, int preferredFontSize,
+                                                  int targetWidthPx, 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;
+        int bestFontSize = minFontSize;
+
+        while (left <= right) {
+            int mid = (left + right) >>> 1;
+            RenderedLatexImage candidate = renderLatexImage(latex, mid);
+            if (fitsWithin(candidate, targetWidthPx, targetHeightPx)) {
+                bestFontSize = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return bestFontSize;
+    }
+
+    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 boolean fitsWithin(RenderedLatexImage renderedImage, int targetWidthPx, int targetHeightPx) {
+        return renderedImage != null
+                && renderedImage.image != null
+                && renderedImage.image.getWidth() <= targetWidthPx
+                && renderedImage.image.getHeight() <= targetHeightPx;
+    }
+
+    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 {
     private static class AnchorCoord {
         final int index;
         final int index;
         final int offsetPx;
         final int offsetPx;