feat(文件归并): 归并PDF适配与解析逻辑

2026-10-29 13:56:32 +08:00 · 2026-10-14 09:22:47 +08:00
1 parent b3c4bbc844
commit 961bc52038
@@ -21,12 +21,20 @@ import (
 	"fmt"
 	"image/color"
 	"math"
+	"reflect"
+	"strconv"

 	basegeom "github.com/xiaoqidun/ofdgo/internal/base/geom"
 	codecpdf "github.com/xiaoqidun/ofdgo/internal/codec/pdf"
 	"github.com/xiaoqidun/pdfgo"
 )

+// pdfPointBounds 逐点汇总边界，不保留文字或路径的临时坐标数组
+type pdfPointBounds struct {
+	minX, minY, maxX, maxY float64
+	found                  bool
+}
+
 // pdfGeometryPath 转换PDF路径并衔接OFD几何类型
 // 入参: ctx 取消上下文, source PDF路径, matrix 坐标变换
 // 返回: GeometryPath 独立几何路径, error 指令、坐标或取消错误
@@ -203,3 +211,278 @@ func (p *pdfImporter) coverageClip(paths []pdfgo.Path, geometry GeometryBackend)
 	}
 	return clip, nil
 }
+
+// pdfGlyphPath 将OFD字形几何交给PDF路径适配器转换
+// 入参: outline 字形轮廓, matrix 字形到页面的变换
+// 返回: pdfgo.Path 页面路径, error 非字体轮廓指令
+func pdfGlyphPath(outline GeometryPath, matrix pdfgo.Matrix) (pdfgo.Path, error) {
+	return codecpdf.GlyphPath(basegeom.Path(outline), matrix)
+}
+
+// pdfNumbers 按OFD数值格式序列化坐标
+// 入参: values 数值列表
+// 返回: string 空格分隔的数值
+func pdfNumbers(values ...float64) string {
+	var buffer [128]byte
+	data := buffer[:0]
+	for n, v := range values {
+		if n != 0 {
+			data = append(data, ' ')
+		}
+		data = strconv.AppendFloat(data, v, 'g', -1, 64)
+	}
+	return string(data)
+}
+
+// pdfDashPattern 换算PDF虚线长度，将单值数组展开为等长线段与间隔
+// 入参: dash PDF虚线数组, scale 坐标缩放比例
+// 返回: string OFD虚线数组
+func pdfDashPattern(dash []float64, scale float64) string {
+	if len(dash) == 0 {
+		return ""
+	}
+	values := make([]float64, max(2, len(dash)))
+	for i, value := range dash {
+		values[i] = value * scale
+	}
+	if len(dash) == 1 {
+		values[1] = values[0]
+	}
+	return pdfNumbers(values...)
+}
+
+// pdfBoundary 序列化对象边界
+// 入参: b 对象边界
+// 返回: string OFD边界数据
+func pdfBoundary(b Box) string { return pdfNumbers(b.X, b.Y, b.W, b.H) }
+
+// pdfBounds 计算点集合的包围框
+// 入参: points 坐标点集合
+// 返回: Box 包围框
+func pdfBounds(points []pdfgo.Point) Box {
+	var bounds pdfPointBounds
+	for _, point := range points {
+		bounds.add(point)
+	}
+	return bounds.box()
+}
+
+// add 按原顺序累计一个控制点的最小和最大坐标
+// 入参: point 坐标点
+func (b *pdfPointBounds) add(point pdfgo.Point) {
+	if !b.found {
+		b.minX, b.minY, b.maxX, b.maxY = point.X, point.Y, point.X, point.Y
+		b.found = true
+	}
+	b.minX, b.minY = math.Min(b.minX, point.X), math.Min(b.minY, point.Y)
+	b.maxX, b.maxY = math.Max(b.maxX, point.X), math.Max(b.maxY, point.Y)
+}
+
+// box 取得原精度边界，空集合仍返回零值
+// 返回: Box 坐标范围
+func (b *pdfPointBounds) box() Box {
+	if !b.found {
+		return Box{}
+	}
+	return Box{X: b.minX, Y: b.minY, W: math.Max(b.maxX-b.minX, 1e-6), H: math.Max(b.maxY-b.minY, 1e-6)}
+}
+
+// pathBoundsContext 逐段计算变换后的控制点边界，不创建临时点集合
+// 入参: ctx 取消上下文, path PDF路径
+// 返回: Box 控制点边界，空路径返回零值, error 取消错误
+func (p *pdfImporter) pathBoundsContext(ctx context.Context, path pdfgo.Path) (Box, error) {
+	if err := ctx.Err(); err != nil {
+		return Box{}, err
+	}
+	minX, minY, maxX, maxY := math.Inf(1), math.Inf(1), math.Inf(-1), math.Inf(-1)
+	found := false
+	for _, segment := range path.Segments {
+		if err := ctx.Err(); err != nil {
+			return Box{}, err
+		}
+		for index, point := range segment.Points {
+			if index&255 == 0 {
+				if err := ctx.Err(); err != nil {
+					return Box{}, err
+				}
+			}
+			point = p.matrix.Apply(point)
+			minX, minY = math.Min(minX, point.X), math.Min(minY, point.Y)
+			maxX, maxY = math.Max(maxX, point.X), math.Max(maxY, point.Y)
+			found = true
+		}
+	}
+	if err := ctx.Err(); err != nil {
+		return Box{}, err
+	}
+	if !found {
+		return Box{}, nil
+	}
+	return Box{X: minX, Y: minY, W: math.Max(maxX-minX, 1e-6), H: math.Max(maxY-minY, 1e-6)}, nil
+}
+
+// pathDataContext 转换路径并在分段处理时检查取消
+// 入参: ctx 取消上下文, path PDF路径, origin 对象边界
+// 返回: string OFD路径数据, error 取消错误
+func (p *pdfImporter) pathDataContext(ctx context.Context, path pdfgo.Path, origin Box) (string, error) {
+	if err := ctx.Err(); err != nil {
+		return "", err
+	}
+	data := make([]byte, 0, len(path.Segments)*48)
+	for index, segment := range path.Segments {
+		if err := ctx.Err(); err != nil {
+			return "", err
+		}
+		if index != 0 {
+			data = append(data, ' ')
+		}
+		data = append(data, segment.Operator...)
+		for _, point := range segment.Points {
+			point = p.matrix.Apply(point)
+			data = append(data, ' ')
+			data = strconv.AppendFloat(data, point.X-origin.X, 'g', -1, 64)
+			data = append(data, ' ')
+			data = strconv.AppendFloat(data, point.Y-origin.Y, 'g', -1, 64)
+		}
+	}
+	if err := ctx.Err(); err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// path 合并相同状态下的不透明描边，保留独立子路径与绘制顺序
+// 入参: mark PDF路径绘制信息
+// 返回: error 错误信息
+func (p *pdfImporter) path(mark pdfgo.PathMark) error {
+	if mark.Style.BlendMode != "" && mark.Style.BlendMode != "Normal" && mark.Style.BlendMode != "Compatible" {
+		return &pdfgo.UnsupportedError{Feature: "path blend mode " + string(mark.Style.BlendMode)}
+	}
+	if !mark.Stroke || mark.Fill || mark.Style.Stroke.Alpha != 1 {
+		if err := p.flushPath(); err != nil {
+			return err
+		}
+		return p.appendPath(mark)
+	}
+	if p.pendingPath != nil && (p.pendingPath.StrokeMatrix != mark.StrokeMatrix || !reflect.DeepEqual(p.pendingPath.Style, mark.Style)) {
+		if err := p.flushPath(); err != nil {
+			return err
+		}
+	}
+	if p.pendingPath == nil {
+		p.pendingPath = &mark
+	} else {
+		p.pendingPath.Path.Segments = append(p.pendingPath.Path.Segments, mark.Path.Segments...)
+	}
+	if len(p.pendingPath.Path.Segments) >= 512 {
+		return p.flushPath()
+	}
+	return nil
+}
+
+// flushPath 写入连续描边批次，保持后续图元的叠放位置
+// 返回: error 转换错误
+func (p *pdfImporter) flushPath() error {
+	if p.pendingPath == nil {
+		return nil
+	}
+	mark := *p.pendingPath
+	p.pendingPath = nil
+	return p.appendPath(mark)
+}
+
+// appendPath 添加独立可编辑路径
+// 入参: mark PDF路径绘制信息
+// 返回: error 错误信息
+func (p *pdfImporter) appendPath(mark pdfgo.PathMark) error {
+	var err error
+	mark.Style, err = p.maskStyle(mark.Style)
+	if err != nil {
+		if p.rasterMaskAllowed(err) {
+			mask := mark.Style.SoftMask
+			mark.Style.SoftMask = nil
+			return p.rasterGroup(pdfgo.GroupMark{Alpha: 1, SoftMask: mask}, func(v pdfgo.Visitor) error { return v.Path(mark) })
+		}
+		return err
+	}
+	if mark.Fill && mark.Style.FillOverprint && pdfOverprintNeedsSeparation(mark.Style.Fill) || mark.Stroke && mark.Style.StrokeOverprint && pdfOverprintNeedsSeparation(mark.Style.Stroke) {
+		return &pdfgo.UnsupportedError{Feature: "color separation overprint"}
+	}
+	if p.warning != nil && (mark.Fill && p.gradientError(mark.Style.Fill) != nil || mark.Stroke && p.gradientError(mark.Style.Stroke) != nil) {
+		if err := p.ctx.Err(); err != nil {
+			return err
+		}
+		return p.gradientPath(mark)
+	}
+	box, err := p.pathBoundsContext(p.ctx, mark.Path)
+	if err != nil {
+		return err
+	}
+	if box == (Box{}) {
+		return fmt.Errorf("empty PDF painted path")
+	}
+	scale := math.Hypot(p.matrix[0], p.matrix[1])
+	drawing, origin, ctm := *p, box, ""
+	marginScale := scale
+	if mark.StrokeMatrix != (pdfgo.Matrix{}) {
+		inverse, ok := mark.StrokeMatrix.Inverse()
+		if !ok {
+			return fmt.Errorf("invalid PDF stroke matrix")
+		}
+		drawing.matrix, origin, scale = inverse, Box{}, 1
+		m := p.matrix.Mul(mark.StrokeMatrix)
+		marginScale = math.Max(math.Hypot(m[0], m[2]), math.Hypot(m[1], m[3]))
+	}
+	if mark.Stroke {
+		margin := mark.Style.LineWidth * marginScale / 2 * math.Max(1, mark.Style.MiterLimit)
+		box = Box{X: box.X - margin, Y: box.Y - margin, W: box.W + 2*margin, H: box.H + 2*margin}
+	}
+	if mark.StrokeMatrix == (pdfgo.Matrix{}) {
+		origin = box
+	} else {
+		m := p.matrix.Mul(mark.StrokeMatrix)
+		m[4], m[5] = m[4]-box.X, m[5]-box.Y
+		ctm = pdfNumbers(m[:]...)
+	}
+	paint := func(value pdfgo.Paint) (*FillColor, error) {
+		if value.Tiling != nil || pdfGradientPattern(value) {
+			return p.paintColor(value, box)
+		}
+		return drawing.paintColor(value, origin)
+	}
+	fillColor, strokePaint := p.color(mark.Style.Fill), p.color(mark.Style.Stroke)
+	if mark.Fill {
+		fillColor, err = paint(mark.Style.Fill)
+		if err != nil {
+			return err
+		}
+	}
+	if mark.Stroke {
+		strokePaint, err = paint(mark.Style.Stroke)
+		if err != nil {
+			return err
+		}
+	}
+	strokeColor := StrokeColor(*strokePaint)
+	clips, err := p.clips(mark.Style.Clips, box)
+	if err != nil {
+		return err
+	}
+	data, err := drawing.pathDataContext(p.ctx, mark.Path, origin)
+	if err != nil {
+		return err
+	}
+	object := PathObject{Boundary: pdfBoundary(box), CTM: ctm, AbbreviatedData: data, Fill: &mark.Fill, Stroke: &mark.Stroke, FillColor: fillColor, StrokeColor: &strokeColor, LineWidth: mark.Style.LineWidth * scale, Cap: []string{"Butt", "Round", "Square"}[mark.Style.Cap], Join: []string{"Miter", "Round", "Bevel"}[mark.Style.Join], MiterLimit: mark.Style.MiterLimit, Clips: clips}
+	object.LineWidthSet = object.LineWidth == 0
+	if mark.Path.EvenOdd {
+		object.Rule = "Even-Odd"
+	}
+	if len(mark.Style.Dash) > 0 {
+		object.DashPattern = pdfDashPattern(mark.Style.Dash, scale)
+		phase := mark.Style.DashPhase * scale
+		object.DashOffset = &phase
+	}
+	p.appendObject(GraphicObject{Type: "PathObject", PathObject: object})
+	p.report.PathObjects++
+	return nil
+}