mirror of
https://github.com/xiaoqidun/ofdgo.git
synced 2026-10-29 08:46:55 +08:00
This commit is contained in:
xiaoqidun committed
1 parent
b4d566019d
commit
201082daa0
9 files changed
+434
-16
No files matched your search
@@ -11,7 +11,7 @@ require (
|
||||
github.com/xiaoqidun/guigo v0.0.0-20261020075840-622fd8853d72
|
||||
github.com/xiaoqidun/j2kgo v1.0.2
|
||||
github.com/xiaoqidun/jbig2 v1.1.8
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021023132-6452ac6abaef
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021045903-4d52abc4d1c4
|
||||
golang.org/x/crypto v0.58.0
|
||||
golang.org/x/image v0.47.0
|
||||
golang.org/x/text v0.43.0
|
||||
|
||||
@@ -66,8 +66,8 @@ github.com/xiaoqidun/j2kgo v1.0.2 h1:OAjjEOfaBaQzBNcj9wx+eM68UI5pewR6SzNZa1R1DIw
|
||||
github.com/xiaoqidun/j2kgo v1.0.2/go.mod h1:DCwAfuDzCDYqUiAlZ7BDwigTjaXw7o9L1FtEma/D1aA=
|
||||
github.com/xiaoqidun/jbig2 v1.1.8 h1:dERPW7F8gs18a/DOD9gXHR3fP1Vl6KhCNsLnq5l3BIo=
|
||||
github.com/xiaoqidun/jbig2 v1.1.8/go.mod h1:9jromqVwMqlptUDEt6Yip8vqYA5I1YjhG7FgMl/Z2dA=
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021023132-6452ac6abaef h1:q0QmZrpkiTtTtNghOY7t+G30YrYu7V3/FgOi14NbdGc=
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021023132-6452ac6abaef/go.mod h1:AaabzsObZ8Z76AcaWbo6swRROrJsblyIGB7HbieeJA4=
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021045903-4d52abc4d1c4 h1:RXZ4mH75yoSxdNuXdgvRsoz6DHJGYz71+r1A14qLoj8=
|
||||
github.com/xiaoqidun/pdfgo v0.0.0-20261021045903-4d52abc4d1c4/go.mod h1:AaabzsObZ8Z76AcaWbo6swRROrJsblyIGB7HbieeJA4=
|
||||
github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
|
||||
github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
|
||||
github.com/yuin/goldmark v1.8.5 h1:r6N5afV5qj/5S4UTch8agZHJ8UxNCMwX7WjkkJam2NA=
|
||||
|
||||
@@ -198,6 +198,9 @@ func ParseType1Program(data []byte) (Type1Program, error) {
|
||||
return Type1Program{}, fmt.Errorf("Type1 font has no glyphs")
|
||||
}
|
||||
for index := range program.subrs {
|
||||
if program.subrs[index] == nil {
|
||||
continue
|
||||
}
|
||||
program.subrs[index], err = type1CharString(program.subrs[index], program.lenIV)
|
||||
if err != nil {
|
||||
return Type1Program{}, err
|
||||
@@ -212,6 +215,61 @@ func ParseType1Program(data []byte) (Type1Program, error) {
|
||||
return program, nil
|
||||
}
|
||||
|
||||
// NormalizePDFType1 修复完整加密分段之后的PFB明文尾部，不补齐加密或字形数据
|
||||
// 入参: data 原始PFB程序
|
||||
// 返回: []byte 原程序或独立修复容器, bool 是否修复, error 容器或程序错误
|
||||
func NormalizePDFType1(data []byte) ([]byte, bool, error) {
|
||||
if len(data) < 6 || data[0] != 0x80 {
|
||||
return data, false, nil
|
||||
}
|
||||
binarySeen := false
|
||||
for offset := 0; offset+2 <= len(data) && data[offset] == 0x80; {
|
||||
kind := data[offset+1]
|
||||
if kind == 3 {
|
||||
return data, false, nil
|
||||
}
|
||||
if offset+6 > len(data) || kind != 1 && kind != 2 {
|
||||
return data, false, fmt.Errorf("incomplete PFB segment header")
|
||||
}
|
||||
length := uint64(binary.LittleEndian.Uint32(data[offset+2:]))
|
||||
remaining := len(data) - offset - 6
|
||||
if binarySeen && kind == 1 && remaining == 0 {
|
||||
result := append(bytes.Clone(data[:offset]), 0x80, 3)
|
||||
if _, err := ParseType1Program(result); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
return result, true, nil
|
||||
}
|
||||
if length > uint64(remaining) {
|
||||
return nil, false, fmt.Errorf("incomplete PFB encrypted or text segment")
|
||||
}
|
||||
if binarySeen && kind == 1 && length == 0 {
|
||||
tail := data[offset+6:]
|
||||
if len(tail) < 2 || !bytes.Equal(tail[len(tail)-2:], []byte{0x80, 3}) {
|
||||
return data, false, fmt.Errorf("unbounded PFB text trailer")
|
||||
}
|
||||
text := bytes.TrimSpace(tail[:len(tail)-2])
|
||||
if !bytes.HasSuffix(text, []byte("cleartomark")) {
|
||||
return data, false, fmt.Errorf("PFB trailer lacks cleartomark")
|
||||
}
|
||||
for _, b := range bytes.TrimSuffix(text, []byte("cleartomark")) {
|
||||
if b != '0' && !type1Space(b) {
|
||||
return data, false, fmt.Errorf("unexpected PFB text trailer")
|
||||
}
|
||||
}
|
||||
result := bytes.Clone(data)
|
||||
binary.LittleEndian.PutUint32(result[offset+2:], uint32(len(tail)-2))
|
||||
if _, err := ParseType1Program(result); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
return result, true, nil
|
||||
}
|
||||
binarySeen = binarySeen || kind == 2
|
||||
offset += 6 + int(length)
|
||||
}
|
||||
return data, false, nil
|
||||
}
|
||||
|
||||
// readType1Header 读取明文字体矩阵及加密数据起点
|
||||
// 入参: data Type1程序
|
||||
// 返回: []float64 字体矩阵, int 加密起点, error 头部错误
|
||||
|
||||
@@ -87,6 +87,108 @@ func FileTables(data []byte, index int) (map[string][]byte, error) {
|
||||
return tables, nil
|
||||
}
|
||||
|
||||
// NormalizePDFProgram 修复可确定的PDF内嵌SFNT封装，不补造TrueType轮廓或字形编号
|
||||
// 入参: data 原始字体程序
|
||||
// 返回: []byte 原程序或独立修复程序, bool 是否修复, error 无法确认的目录或度量错误
|
||||
func NormalizePDFProgram(data []byte) ([]byte, bool, error) {
|
||||
if len(data) < 12 || string(data[:4]) != "OTTO" && string(data[:4]) != "\x00\x01\x00\x00" && string(data[:4]) != "true" {
|
||||
return data, false, nil
|
||||
}
|
||||
count := int(binary.BigEndian.Uint16(data[4:6]))
|
||||
if count == 0 || count > (len(data)-12)/16 {
|
||||
return nil, false, fmt.Errorf("unrecoverable PDF font directory size")
|
||||
}
|
||||
first := len(data)
|
||||
for n := 0; n < count; n++ {
|
||||
record := data[12+n*16:]
|
||||
start, size := uint64(binary.BigEndian.Uint32(record[8:])), uint64(binary.BigEndian.Uint32(record[12:]))
|
||||
if size != 0 && start >= 12 && start+size <= uint64(len(data)) {
|
||||
first = min(first, int(start))
|
||||
}
|
||||
}
|
||||
changed := false
|
||||
if first < 12+count*16 {
|
||||
if (first-12)%16 != 0 {
|
||||
return nil, false, fmt.Errorf("ambiguous PDF font directory overlap")
|
||||
}
|
||||
actual := (first - 12) / 16
|
||||
for n := 0; n < count; n++ {
|
||||
record := data[12+n*16:]
|
||||
printable := true
|
||||
for _, b := range record[:4] {
|
||||
printable = printable && b >= 32 && b <= 126
|
||||
}
|
||||
if printable != (n < actual) {
|
||||
return nil, false, fmt.Errorf("ambiguous PDF font table count")
|
||||
}
|
||||
if n < actual {
|
||||
start, size := uint64(binary.BigEndian.Uint32(record[8:])), uint64(binary.BigEndian.Uint32(record[12:]))
|
||||
if size != 0 && (start < uint64(first) || start+size > uint64(len(data))) {
|
||||
return nil, false, fmt.Errorf("incomplete PDF font table")
|
||||
}
|
||||
}
|
||||
}
|
||||
data = bytes.Clone(data)
|
||||
binary.BigEndian.PutUint16(data[4:6], uint16(actual))
|
||||
changed = true
|
||||
}
|
||||
tables, err := FileTables(data, 0)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
if head := tables["head"]; len(head) > 54 && len(head) <= 57 {
|
||||
tables["head"] = head[:54]
|
||||
changed = true
|
||||
}
|
||||
if hhea := tables["hhea"]; len(hhea) > 36 && len(hhea) <= 39 && binary.BigEndian.Uint32(hhea) == 0x00010000 {
|
||||
tables["hhea"] = hhea[:36]
|
||||
changed = true
|
||||
}
|
||||
if maxp := tables["maxp"]; tables["glyf"] != nil && len(maxp) > 32 && len(maxp) <= 35 && binary.BigEndian.Uint32(maxp) == 0x00010000 {
|
||||
tables["maxp"] = maxp[:32]
|
||||
changed = true
|
||||
}
|
||||
if post := tables["post"]; len(post) > 32 && binary.BigEndian.Uint32(post) == 0x00030000 {
|
||||
tables["post"] = post[:32]
|
||||
changed = true
|
||||
}
|
||||
if cvt := tables["cvt "]; len(cvt)%2 != 0 && cvt[len(cvt)-1] == 0 {
|
||||
tables["cvt "] = cvt[:len(cvt)-1]
|
||||
changed = true
|
||||
}
|
||||
if len(tables["CFF "]) != 0 && len(tables["head"]) == 0 && len(tables["maxp"]) == 0 && len(tables["hhea"]) == 0 && len(tables["hmtx"]) == 0 {
|
||||
program, _, err := WrapCFFToOTF(tables["CFF "])
|
||||
return program, true, err
|
||||
}
|
||||
if maxp := tables["maxp"]; len(tables["CFF "]) != 0 && tables["glyf"] == nil && len(maxp) >= 6 && (binary.BigEndian.Uint32(maxp) == 0x00010000 || binary.BigEndian.Uint32(maxp) == 0x00005000 && len(maxp) != 6) {
|
||||
count, err := parseCFFAndCountGlyphs(tables["CFF "])
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
if count != int(binary.BigEndian.Uint16(maxp[4:6])) {
|
||||
program, _, err := WrapCFFToOTF(tables["CFF "])
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
rebuilt, err := FileTables(program, 0)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
if len(tables["head"]) < 20 || !bytes.Equal(tables["head"][18:20], rebuilt["head"][18:20]) {
|
||||
return nil, false, fmt.Errorf("CFF and SFNT design units differ")
|
||||
}
|
||||
return program, true, nil
|
||||
}
|
||||
tables["maxp"] = buildCFFMaxpTable(uint16(count))
|
||||
changed = true
|
||||
}
|
||||
if !changed {
|
||||
return data, false, nil
|
||||
}
|
||||
program, err := SerializeOTF(tables)
|
||||
return program, true, err
|
||||
}
|
||||
|
||||
// calcTableChecksum 计算字体表校验和
|
||||
// 入参: data 表数据
|
||||
// 返回: uint32 校验和
|
||||
|
||||
+1
-1
@@ -315,7 +315,7 @@ func (p *pdfImporter) destinationBounds(page *pdfgo.Page) (Box, error) {
|
||||
if err := local.commitObjects(); err != nil {
|
||||
return Box{}, err
|
||||
}
|
||||
reader, err := editor.resourceReader()
|
||||
reader, err := local.temporaryReader()
|
||||
if err != nil {
|
||||
return Box{}, err
|
||||
}
|
||||
|
||||
@@ -19,6 +19,7 @@ import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"fmt"
|
||||
"maps"
|
||||
"math"
|
||||
@@ -120,6 +121,52 @@ func (p *pdfImporter) annotationOpen(ctx context.Context, dict pdfgo.Dictionary)
|
||||
// 入参: ctx 取消上下文, page PDF页面, annotation PDF注解, actions 外观区域的动作
|
||||
// 返回: error 外观或转换错误
|
||||
func (p *pdfImporter) appearanceAnnotation(ctx context.Context, page *pdfgo.Page, annotation pdfgo.Annotation, actions ...Action) error {
|
||||
if annotation.Rect.XMin == annotation.Rect.XMax || annotation.Rect.YMin == annotation.Rect.YMax {
|
||||
return p.paintedAnnotation(ctx, page, annotation, nil, actions...)
|
||||
}
|
||||
if !annotation.IsStandard() {
|
||||
flags, err := p.reader.ReadAnnotationFlags(annotation)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if flags&1 != 0 {
|
||||
return p.paintedAnnotation(ctx, page, annotation, nil, actions...)
|
||||
}
|
||||
}
|
||||
if p.warning != nil && annotation.Dictionary["AP"] == nil && annotation.Dictionary["BS"] == nil && annotation.Dictionary["Border"] != nil {
|
||||
border, err := p.reader.Resolve(annotation.Dictionary["Border"])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if array, ok := border.(pdfgo.Array); ok && len(array) == 0 {
|
||||
if err := p.preservePDFObject(ctx, "Annotation.Border", annotation.Dictionary["Border"]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
if annotation.Dictionary["AP"] != nil {
|
||||
if _, err := p.reader.ReadAnnotationAppearance(annotation); err != nil {
|
||||
if !errors.Is(err, pdfgo.ErrInvalidAnnotationAppearance) {
|
||||
return err
|
||||
}
|
||||
if p.warning == nil {
|
||||
return err
|
||||
}
|
||||
if err := p.preservePDFObject(ctx, "Annotation.Appearance", annotation.Dictionary); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
switch annotation.Subtype {
|
||||
case "PrinterMark", "TrapNet", "3D", "RichMedia", "Watermark":
|
||||
appearance, err := p.reader.Resolve(annotation.Dictionary["AP"])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if appearance == nil {
|
||||
return p.recoverPDFObject(ctx, "Annotation.Appearance", annotation.Dictionary, &pdfgo.UnsupportedError{Feature: "annotation without static appearance"})
|
||||
}
|
||||
}
|
||||
return p.paintedAnnotation(ctx, page, annotation, nil, actions...)
|
||||
}
|
||||
|
||||
|
||||
+13
-1
@@ -414,7 +414,7 @@ func (p *pdfImporter) compileGroup(build func(*pdfImporter) error) (*RasterPage,
|
||||
if err := local.commitObjects(); err != nil {
|
||||
return nil, box, err
|
||||
}
|
||||
reader, err := editor.resourceReader()
|
||||
reader, err := local.temporaryReader()
|
||||
if err != nil {
|
||||
return nil, box, err
|
||||
}
|
||||
@@ -435,6 +435,18 @@ func (p *pdfImporter) compileGroup(build func(*pdfImporter) error) (*RasterPage,
|
||||
return p.groupSceneBounds(scene)
|
||||
}
|
||||
|
||||
// temporaryReader 为局部编译准备资源，带有保留信息时使用完整快照
|
||||
// 返回: *Reader 独立阅读器, error 准备或取消错误
|
||||
func (p *pdfImporter) temporaryReader() (*Reader, error) {
|
||||
if err := p.ctx.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if p.editor.source != nil || len(p.editor.origins) != 0 {
|
||||
return p.editor.readerContext(p.ctx, nil)
|
||||
}
|
||||
return p.editor.resourceReader()
|
||||
}
|
||||
|
||||
// groupSceneBounds 计算已编译场景在页面内的像素对齐区域
|
||||
// 入参: scene 中立绘制场景
|
||||
// 返回: *RasterPage 非空场景, Box 页面区域, error 度量错误
|
||||
|
||||
+182
-9
@@ -27,12 +27,13 @@ const pdfPatternCellLimit = 8 << 20
|
||||
|
||||
// pdfPatternCellKey 隔离图案来源、基色、坐标、精度、混合空间与目标文档资源
|
||||
type pdfPatternCellKey struct {
|
||||
source *pdfgo.TilingPattern
|
||||
base pdfgo.Paint
|
||||
matrix pdfgo.Matrix
|
||||
dpi float64
|
||||
editor *Editor
|
||||
space *pdfgo.ColorSpace
|
||||
source *pdfgo.TilingPattern
|
||||
base pdfgo.Paint
|
||||
matrix pdfgo.Matrix
|
||||
dpi float64
|
||||
editor *Editor
|
||||
space *pdfgo.ColorSpace
|
||||
pageWidth, pageHeight float64
|
||||
}
|
||||
|
||||
// pdfPatternCell 保存图案快照及单元内部的来源区段
|
||||
@@ -71,7 +72,7 @@ func (p *pdfImporter) tilingPattern(source *pdfgo.TilingPattern, base pdfgo.Pain
|
||||
if p.patternCells == nil {
|
||||
p.patternCells = resourceCache[pdfPatternCellKey, pdfPatternCell](p.resources, pdfPatternCellLimit)
|
||||
}
|
||||
key := pdfPatternCellKey{source: source, matrix: p.matrix, dpi: p.rasterDPI, editor: p.editor, space: p.compositeSpace}
|
||||
key := pdfPatternCellKey{source: source, matrix: p.matrix, dpi: p.rasterDPI, editor: p.editor, space: p.compositeSpace, pageWidth: p.pageWidth, pageHeight: p.pageHeight}
|
||||
if source.PaintType == 2 {
|
||||
base.Tiling, base.Axial, base.Radial, base.Mesh, base.Function, base.Shading = nil, nil, nil, nil, nil, nil
|
||||
base.Alpha = 1
|
||||
@@ -140,6 +141,146 @@ func pdfPatternCellCost(value reflect.Value, budget, depth int) int {
|
||||
return cost
|
||||
}
|
||||
|
||||
// pdfPatternRectangleBounds 识别无文字裁剪的单个轴对齐矩形，不把边界框当作路径覆盖范围
|
||||
// 入参: path 矩形路径
|
||||
// 返回: pdfgo.Rectangle 精确覆盖范围, bool 是否单矩形
|
||||
func pdfPatternRectangleBounds(path pdfgo.Path) (pdfgo.Rectangle, bool) {
|
||||
if len(path.Text) != 0 || len(path.Segments) != 5 || path.Segments[4].Operator != "C" || len(path.Segments[4].Points) != 0 {
|
||||
return pdfgo.Rectangle{}, false
|
||||
}
|
||||
var points [4]pdfgo.Point
|
||||
box := pdfgo.Rectangle{XMin: math.Inf(1), YMin: math.Inf(1), XMax: math.Inf(-1), YMax: math.Inf(-1)}
|
||||
for i, segment := range path.Segments[:4] {
|
||||
if len(segment.Points) != 1 || i == 0 && segment.Operator != "M" || i != 0 && segment.Operator != "L" {
|
||||
return pdfgo.Rectangle{}, false
|
||||
}
|
||||
point := segment.Points[0]
|
||||
if !finite(point.X) || !finite(point.Y) {
|
||||
return pdfgo.Rectangle{}, false
|
||||
}
|
||||
points[i] = point
|
||||
box.XMin, box.YMin = math.Min(box.XMin, point.X), math.Min(box.YMin, point.Y)
|
||||
box.XMax, box.YMax = math.Max(box.XMax, point.X), math.Max(box.YMax, point.Y)
|
||||
}
|
||||
if box.XMin == box.XMax || box.YMin == box.YMax {
|
||||
return pdfgo.Rectangle{}, false
|
||||
}
|
||||
corners := 0
|
||||
for i, point := range points {
|
||||
next := points[(i+1)%len(points)]
|
||||
if (point.X == next.X) == (point.Y == next.Y) || point.X != box.XMin && point.X != box.XMax || point.Y != box.YMin && point.Y != box.YMax {
|
||||
return pdfgo.Rectangle{}, false
|
||||
}
|
||||
corner := 0
|
||||
if point.X == box.XMax {
|
||||
corner++
|
||||
}
|
||||
if point.Y == box.YMax {
|
||||
corner += 2
|
||||
}
|
||||
corners |= 1 << corner
|
||||
}
|
||||
return box, corners == 15
|
||||
}
|
||||
|
||||
// pdfPatternRectanglePath 构造精确闭合矩形，用于连续覆盖的绘制及裁剪
|
||||
// 入参: box 矩形范围
|
||||
// 返回: pdfgo.Path 闭合矩形
|
||||
func pdfPatternRectanglePath(box pdfgo.Rectangle) pdfgo.Path {
|
||||
return pdfgo.Path{Segments: []pdfgo.Segment{{Operator: "M", Points: []pdfgo.Point{{X: box.XMin, Y: box.YMin}}}, {Operator: "L", Points: []pdfgo.Point{{X: box.XMax, Y: box.YMin}}}, {Operator: "L", Points: []pdfgo.Point{{X: box.XMax, Y: box.YMax}}}, {Operator: "L", Points: []pdfgo.Point{{X: box.XMin, Y: box.YMax}}}, {Operator: "C"}}}
|
||||
}
|
||||
|
||||
// densePatternRectangle 对单一不透明矩形的连续重叠轴求精确并集，不修改源步距或近似采样
|
||||
// 入参: source 原图案, base 基色, width 单元宽, height 单元高, xstep 横向步距, ystep 纵向步距
|
||||
// 返回: *pdfgo.PathMark 并集矩形, bool 横轴已连续覆盖, bool 纵轴已连续覆盖, error 解析或取消错误
|
||||
func (p *pdfImporter) densePatternRectangle(source *pdfgo.TilingPattern, base pdfgo.Paint, width, height, xstep, ystep float64) (*pdfgo.PathMark, bool, bool, error) {
|
||||
limit := float64(int(^uint(0) >> 1))
|
||||
continuousX, continuousY := width/xstep >= limit, height/ystep >= limit
|
||||
if !continuousX && !continuousY {
|
||||
return nil, false, false, nil
|
||||
}
|
||||
var mark pdfgo.PathMark
|
||||
paths, other := 0, false
|
||||
visitor := pdfgo.Visitor{
|
||||
Warning: p.warning,
|
||||
Path: func(value pdfgo.PathMark) error {
|
||||
paths++
|
||||
if paths == 1 {
|
||||
mark = value
|
||||
}
|
||||
return nil
|
||||
},
|
||||
Text: func(pdfgo.TextMark) error { other = true; return nil }, Image: func(pdfgo.ImageMark) error { other = true; return nil },
|
||||
Form: func(pdfgo.FormMark, func(pdfgo.Visitor) error) error { other = true; return nil },
|
||||
Group: func(pdfgo.GroupMark, func(pdfgo.Visitor) error) error { other = true; return nil },
|
||||
PostScript: func(pdfgo.PostScriptMark) error { other = true; return nil },
|
||||
}
|
||||
if err := source.Walk(p.ctx, base, visitor); err != nil {
|
||||
return nil, false, false, err
|
||||
}
|
||||
if err := p.ctx.Err(); err != nil {
|
||||
return nil, false, false, err
|
||||
}
|
||||
style, paint := mark.Style, mark.Style.Fill
|
||||
if other || paths != 1 || !mark.Fill || mark.Stroke || paint.None || paint.Alpha != 1 || paint.Colorant != nil || paint.Process != nil || paint.Tiling != nil || paint.Shading != nil || paint.Axial != nil || paint.Radial != nil || paint.Mesh != nil || paint.Function != nil || style.SoftMask != nil || style.Transfer != nil || style.Halftone != nil || style.FillOverprint || style.AlphaIsShape || style.BlendMode != "" && style.BlendMode != "Normal" || len(style.Clips) != 1 {
|
||||
return nil, false, false, nil
|
||||
}
|
||||
clip, ok := pdfPatternRectangleBounds(style.Clips[0])
|
||||
if !ok || clip != source.BBox {
|
||||
return nil, false, false, nil
|
||||
}
|
||||
box, ok := pdfPatternRectangleBounds(mark.Path)
|
||||
if !ok {
|
||||
return nil, false, false, nil
|
||||
}
|
||||
box.XMin, box.YMin = math.Max(box.XMin, clip.XMin), math.Max(box.YMin, clip.YMin)
|
||||
box.XMax, box.YMax = math.Min(box.XMax, clip.XMax), math.Min(box.YMax, clip.YMax)
|
||||
if box.XMax <= box.XMin || box.YMax <= box.YMin || continuousX && box.XMax-box.XMin < xstep || continuousY && box.YMax-box.YMin < ystep {
|
||||
return nil, false, false, nil
|
||||
}
|
||||
if continuousX {
|
||||
box.XMin, box.XMax = clip.XMin, clip.XMax
|
||||
}
|
||||
if continuousY {
|
||||
box.YMin, box.YMax = clip.YMin, clip.YMax
|
||||
}
|
||||
mark.Path = pdfPatternRectanglePath(box)
|
||||
return &mark, continuousX, continuousY, nil
|
||||
}
|
||||
|
||||
// densePatternPageBounds 将连续覆盖轴的等价单元边界置于页面外，避免子像素单元接缝
|
||||
// 入参: source 原图案, box 原单元, x 横轴连续覆盖, y 纵轴连续覆盖
|
||||
// 返回: pdfgo.Rectangle 等价单元边界, error 非有限范围或退化变换错误
|
||||
func (p *pdfImporter) densePatternPageBounds(source *pdfgo.TilingPattern, box pdfgo.Rectangle, x, y bool) (pdfgo.Rectangle, error) {
|
||||
inverse, ok := p.matrix.Mul(source.Matrix).Inverse()
|
||||
if !ok {
|
||||
return box, fmt.Errorf("invalid PDF dense pattern matrix")
|
||||
}
|
||||
if !finite(p.pageWidth) || !finite(p.pageHeight) || p.pageWidth <= 0 || p.pageHeight <= 0 {
|
||||
return box, fmt.Errorf("invalid PDF dense pattern page bounds")
|
||||
}
|
||||
area := pdfgo.Rectangle{XMin: math.Inf(1), YMin: math.Inf(1), XMax: math.Inf(-1), YMax: math.Inf(-1)}
|
||||
for _, point := range []pdfgo.Point{{}, {X: p.pageWidth}, {Y: p.pageHeight}, {X: p.pageWidth, Y: p.pageHeight}} {
|
||||
point = inverse.Apply(point)
|
||||
area.XMin, area.YMin = math.Min(area.XMin, point.X), math.Min(area.YMin, point.Y)
|
||||
area.XMax, area.YMax = math.Max(area.XMax, point.X), math.Max(area.YMax, point.Y)
|
||||
}
|
||||
if x {
|
||||
span := box.XMax - box.XMin
|
||||
box.XMin, box.XMax = math.Min(box.XMin, area.XMin-span), math.Max(box.XMax, area.XMax+span)
|
||||
}
|
||||
if y {
|
||||
span := box.YMax - box.YMin
|
||||
box.YMin, box.YMax = math.Min(box.YMin, area.YMin-span), math.Max(box.YMax, area.YMax+span)
|
||||
}
|
||||
for _, value := range []float64{box.XMin, box.YMin, box.XMax, box.YMax, box.XMax - box.XMin, box.YMax - box.YMin} {
|
||||
if !finite(value) {
|
||||
return box, fmt.Errorf("nonfinite PDF dense pattern page bounds")
|
||||
}
|
||||
}
|
||||
return box, nil
|
||||
}
|
||||
|
||||
// buildTilingPattern 保留PDF图案单元与页面坐标之间的仿射关系
|
||||
// 入参: source 平铺图案, base 无色图案基色
|
||||
// 返回: *Pattern OFD图案, error 转换错误
|
||||
@@ -148,12 +289,41 @@ func (p *pdfImporter) buildTilingPattern(source *pdfgo.TilingPattern, base pdfgo
|
||||
box := source.BBox
|
||||
width, height := box.XMax-box.XMin, box.YMax-box.YMin
|
||||
xstep, ystep := math.Abs(source.XStep), math.Abs(source.YStep)
|
||||
if (width == 0 || height == 0) && finite(width) && finite(height) && width >= 0 && height >= 0 && finite(xstep) && finite(ystep) && xstep > 0 && ystep > 0 {
|
||||
return &Pattern{Width: unit, Height: unit, XStep: unit, YStep: unit, RelativeTo: "Page"}, nil
|
||||
}
|
||||
if width <= 0 || height <= 0 || !finite(xstep) || !finite(ystep) || xstep == 0 || ystep == 0 {
|
||||
return nil, fmt.Errorf("invalid PDF tiling pattern dimensions")
|
||||
}
|
||||
dense, continuousX, continuousY, err := p.densePatternRectangle(source, base, width, height, xstep, ystep)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if dense != nil {
|
||||
box, err = p.densePatternPageBounds(source, box, continuousX, continuousY)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bounds, _ := pdfPatternRectangleBounds(dense.Path)
|
||||
if continuousX {
|
||||
bounds.XMin, bounds.XMax = box.XMin, box.XMax
|
||||
}
|
||||
if continuousY {
|
||||
bounds.YMin, bounds.YMax = box.YMin, box.YMax
|
||||
}
|
||||
dense.Path, dense.Style.Clips = pdfPatternRectanglePath(bounds), []pdfgo.Path{pdfPatternRectanglePath(box)}
|
||||
width, height = box.XMax-box.XMin, box.YMax-box.YMin
|
||||
}
|
||||
localToPDF := pdfgo.Matrix{1 / unit, 0, 0, -1 / unit, box.XMin, box.YMax}
|
||||
m := p.matrix.Mul(source.Matrix).Mul(localToPDF)
|
||||
pattern := &Pattern{Width: math.Min(width, xstep) * unit, Height: math.Min(height, ystep) * unit, XStep: xstep * unit, YStep: ystep * unit, RelativeTo: "Page", CTM: pdfNumbers(m[:]...)}
|
||||
repeatWidth, repeatHeight := width, height
|
||||
if continuousX {
|
||||
pattern.Width, repeatWidth = width*unit, xstep
|
||||
}
|
||||
if continuousY {
|
||||
pattern.Height, repeatHeight = height*unit, ystep
|
||||
}
|
||||
if p.patternOrigins == nil {
|
||||
p.patternOrigins = make(map[*Pattern]pdfObjectOrigin)
|
||||
}
|
||||
@@ -166,6 +336,9 @@ func (p *pdfImporter) buildTilingPattern(source *pdfgo.TilingPattern, base pdfgo
|
||||
}
|
||||
cell.objects = nil
|
||||
nodes, err := cell.collectCompositeNodes(func(visitor pdfgo.Visitor) error {
|
||||
if dense != nil {
|
||||
return visitor.Path(*dense)
|
||||
}
|
||||
return source.Walk(p.ctx, base, visitor)
|
||||
}, false)
|
||||
if err != nil {
|
||||
@@ -185,8 +358,8 @@ func (p *pdfImporter) buildTilingPattern(source *pdfgo.TilingPattern, base pdfgo
|
||||
return nil, err
|
||||
}
|
||||
pattern.CellContent.Objects = objects
|
||||
if len(objects) != 0 && (width > xstep || height > ystep) {
|
||||
columns, rows := math.Ceil(width/xstep), math.Ceil(height/ystep)
|
||||
if len(objects) != 0 && (repeatWidth > xstep || repeatHeight > ystep) {
|
||||
columns, rows := math.Ceil(repeatWidth/xstep), math.Ceil(repeatHeight/ystep)
|
||||
if !finite(columns*rows) || columns*rows >= float64(uint(^uint(0)>>1)+1) {
|
||||
return nil, fmt.Errorf("PDF tiling pattern instance count overflow")
|
||||
}
|
||||
|
||||
+28
-2
@@ -166,6 +166,11 @@ func (p *pdfImporter) text(mark pdfgo.TextMark) error {
|
||||
p.editor.fontMetrics[id] = imported.metrics
|
||||
}
|
||||
} else {
|
||||
if font.Recovered {
|
||||
if err := p.preservePDFObject(p.ctx, "Font", font.Dictionary); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
id, err = p.editor.AddExternalFont(font.Name)
|
||||
}
|
||||
if err != nil {
|
||||
@@ -625,15 +630,28 @@ func (p *pdfImporter) importedFont(source *pdfgo.Font) (*pdfImportedFont, error)
|
||||
}
|
||||
var type1 *basefont.Type1Program
|
||||
result := &pdfImportedFont{}
|
||||
programSource := *source
|
||||
programRecovered := false
|
||||
if p.warning != nil {
|
||||
var err error
|
||||
if source.ProgramType == "FontFile" {
|
||||
programSource.Program, programRecovered, err = basefont.NormalizePDFType1(source.Program)
|
||||
} else {
|
||||
programSource.Program, programRecovered, err = basefont.NormalizePDFProgram(source.Program)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("PDF font %s container: %w", source.Name, err)
|
||||
}
|
||||
}
|
||||
if source.ProgramType == "FontFile" {
|
||||
parsed, err := basefont.ParseType1Program(source.Program)
|
||||
parsed, err := basefont.ParseType1Program(programSource.Program)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("PDF font %s program: %w", source.Name, err)
|
||||
}
|
||||
type1 = &parsed
|
||||
result.type1Glyphs = parsed.GlyphIDs()
|
||||
}
|
||||
program, repair, err := codecpdf.FontProgram(source, type1)
|
||||
program, repair, err := codecpdf.FontProgram(&programSource, type1)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("PDF font %s program: %w", source.Name, err)
|
||||
}
|
||||
@@ -658,6 +676,14 @@ func (p *pdfImporter) importedFont(source *pdfgo.Font) (*pdfImportedFont, error)
|
||||
return nil, fmt.Errorf("PDF font backend does not provide glyph outlines")
|
||||
}
|
||||
result.checksum, result.repairLimit = sha256.Sum256(result.resource.Data), repair.MetricsLimit
|
||||
if source.Recovered || programRecovered {
|
||||
if err := p.preservePDFObject(p.ctx, "Font", source.Dictionary); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if programRecovered {
|
||||
p.warning(pdfgo.Diagnostic{Message: fmt.Sprintf("PDF font %s container and metrics normalized from embedded program; original glyph IDs retained", source.Name)})
|
||||
}
|
||||
if repair.Locations {
|
||||
p.warning(pdfgo.Diagnostic{Message: fmt.Sprintf("PDF font %s has invalid glyph locations; index rebuilt with original glyph IDs", source.Name)})
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user