第2210篇：文档翻译的多模态挑战——排版保留的AI翻译系统
2026/4/30大约 8 分钟
第2210篇：文档翻译的多模态挑战——排版保留的AI翻译系统
适读人群：需要做文档智能翻译的Java工程师 | 阅读时长：约15分钟 | 核心价值：保留原文排版格式的文档翻译工程实现，解决翻译后格式丢失的工程难题
做翻译这件事，大家都知道LLM翻译质量很好了。但有一个场景让很多工程师头疼：翻译完了，格式全乱了。
一份精心排版的英文技术报告，翻译成中文后，原来的表格变成了文字堆，图注和图片脱节，页眉页脚丢失，章节编号错乱。最后翻译出来的中文版，内容是对的，但不能用，因为排版已经面目全非。
这就是"排版保留的文档翻译"问题。它难在：翻译不只是文字替换，还要理解文档的结构（哪些是正文、哪些是标题、哪些是表格），并且翻译完之后维持这个结构。
多模态AI在这里能帮上大忙：视觉理解+文字理解，同时感知文档的视觉结构和文字内容。
一、文档翻译的核心挑战分解
文档翻译面临的挑战：
1. 格式保留
- Word文档：段落样式、字体、表格、图片位置
- PDF文档：页面布局、文本块位置、图表关系
- 图片文档（扫描件）：完全依赖VLM理解布局
2. 上下文连贯性
- 跨段落的代词指代
- 跨页的列表和表格
- 专业术语一致性（文档前后统一）
3. 特殊元素处理
- 代码块（不翻译，保留原文）
- 公式（不翻译，但可能需要调整排版）
- 图例、图注（需要翻译，但要和图保持关联）
- 页眉页脚（通常需要翻译）二、Word文档的保留排版翻译
Word文档有明确的DOM结构（段落、样式、表格），可以精确操作：
@Service
public class WordDocumentTranslator {
private final TranslationService translationService;
private final TerminologyManager terminologyManager;
/**
* 翻译Word文档，保留所有格式
*/
public byte[] translateDocx(byte[] docxBytes, String sourceLanguage,
String targetLanguage) throws IOException {
// 使用Apache POI处理DOCX
try (XWPFDocument document = new XWPFDocument(
new ByteArrayInputStream(docxBytes))) {
// 建立术语表（保证全文术语一致性）
TerminologyTable terminology = buildTerminologyTable(document, sourceLanguage);
// 翻译所有文本内容
translateParagraphs(document.getParagraphs(), sourceLanguage,
targetLanguage, terminology);
// 翻译表格
translateTables(document.getTables(), sourceLanguage,
targetLanguage, terminology);
// 翻译页眉页脚
translateHeadersFooters(document, sourceLanguage, targetLanguage, terminology);
// 输出到字节数组
ByteArrayOutputStream bos = new ByteArrayOutputStream();
document.write(bos);
return bos.toByteArray();
}
}
private void translateParagraphs(List<XWPFParagraph> paragraphs,
String sourceLang, String targetLang,
TerminologyTable terminology) {
for (XWPFParagraph para : paragraphs) {
if (para.getText().trim().isEmpty()) continue;
// 检查是否需要翻译（代码块不翻译）
String styleId = para.getStyleID();
if (isCodeStyle(styleId)) continue;
// 逐个Run翻译（保留格式：粗体、斜体、字体大小等）
translateRuns(para.getRuns(), sourceLang, targetLang, terminology);
}
}
private void translateRuns(List<XWPFRun> runs, String sourceLang,
String targetLang, TerminologyTable terminology) {
if (runs.isEmpty()) return;
// 收集整个段落的文字（而不是逐Run翻译，保证翻译质量）
StringBuilder fullText = new StringBuilder();
List<int[]> runRanges = new ArrayList<>(); // 每个Run在全文中的起止位置
int pos = 0;
for (XWPFRun run : runs) {
String text = run.getText(0);
if (text == null) text = "";
runRanges.add(new int[]{pos, pos + text.length()});
fullText.append(text);
pos += text.length();
}
if (fullText.toString().trim().isEmpty()) return;
// 整段翻译
String translatedText = translationService.translate(
fullText.toString(), sourceLang, targetLang, terminology);
// 最简单策略：把翻译结果按比例分配回各Run
// 注意：这是一个近似，无法完全精确地把翻译文字对应回原来的Run分布
distributeTranslatedTextToRuns(runs, translatedText);
}
/**
* 把翻译后的文本分配回Run列表
* 策略：按字符比例分配，保留Run的格式属性
*/
private void distributeTranslatedTextToRuns(List<XWPFRun> runs, String translatedText) {
if (runs.isEmpty() || translatedText.isEmpty()) return;
// 简单策略：把所有格式放到第一个Run，清空其他Run
// 更复杂的策略可以按词语分割，但实现复杂
String originalFirstRunText = runs.get(0).getText(0);
// 计算原文总长度
int totalOriginalLength = runs.stream()
.mapToInt(r -> r.getText(0) == null ? 0 : r.getText(0).length())
.sum();
if (totalOriginalLength == 0) return;
// 按比例分配翻译文本到各Run
int translatedPos = 0;
for (int i = 0; i < runs.size(); i++) {
XWPFRun run = runs.get(i);
String runText = run.getText(0);
int runLength = runText == null ? 0 : runText.length();
if (i == runs.size() - 1) {
// 最后一个Run得到剩余的所有翻译文本
run.setText(translatedText.substring(translatedPos), 0);
} else {
int translatedLength = (int) Math.ceil(
(double) runLength / totalOriginalLength * translatedText.length());
translatedLength = Math.min(translatedLength,
translatedText.length() - translatedPos);
run.setText(translatedText.substring(translatedPos,
translatedPos + translatedLength), 0);
translatedPos += translatedLength;
}
}
}
private void translateTables(List<XWPFTable> tables, String sourceLang,
String targetLang, TerminologyTable terminology) {
for (XWPFTable table : tables) {
for (XWPFTableRow row : table.getRows()) {
for (XWPFTableCell cell : row.getTableCells()) {
translateParagraphs(cell.getParagraphs(), sourceLang,
targetLang, terminology);
}
}
}
}
private void translateHeadersFooters(XWPFDocument doc, String sourceLang,
String targetLang, TerminologyTable terminology) {
// 遍历所有section的页眉页脚
doc.getHeaderList().forEach(header ->
translateParagraphs(header.getParagraphs(), sourceLang, targetLang, terminology));
doc.getFooterList().forEach(footer ->
translateParagraphs(footer.getParagraphs(), sourceLang, targetLang, terminology));
}
private boolean isCodeStyle(String styleId) {
return styleId != null && (styleId.contains("Code") || styleId.contains("code")
|| styleId.contains("Verbatim"));
}
private TerminologyTable buildTerminologyTable(XWPFDocument doc, String sourceLang) {
// 提取文档中的专业术语，建立统一翻译表
// 省略具体实现
return new TerminologyTable();
}
}三、图片/PDF文档的排版保留翻译
对于图片格式的文档，需要先理解布局，再覆盖翻译：
@Service
public class ImageDocumentTranslator {
private final VisionService visionService;
private final PaddleOCRClient ocrClient;
/**
* 翻译图片文档，保留原有版式
* 策略：识别文字区域 -> 翻译 -> 在原图上覆盖翻译文字
*/
public byte[] translateImageDocument(byte[] imageBytes, String sourceLanguage,
String targetLanguage) throws IOException {
// 1. 用VLM理解文档版式
DocumentLayout layout = analyzeDocumentLayout(imageBytes);
// 2. 对每个文字区域，用OCR识别并翻译
Mat image = Imgcodecs.imdecode(new MatOfByte(imageBytes), Imgcodecs.IMREAD_COLOR);
for (TextRegion region : layout.textRegions()) {
// 裁剪区域
Mat regionImage = cropRegion(image, region.boundingBox());
byte[] regionBytes = matToBytes(regionImage);
// OCR识别原文
String originalText = ocrClient.recognize(regionBytes).toPlainText();
if (originalText.trim().isEmpty()) continue;
// 翻译
String translatedText = translate(originalText, sourceLanguage, targetLanguage);
// 在原图上覆盖翻译文字
overlayTranslatedText(image, region, translatedText);
}
return matToBytes(image);
}
/**
* 用VLM分析文档版式，识别各文字区域的位置和类型
*/
private DocumentLayout analyzeDocumentLayout(byte[] imageBytes) {
VisionRequest request = VisionRequest.builder()
.images(List.of(ImageInput.fromBytes(imageBytes, "image/jpeg")))
.prompt("""
请分析这张文档图片的版式，识别所有文字区域。
返回每个文字区域的类型和相对位置（百分比，0-100）：
[
{
"type": "title/heading/body/caption/header/footer/table_cell",
"x1": 左边界百分比,
"y1": 上边界百分比,
"x2": 右边界百分比,
"y2": 下边界百分比,
"fontSize": "small/medium/large"
}
]
只返回JSON数组。
""")
.metadata(Map.of("detail", "high"))
.build();
String response = visionService.analyzeImage(request).getContent();
return parseDocumentLayout(response);
}
/**
* 在图片指定区域覆盖翻译文字
*/
private void overlayTranslatedText(Mat image, TextRegion region, String text) {
// 获取区域的实际像素坐标
int x1 = (int)(region.boundingBox().x1Pct() / 100 * image.cols());
int y1 = (int)(region.boundingBox().y1Pct() / 100 * image.rows());
int x2 = (int)(region.boundingBox().x2Pct() / 100 * image.cols());
int y2 = (int)(region.boundingBox().y2Pct() / 100 * image.rows());
// 用白色矩形覆盖原文字区域
Imgproc.rectangle(image, new Point(x1, y1), new Point(x2, y2),
new Scalar(255, 255, 255), -1);
// 在覆盖区域上写入翻译文字
// 注意：OpenCV的putText不支持中文，需要用Java的Graphics2D来写中文
writeChineseText(image, text, x1, y1, x2 - x1, y2 - y1);
}
/**
* 使用Java Graphics2D在OpenCV Mat上写入中文文字
*/
private void writeChineseText(Mat mat, String text, int x, int y, int width, int height) {
// 把Mat转为BufferedImage
BufferedImage bufferedImage = matToBufferedImage(mat);
Graphics2D g2d = bufferedImage.createGraphics();
// 设置字体（根据区域高度自适应字体大小）
int fontSize = Math.max(10, (int)(height * 0.7));
Font font = new Font("微软雅黑", Font.PLAIN, fontSize);
g2d.setFont(font);
g2d.setColor(Color.BLACK);
// 自动换行绘制文字
FontMetrics fm = g2d.getFontMetrics();
drawWrappedText(g2d, text, x + 2, y + fm.getAscent() + 2, width - 4, fm);
g2d.dispose();
// 把BufferedImage写回Mat
bufferedImageToMat(bufferedImage, mat);
}
private void drawWrappedText(Graphics2D g2d, String text, int x, int y,
int maxWidth, FontMetrics fm) {
String[] words = text.split(""); // 中文按字符分割
StringBuilder line = new StringBuilder();
int currentY = y;
for (String word : words) {
String testLine = line.toString() + word;
if (fm.stringWidth(testLine) <= maxWidth) {
line.append(word);
} else {
g2d.drawString(line.toString(), x, currentY);
currentY += fm.getHeight();
line = new StringBuilder(word);
}
}
if (!line.isEmpty()) {
g2d.drawString(line.toString(), x, currentY);
}
}
private DocumentLayout parseDocumentLayout(String response) {
// 解析VLM返回的版式JSON
return new DocumentLayout(List.of()); // 省略具体解析
}
private Mat cropRegion(Mat image, BoundingBox box) {
int x1 = (int)(box.x1Pct() / 100 * image.cols());
int y1 = (int)(box.y1Pct() / 100 * image.rows());
int x2 = (int)(box.x2Pct() / 100 * image.cols());
int y2 = (int)(box.y2Pct() / 100 * image.rows());
return new Mat(image, new Rect(x1, y1, x2 - x1, y2 - y1));
}
private String translate(String text, String sourceLang, String targetLang) {
// 调用翻译服务，省略具体实现
return text;
}
private byte[] matToBytes(Mat mat) {
MatOfByte mob = new MatOfByte();
Imgcodecs.imencode(".jpg", mat, mob);
return mob.toArray();
}
private BufferedImage matToBufferedImage(Mat mat) {
// Mat转BufferedImage，省略具体实现
return null;
}
private void bufferedImageToMat(BufferedImage image, Mat mat) {
// BufferedImage写回Mat，省略具体实现
}
public record DocumentLayout(List<TextRegion> textRegions) {}
public record TextRegion(String type, BoundingBox boundingBox, String fontSize) {}
public record BoundingBox(double x1Pct, double y1Pct, double x2Pct, double y2Pct) {}
}四、术语一致性管理
长文档翻译的质量杀手之一是术语不一致：
@Service
public class TranslationService {
private final ChatClient chatClient;
/**
* 带术语表的翻译
*/
public String translate(String text, String sourceLang, String targetLang,
TerminologyTable terminology) {
String terminologyHint = terminology.isEmpty() ? "" :
"\n以下术语必须使用固定翻译：\n" + terminology.toPromptFormat();
String prompt = String.format("""
请将以下%s文本翻译为%s，保持原文的语气和风格。
%s
原文：
%s
只返回翻译结果，不要有任何解释。
""", sourceLang, targetLang, terminologyHint, text);
return chatClient.prompt()
.user(prompt)
.options(OpenAiChatOptions.builder()
.withTemperature(0.1f) // 翻译任务用低temperature
.build())
.call()
.content();
}
}五、翻译质量的工程控制
排版保留翻译的质量有两个维度：翻译质量（文字）和排版质量（格式）。两者都需要评估：
@Service
public class TranslationQualityEvaluator {
/**
* 自动质量评估（用LLM评价翻译质量）
*/
public QualityScore evaluateTranslation(String originalText, String translatedText,
String targetLanguage) {
String evalPrompt = String.format("""
请评估以下翻译的质量（打分1-5分）：
原文：%s
译文：%s
评分维度：
1. 准确性（1-5）：翻译内容是否准确？
2. 流畅性（1-5）：译文是否自然流畅？
3. 术语一致性（1-5）：专业术语是否统一？
返回JSON：{"accuracy": 分, "fluency": 分, "terminology": 分, "overall": 分}
只返回JSON。
""", originalText.substring(0, Math.min(500, originalText.length())),
translatedText.substring(0, Math.min(500, translatedText.length())));
String response = chatClient.prompt().user(evalPrompt).call().content();
// 解析JSON并返回
return new QualityScore(4, 4, 4, 4); // 简化
}
public record QualityScore(int accuracy, int fluency, int terminology, int overall) {}
}文档翻译是一个在工程实现上比想象中复杂得多的问题。排版保留要求我们不只是处理文字，还要处理格式、版式、字体——这是多模态AI真正发挥价值的场景。