xiaoqidun/ofdgo
1
0
Fork 0
mirror of https://github.com/xiaoqidun/ofdgo.git synced 2026-08-30 12:12:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat(强化兼容): 改进字体渲染

Browse Source
This commit is contained in:
xiaoqidun
2026-01-07 15:29:08 +08:00
parent 191ff30b97
commit 308076a9f6
11 changed files with 2065 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ofdgo.go
+5 -4
View File
@@ -65,10 +65,11 @@ func NewReader(r io.ReaderAt, size int64) (*Reader, error) {
// 返回: *Renderer 渲染器实例
func NewRenderer(reader *Reader, opts ...RendererOption) *Renderer {
r := &Renderer{
Reader: reader,
DPI: 300.0,
DrawParams: reader.drawParamCache,
FontMap: make(map[string]*canvas.FontFamily),
Reader: reader,
DPI: 300.0,
DrawParams: reader.drawParamCache,
CompositeGraphicUnits: reader.compositeGraphicUnitCache,
FontMap: make(map[string]*canvas.FontFamily),
}
for _, opt := range opts {
opt(r)
ofdgo_font.go
+21 -197
View File
@@ -15,209 +15,33 @@
package ofdgo
import (
"bytes"
"encoding/binary"
"fmt"
)
// FixFontData 修复字体数据
// 本函数主要解决嵌入字体缺失 OS/2 表导致部分渲染库（如 tdewolff/font）Panic 的问题
// 通过解析 hhea 表获取 Ascender/Descender 等度量信息，构造并注入一个标准的 OS/2 表
// 入参: data 原始字体文件数据
// 返回: bool 是否进行了修补, []byte 修复后的字体数据, error 错误信息
func FixFontData(data []byte) (bool, []byte, error) {
if len(data) < 12 {
return false, data, nil
// FixFontDataAggressive 激进修复字体数据
// 尝试修复缺失表(OS/2, cmap等)的TrueType字体或包装CFF裸数据
// 入参: data 原始字体数据, fixCmap 是否修复cmap, fixName 是否修复name
// 返回: bool 是否修复, []byte 修复后数据, map[rune]uint16 字符映射, bool 是否缺失cmap, error 错误信息
func FixFontDataAggressive(data []byte, fixCmap, fixName bool) (bool, []byte, map[rune]uint16, bool, error) {
if len(data) < 4 {
return false, data, nil, false, nil
}
numTables := binary.BigEndian.Uint16(data[4:6])
hasOS2 := false
type TableRecord struct {
Tag string
CheckSum uint32
Offset uint32
Length uint32
tag := string(data[0:4])
u32Tag := binary.BigEndian.Uint32(data[0:4])
isTrueType := u32Tag == 0x00010000 || tag == "true"
isOpenType := tag == "OTTO"
isTTC := tag == "ttcf"
if isTTC {
return false, data, nil, false, nil
}
tables := make([]TableRecord, 0, numTables)
var hhea TableRecord
hasHhea := false
pos := 12
for i := 0; i < int(numTables); i++ {
if len(data) < pos+16 {
return false, data, nil
}
tag := string(data[pos : pos+4])
checkSum := binary.BigEndian.Uint32(data[pos+4 : pos+8])
offset := binary.BigEndian.Uint32(data[pos+8 : pos+12])
length := binary.BigEndian.Uint32(data[pos+12 : pos+16])
tables = append(tables, TableRecord{tag, checkSum, offset, length})
if tag == "OS/2" {
hasOS2 = true
}
if tag == "hhea" {
hhea = TableRecord{tag, checkSum, offset, length}
hasHhea = true
}
pos += 16
}
if hasOS2 {
return false, data, nil
}
if !hasHhea {
return false, data, nil
}
if uint32(len(data)) < hhea.Offset+hhea.Length {
return false, data, nil
}
hheaData := data[hhea.Offset : hhea.Offset+hhea.Length]
if len(hheaData) < 10 {
return false, data, nil
}
ascender := int16(binary.BigEndian.Uint16(hheaData[4:6]))
descender := int16(binary.BigEndian.Uint16(hheaData[6:8]))
os2 := new(bytes.Buffer)
binary.Write(os2, binary.BigEndian, uint16(3))
binary.Write(os2, binary.BigEndian, int16(500))
binary.Write(os2, binary.BigEndian, uint16(400))
binary.Write(os2, binary.BigEndian, uint16(5))
binary.Write(os2, binary.BigEndian, uint16(0))
for i := 0; i < 11; i++ {
binary.Write(os2, binary.BigEndian, int16(0))
}
os2.Write(make([]byte, 10))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
os2.WriteString("PfEd")
binary.Write(os2, binary.BigEndian, uint16(0x0040))
binary.Write(os2, binary.BigEndian, uint16(0x0020))
binary.Write(os2, binary.BigEndian, uint16(0xFFFD))
binary.Write(os2, binary.BigEndian, ascender)
binary.Write(os2, binary.BigEndian, descender)
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, uint16(ascender))
if descender < 0 {
binary.Write(os2, binary.BigEndian, uint16(-descender))
} else {
binary.Write(os2, binary.BigEndian, uint16(descender))
}
binary.Write(os2, binary.BigEndian, uint32(1))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, uint16(0))
binary.Write(os2, binary.BigEndian, uint16(0x0020))
binary.Write(os2, binary.BigEndian, uint16(0))
os2Data := os2.Bytes()
os2CheckSum := calcTableChecksum(os2Data)
newNumTables := numTables + 1
entrySelector := 0
for 1<<(entrySelector+1) <= int(newNumTables) {
entrySelector++
}
searchRange := 1 << (entrySelector + 4)
rangeShift := int(newNumTables)*16 - searchRange
buf := new(bytes.Buffer)
buf.Write(data[0:4])
binary.Write(buf, binary.BigEndian, uint16(newNumTables))
binary.Write(buf, binary.BigEndian, uint16(searchRange))
binary.Write(buf, binary.BigEndian, uint16(entrySelector))
binary.Write(buf, binary.BigEndian, uint16(rangeShift))
newTables := append(tables, TableRecord{
Tag: "OS/2",
CheckSum: os2CheckSum,
Offset: 0,
Length: uint32(len(os2Data)),
})
for i := 0; i < len(newTables); i++ {
for j := i + 1; j < len(newTables); j++ {
if newTables[i].Tag > newTables[j].Tag {
newTables[i], newTables[j] = newTables[j], newTables[i]
if !isTrueType && !isOpenType {
if data[0] == 1 && data[1] == 0 && data[2] == 4 {
otf, mapping, err := wrapCFFToOTF(data)
if err == nil {
return true, otf, mapping, false, nil
}
}
}
headerSize := 12 + 16*uint32(len(newTables))
currentOffset := headerSize
for i := range newTables {
t := &newTables[i]
t.Offset = currentOffset
currentOffset += align4(t.Length)
}
for _, t := range newTables {
buf.WriteString(t.Tag)
binary.Write(buf, binary.BigEndian, t.CheckSum)
binary.Write(buf, binary.BigEndian, t.Offset)
binary.Write(buf, binary.BigEndian, t.Length)
}
for _, t := range newTables {
var tableData []byte
if t.Tag == "OS/2" {
tableData = os2Data
} else {
found := false
for _, old := range tables {
if old.Tag == t.Tag {
if uint32(len(data)) < old.Offset+old.Length {
return false, data, nil
}
tableData = data[old.Offset : old.Offset+old.Length]
found = true
break
}
}
if !found {
return false, data, fmt.Errorf("lost table %s", t.Tag)
}
}
buf.Write(tableData)
padding := align4(t.Length) - t.Length
for k := uint32(0); k < padding; k++ {
buf.WriteByte(0)
}
}
fullData := buf.Bytes()
var newHeadOffset uint32
var newHeadLength uint32
for _, t := range newTables {
if t.Tag == "head" {
newHeadOffset = t.Offset
newHeadLength = t.Length
}
}
if newHeadLength >= 12 {
checkSumAdjPos := newHeadOffset + 8
binary.BigEndian.PutUint32(fullData[checkSumAdjPos:checkSumAdjPos+4], 0)
cs := calcTableChecksum(fullData)
adjustment := 0xB1B0AFBA - cs
binary.BigEndian.PutUint32(fullData[checkSumAdjPos:checkSumAdjPos+4], adjustment)
}
return true, fullData, nil
}
// align4 计算 4 字节对齐后的长度
// 入参: n 原始长度
// 返回: uint32 对齐后的长度
func align4(n uint32) uint32 {
return (n + 3) & ^uint32(3)
}
// calcTableChecksum 计算字体表校验和
// 入参: data 表数据
// 返回: uint32 校验和
func calcTableChecksum(data []byte) uint32 {
var sum uint32
length := len(data)
for i := 0; i < length; i += 4 {
if i+4 <= length {
sum += binary.BigEndian.Uint32(data[i : i+4])
} else {
var val uint32
rem := data[i:]
for j, b := range rem {
val |= uint32(b) << (24 - 8*j)
}
sum += val
}
}
return sum
fixed, newData, mapping, mc, err := fixTrueType(data, fixCmap, fixName)
return fixed, newData, mapping, mc, err
}
ofdgo_font_cff.go
+981
View File
@@ -0,0 +1,981 @@
// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ofdgo
import (
"bytes"
"encoding/binary"
"fmt"
"math"
"sort"
"strconv"
"strings"
)
// wrapCFFToOTF 将 CFF 裸数据包装为 OpenType 字体格式
// 入参: cffData CFF字体数据
// 返回: []byte OTF字体数据, map[rune]uint16 字符映射, error 错误信息
func wrapCFFToOTF(cffData []byte) ([]byte, map[rune]uint16, error) {
sanitized, err := sanitizeCFF(cffData)
if err == nil {
cffData = sanitized
} else {
return nil, nil, err
}
numGlyphs, err := parseCFFAndCountGlyphs(cffData)
if err != nil {
return nil, nil, err
}
widths, err := parseCFFWidths(cffData, numGlyphs)
if err != nil {
widths = make([]uint16, numGlyphs)
for i := range widths {
widths[i] = 500
}
}
var unitsPerEm uint16 = 1000
if len(cffData) > 4 {
hdrSize := int(cffData[2])
off := hdrSize
_, sz := getCFFIndexCount(cffData, off)
off += sz
topDictData, _ := getCFFIndexData(cffData, off)
if topDictData != nil {
td := parseCFFDict(topDictData)
if mat, ok := td[1207]; ok && len(mat) > 0 {
if mat[0] != 0 {
val := 1.0 / mat[0]
if val > 0 {
unitsPerEm = uint16(math.Round(val))
}
}
}
}
}
mapping := getCmapFromCFF(cffData, int(numGlyphs))
tables := make(map[string][]byte)
tables["CFF "] = cffData
tables["head"] = buildHeadTable(unitsPerEm)
tables["hhea"] = buildHheaTable(uint16(numGlyphs))
tables["maxp"] = buildMaxpTable(uint16(numGlyphs))
tables["OS/2"] = buildOS2Table()
tables["name"] = buildNameTable()
tables["post"] = buildPostTable()
tables["hmtx"] = buildHmtxTable(widths)
tables["cmap"] = buildCmapTable(uint16(numGlyphs), mapping)
data, err := serializeOTF(tables)
return data, mapping, err
}
// cffDict 使用 float64 存储所有数值，以统一处理整数和实数
type cffDict map[int][]float64
// sanitizeCFF 尝试清洗CFF数据，转换CID字体并合并FontMatrix
// 入参: data 原始CFF数据
// 返回: []byte 清洗后的CFF数据, error 错误信息
func sanitizeCFF(data []byte) ([]byte, error) {
if len(data) < 4 {
return nil, fmt.Errorf("data too short")
}
hdrSize := int(data[2])
offset := hdrSize
if offset >= len(data) {
return nil, fmt.Errorf("truncated")
}
nameCount, nameSz := getCFFIndexCount(data, offset)
if nameCount != 1 {
return nil, fmt.Errorf("multi-font cff not supported")
}
nameIndexData := data[offset : offset+nameSz]
offset += nameSz
if offset >= len(data) {
return nil, fmt.Errorf("truncated")
}
topCount, topSz := getCFFIndexCount(data, offset)
if topCount != 1 {
return nil, fmt.Errorf("top dict count != 1")
}
topDictData, _ := getCFFIndexData(data, offset)
offset += topSz
if offset >= len(data) {
return nil, fmt.Errorf("truncated")
}
_, strSz := getCFFIndexCount(data, offset)
stringIndexData := data[offset : offset+strSz]
offset += strSz
if offset >= len(data) {
return nil, fmt.Errorf("truncated")
}
_, glbSz := getCFFIndexCount(data, offset)
globalSubrIndexData := data[offset : offset+glbSz]
topDict := parseCFFDict(topDictData)
if _, isCID := topDict[1230]; !isCID {
return data, nil
}
fdArrOffs, ok := topDict[1236]
if !ok || len(fdArrOffs) == 0 {
return nil, fmt.Errorf("cid without fdarray")
}
fdArrOff := int(fdArrOffs[0])
if fdArrOff >= len(data) {
return nil, fmt.Errorf("fdarray offset oob")
}
fdCount, _ := getCFFIndexCount(data, fdArrOff)
if fdCount != 1 {
return nil, fmt.Errorf("complex cid (fdarray count=%d) not supported", fdCount)
}
fontDictData, _ := getCFFIndexData(data, fdArrOff)
fontDict := parseCFFDict(fontDictData)
if fdMat, ok := fontDict[1207]; ok && len(fdMat) == 6 {
topMat, hasTop := topDict[1207]
if !hasTop || len(topMat) != 6 {
topMat = []float64{0.001, 0, 0, 0.001, 0, 0}
}
newMat := multiplyAffine(topMat, fdMat)
topDict[1207] = newMat
}
privVals, ok := fontDict[18]
if !ok || len(privVals) != 2 {
privVals = []float64{0, 0}
}
privSize := int(privVals[0])
privOff := int(privVals[1])
var localSubrData []byte
var privDictData []byte
if privSize > 0 && privOff < len(data) && privOff+privSize <= len(data) {
privDictData = data[privOff : privOff+privSize]
}
var subrsOffRel int
if len(privDictData) > 0 {
pDict := parseCFFDict(privDictData)
if sVals, ok := pDict[19]; ok && len(sVals) > 0 {
subrsOffRel = int(sVals[0])
}
}
if subrsOffRel > 0 {
subrsAbs := privOff + subrsOffRel
if subrsAbs < len(data) {
_, subSz := getCFFIndexCount(data, subrsAbs)
if subrsAbs+subSz <= len(data) {
localSubrData = data[subrsAbs : subrsAbs+subSz]
}
}
}
charStringsOffs, ok := topDict[17]
if !ok || len(charStringsOffs) == 0 {
return nil, fmt.Errorf("missing charstrings")
}
charStringsOff := int(charStringsOffs[0])
_, charStrSz := getCFFIndexCount(data, charStringsOff)
charStringsData := data[charStringsOff : charStringsOff+charStrSz]
delete(topDict, 1230)
delete(topDict, 1236)
delete(topDict, 1237)
delete(topDict, 1234)
delete(topDict, 15)
delete(topDict, 16)
topDict[18] = []float64{float64(privSize), 0}
var newCFF bytes.Buffer
newCFF.Write(data[:hdrSize])
newCFF.Write(nameIndexData)
dummyDict := make(map[int][]float64)
for k, v := range topDict {
dummyDict[k] = v
}
dummyDict[17] = []float64{0}
dummyDict[18] = []float64{float64(privSize), 0}
dummyTopData := encodeCFFDict(dummyDict)
topIdxSize := 2 + 1 + 8 + len(dummyTopData)
dataStart := hdrSize + len(nameIndexData) + topIdxSize + len(stringIndexData) + len(globalSubrIndexData)
charStringsPos := dataStart
privatePos := charStringsPos + len(charStringsData)
privateLen := privSize
var finalPrivData []byte
if len(privDictData) > 0 {
pDict := parseCFFDict(privDictData)
if _, ok := pDict[19]; ok || len(localSubrData) > 0 {
pDict[19] = []float64{float64(privateLen)}
}
finalPrivData = encodeCFFDict(pDict)
privateLen = len(finalPrivData)
}
localSubrsPos := privatePos + privateLen
topDict[17] = []float64{float64(charStringsPos)}
topDict[18] = []float64{float64(privateLen), float64(privatePos)}
finalTopData := encodeCFFDict(topDict)
topIndex := encodeCFFIndex([]([]byte){finalTopData})
newCFF.Reset()
newCFF.Write(data[:hdrSize])
newCFF.Write(nameIndexData)
newCFF.Write(topIndex)
newCFF.Write(stringIndexData)
newCFF.Write(globalSubrIndexData)
if newCFF.Len() != dataStart {
diff := newCFF.Len() - dataStart
charStringsPos += diff
privatePos += diff
localSubrsPos += diff
topDict[17] = []float64{float64(charStringsPos)}
topDict[18] = []float64{float64(privateLen), float64(privatePos)}
finalTopData = encodeCFFDict(topDict)
topIndex = encodeCFFIndex([]([]byte){finalTopData})
newCFF.Reset()
newCFF.Write(data[:hdrSize])
newCFF.Write(nameIndexData)
newCFF.Write(topIndex)
newCFF.Write(stringIndexData)
newCFF.Write(globalSubrIndexData)
}
newCFF.Write(charStringsData)
newCFF.Write(finalPrivData)
if len(localSubrData) > 0 {
newCFF.Write(localSubrData)
}
return newCFF.Bytes(), nil
}
// parseCFFAndCountGlyphs 解析 CFF 头部并统计字形数量
// 入参: data CFF数据
// 返回: int 字形数量, error 错误信息
func parseCFFAndCountGlyphs(data []byte) (int, error) {
if len(data) < 4 {
return 0, fmt.Errorf("data too short")
}
hdrSize := int(data[2])
offset := hdrSize
if offset >= len(data) {
return 0, fmt.Errorf("truncated")
}
count, sz := getCFFIndexCount(data, offset)
if count != 1 {
return 0, fmt.Errorf("multi-font cff not supported")
}
offset += sz
if offset >= len(data) {
return 0, fmt.Errorf("truncated")
}
count, _ = getCFFIndexCount(data, offset)
if count != 1 {
return 0, fmt.Errorf("top dict count mismatch")
}
topDictData, _ := getCFFIndexData(data, offset)
if topDictData != nil {
dict := parseCFFDict(topDictData)
if offsetVals, ok := dict[17]; ok && len(offsetVals) > 0 {
charStrOff := int(offsetVals[0])
if charStrOff > 0 && charStrOff < len(data) {
count, _ := getCFFIndexCount(data, charStrOff)
return count, nil
}
}
}
return 0, fmt.Errorf("failed to parse top dict")
}
// multiplyAffine 2x3 仿射矩阵乘法
// 入参: a 矩阵A, b 矩阵B
// 返回: []float64 结果矩阵
func multiplyAffine(a, b []float64) []float64 {
return []float64{
a[0]*b[0] + a[2]*b[1],
a[1]*b[0] + a[3]*b[1],
a[0]*b[2] + a[2]*b[3],
a[1]*b[2] + a[3]*b[3],
a[0]*b[4] + a[2]*b[5] + a[4],
a[1]*b[4] + a[3]*b[5] + a[5],
}
}
// parseCFFDict 解析 CFF 字典数据
// 入参: data 字典数据
// 返回: cffDict 解析后的字典映射
func parseCFFDict(data []byte) cffDict {
dict := make(cffDict)
var operands []float64
i := 0
for i < len(data) {
b := data[i]
i++
if b <= 27 {
op := int(b)
if b == 12 {
if i >= len(data) {
break
}
op = 1200 + int(data[i])
i++
}
dict[op] = operands
operands = nil
} else if b == 28 {
if i+1 < len(data) {
val := int(int16(binary.BigEndian.Uint16(data[i:])))
operands = append(operands, float64(val))
i += 2
}
} else if b == 29 {
if i+3 < len(data) {
val := int(int32(binary.BigEndian.Uint32(data[i:])))
operands = append(operands, float64(val))
i += 4
}
} else if b == 30 {
s, n := parseCFFReal(data[i:])
if f, err := strconv.ParseFloat(s, 64); err == nil {
operands = append(operands, f)
}
i += n
} else if b >= 32 && b <= 246 {
operands = append(operands, float64(int(b)-139))
} else if b >= 247 && b <= 250 {
if i < len(data) {
b1 := int(data[i])
i++
operands = append(operands, float64((int(b)-247)*256+b1+108))
}
} else if b >= 251 && b <= 254 {
if i < len(data) {
b1 := int(data[i])
i++
operands = append(operands, float64(-(int(b)-251)*256-b1-108))
}
}
}
return dict
}
// parseCFFReal 解析 CFF 实数编码
// 入参: data 数据切片
// 返回: string 实数字符串, int 消耗字节数
func parseCFFReal(data []byte) (string, int) {
var sb strings.Builder
i := 0
done := false
for i < len(data) && !done {
b := data[i]
i++
nibbles := []byte{b >> 4, b & 0x0F}
for _, n := range nibbles {
if n == 0xF {
done = true
break
}
if n <= 9 {
sb.WriteString(strconv.Itoa(int(n)))
}
if n == 0xA {
sb.WriteString(".")
}
if n == 0xB {
sb.WriteString("E")
}
if n == 0xC {
sb.WriteString("E-")
}
if n == 0xE {
sb.WriteString("-")
}
}
}
return sb.String(), i
}
// encodeCFFDict 编码 CFF 字典 (仅使用 float64 操作数)
// 入参: dict CFF字典映射
// 返回: []byte 编码后的字典数据
func encodeCFFDict(dict cffDict) []byte {
buf := new(bytes.Buffer)
var keys []int
for k := range dict {
keys = append(keys, k)
}
sort.Ints(keys)
for _, op := range keys {
vals := dict[op]
for _, val := range vals {
encodeNumberCFF(buf, val)
}
if op >= 1200 {
buf.WriteByte(12)
buf.WriteByte(byte(op - 1200))
} else {
buf.WriteByte(byte(op))
}
}
return buf.Bytes()
}
// encodeNumberCFF 编码单个数值到 CFF 格式
// 入参: buf 缓冲区, val 数值
func encodeNumberCFF(buf *bytes.Buffer, val float64) {
if val == math.Trunc(val) {
iv := int(val)
if iv >= -107 && iv <= 107 {
buf.WriteByte(byte(iv + 139))
} else if iv >= 108 && iv <= 1131 {
iv -= 108
buf.WriteByte(byte((iv >> 8) + 247))
buf.WriteByte(byte(iv & 0xFF))
} else if iv >= -1131 && iv <= -108 {
iv = -iv - 108
buf.WriteByte(byte((iv >> 8) + 251))
buf.WriteByte(byte(iv & 0xFF))
} else if iv >= -32768 && iv <= 32767 {
buf.WriteByte(28)
binary.Write(buf, binary.BigEndian, int16(iv))
} else {
buf.WriteByte(29)
binary.Write(buf, binary.BigEndian, int32(iv))
}
} else {
s := fmt.Sprintf("%g", val)
buf.WriteByte(30)
var nibbles []byte
for _, c := range s {
var n byte
switch c {
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
n = byte(c - '0')
case '.':
n = 0xA
case 'E', 'e':
n = 0xB
case '-':
n = 0xE
}
nibbles = append(nibbles, n)
}
nibbles = append(nibbles, 0xF)
if len(nibbles)%2 != 0 {
nibbles = append(nibbles, 0xF)
}
for i := 0; i < len(nibbles); i += 2 {
b := nibbles[i] << 4
if i+1 < len(nibbles) {
b |= nibbles[i+1]
}
buf.WriteByte(b)
}
}
}
// encodeCFFIndex 编码 CFF 索引结构
// 入参: items 数据项列表
// 返回: []byte 编码后的索引数据
func encodeCFFIndex(items []([]byte)) []byte {
count := len(items)
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint16(count))
if count == 0 {
return buf.Bytes()
}
totalSize := 0
for _, item := range items {
totalSize += len(item)
}
offSize := 1
if totalSize+1 > 255 {
offSize = 2
}
if totalSize+1 > 65535 {
offSize = 3
}
if totalSize+1 > 16777215 {
offSize = 4
}
buf.WriteByte(byte(offSize))
offset := 1
putOffset(buf, offset, offSize)
for _, item := range items {
offset += len(item)
putOffset(buf, offset, offSize)
}
for _, item := range items {
buf.Write(item)
}
return buf.Bytes()
}
// putOffset 写入指定大小的偏移量
// 入参: buf 缓冲区, val 偏移值, size 字节大小
func putOffset(buf *bytes.Buffer, val int, size int) {
tmp := make([]byte, 4)
binary.BigEndian.PutUint32(tmp, uint32(val))
buf.Write(tmp[4-size:])
}
// getCFFIndexCount 读取 CFF 索引的计数和大小
// 入参: data CFF数据, offset 偏移量
// 返回: int 数量, int 索引结构总大小
func getCFFIndexCount(data []byte, offset int) (int, int) {
if offset+2 > len(data) {
return 0, 0
}
count := int(binary.BigEndian.Uint16(data[offset:]))
if count == 0 {
return 0, 2
}
if offset+3 > len(data) {
return 0, 0
}
offSize := int(data[offset+2])
if offSize < 1 || offSize > 4 {
return 0, 0
}
dataSizeLen := (count + 1) * offSize
if offset+3+dataSizeLen > len(data) {
return 0, 0
}
endOffsetPos := offset + 3 + count*offSize
if endOffsetPos+offSize > len(data) {
return 0, 0
}
dataEnd := readCFFOffset(data, endOffsetPos, offSize)
if dataEnd < 1 {
return 0, 0
}
return count, 3 + (count+1)*offSize + (dataEnd - 1)
}
// getCFFIndexData 读取 CFF 索引的数据块
// 入参: data CFF数据, offset 偏移量
// 返回: []byte 索引数据(已去除offsets), int 索引结构总大小
func getCFFIndexData(data []byte, offset int) ([]byte, int) {
count, size := getCFFIndexCount(data, offset)
if count == 0 {
return nil, size
}
if offset+3 > len(data) {
return nil, size
}
offSize := int(data[offset+2])
if offset+3+offSize > len(data) {
return nil, size
}
off0 := readCFFOffset(data, offset+3, offSize)
if offset+3+offSize*2 > len(data) {
return nil, size
}
off1 := readCFFOffset(data, offset+3+offSize, offSize)
dataStartRel := 3 + (count+1)*offSize
dataStartAbs := offset + dataStartRel
start := dataStartAbs + (off0 - 1)
length := off1 - off0
if start < 0 || length < 0 || start+length > len(data) {
return nil, size
}
return data[start : start+length], size
}
// parseCFFWidths 从 CFF 数据中解析 Glyph 宽度
// 入参: data CFF数据, numGlyphs 字形数量
// 返回: []uint16 宽度列表, error 错误信息
func parseCFFWidths(data []byte, numGlyphs int) ([]uint16, error) {
if len(data) < 4 {
return nil, fmt.Errorf("data too short")
}
hdrSize := int(data[2])
offset := hdrSize
_, sz := getCFFIndexCount(data, offset)
offset += sz
topDictData, sz := getCFFIndexData(data, offset)
offset += sz
if topDictData == nil {
return nil, fmt.Errorf("failed to read top dict")
}
topDict := parseCFFDict(topDictData)
_, sz = getCFFIndexCount(data, offset)
offset += sz
_, sz = getCFFIndexCount(data, offset)
offset += sz
var nominalWidthX float64 = 0
var defaultWidthX float64 = 0
if vals, ok := topDict[18]; ok && len(vals) == 2 {
privSize := int(vals[0])
privOff := int(vals[1])
if privSize > 0 && privOff+privSize <= len(data) {
privData := data[privOff : privOff+privSize]
privDict := parseCFFDict(privData)
if v, ok := privDict[20]; ok && len(v) > 0 {
defaultWidthX = v[0]
}
if v, ok := privDict[21]; ok && len(v) > 0 {
nominalWidthX = v[0]
}
}
}
if vals, ok := topDict[17]; ok && len(vals) > 0 {
charStrOff := int(vals[0])
count, _ := getCFFIndexCount(data, charStrOff)
limit := count
if numGlyphs < limit {
limit = numGlyphs
}
widths := make([]uint16, numGlyphs)
for i := range widths {
widths[i] = uint16(defaultWidthX)
}
for i := 0; i < limit; i++ {
offSize := int(data[charStrOff+2])
p1 := charStrOff + 3 + i*offSize
p2 := p1 + offSize
off1 := readCFFOffset(data, p1, offSize)
off2 := readCFFOffset(data, p2, offSize)
dataStartBase := charStrOff + 3 + (count+1)*offSize
start := dataStartBase + (off1 - 1)
length := off2 - off1
if start < 0 || start+length > len(data) {
widths[i] = uint16(defaultWidthX)
continue
}
csData := data[start : start+length]
w := scanCharStringWidth(csData, nominalWidthX, defaultWidthX)
widths[i] = uint16(w)
}
return widths, nil
}
return nil, fmt.Errorf("no charstrings")
}
// scanCharStringWidth 扫描 CharString 获取宽度
// 入参: data CharString数据, nominal, def 默认宽度值
// 返回: float64 宽度值
func scanCharStringWidth(data []byte, nominal, def float64) float64 {
stackDepth := 0
i := 0
firstVal := 0.0
for i < len(data) {
b := data[i]
if b <= 31 {
if b == 28 {
i += 3
stackDepth++
if stackDepth == 1 {
firstVal = parseShortInt(data, i-3)
}
} else if b == 29 {
i += 5
stackDepth++
} else if b == 12 {
i += 2
if stackDepth%2 != 0 {
return nominal + firstVal
}
return def
} else if b == 19 || b == 20 {
if stackDepth%2 != 0 {
return nominal + firstVal
}
return def
} else {
if stackDepth%2 != 0 {
return nominal + firstVal
}
return def
}
} else {
stackDepth++
if stackDepth == 1 {
firstVal = parseNumberType2(data, i)
}
if b >= 32 && b <= 246 {
i++
} else if b >= 247 && b <= 250 {
i += 2
} else if b >= 251 && b <= 254 {
i += 2
} else if b == 255 {
i += 5
}
}
}
return def
}
// parseShortInt 解析短整数 (Type 2 CharString)
// 入参: data 数据, idx 索引
// 返回: float64 浮点值
func parseShortInt(data []byte, idx int) float64 {
return float64(int16(binary.BigEndian.Uint16(data[idx+1:])))
}
// parseNumberType2 解析 Number (Type 2)
// 入参: data 数据, idx 索引
// 返回: float64 浮点值
func parseNumberType2(data []byte, idx int) float64 {
b := data[idx]
if b >= 32 && b <= 246 {
return float64(int(b) - 139)
}
if b >= 247 && b <= 250 {
return float64((int(b)-247)*256 + int(data[idx+1]) + 108)
}
if b >= 251 && b <= 254 {
return float64(-(int(b)-251)*256 - int(data[idx+1]) - 108)
}
if b == 28 {
return float64(int16(binary.BigEndian.Uint16(data[idx+1:])))
}
if b == 255 {
return float64(int16(binary.BigEndian.Uint16(data[idx+1:]))) + float64(binary.BigEndian.Uint16(data[idx+3:]))/65536.0
}
return 0
}
// readCFFOffset 读取指定大小的偏移量
// 入参: data 数据, pos 位置, size 大小
// 返回: int 偏移量
func readCFFOffset(data []byte, pos, size int) int {
var val int
for i := 0; i < size; i++ {
if pos+i < len(data) {
val = (val << 8) | int(data[pos+i])
}
}
return val
}
// getCmapFromCFF 从 CFF 数据中恢复 Unicode 映射
// 入参: data CFF数据, numGlyphs 字形数量
// 返回: map[rune]uint16 恢复的映射表
func getCmapFromCFF(data []byte, numGlyphs int) map[rune]uint16 {
if len(data) < 4 {
return nil
}
hdrSize := int(data[2])
offset := hdrSize
_, sz := getCFFIndexCount(data, offset)
offset += sz
_, szTD := getCFFIndexCount(data, offset)
topDictData, _ := getCFFIndexData(data, offset)
offset += szTD
stringIndexOff := offset
if topDictData == nil {
return nil
}
td := parseCFFDict(topDictData)
charsetOff := 0
if vals, ok := td[15]; ok && len(vals) > 0 {
charsetOff = int(vals[0])
}
sids := make([]int, numGlyphs)
sids[0] = 0
if charsetOff > 2 {
sidsParsed := parseCFFCharset(data, charsetOff, numGlyphs)
copy(sids[1:], sidsParsed)
} else if charsetOff == 0 {
count := 228
if numGlyphs-1 < count {
count = numGlyphs - 1
}
for i := 1; i <= count; i++ {
sids[i] = i
}
} else {
return nil
}
mapping := make(map[rune]uint16)
for gid, sid := range sids {
if gid == 0 {
continue
}
var name string
if sid <= 390 {
if sid >= 0 && sid < len(cffStandardStrings) {
name = cffStandardStrings[sid]
}
} else {
idx := sid - 391
name = readStringIndexItem(data, stringIndexOff, idx)
}
r := rune(0)
if name != "" {
r = getUnicodeFromName(name)
}
if r == 0 {
r = 0xE000 + rune(gid)
}
mapping[r] = uint16(gid)
}
return mapping
}
// parseCFFCharset 解析 CFF 字符集并返回 SID 列表
// 入参: data CFF数据, offset 偏移量, numGlyphs 字形数量
// 返回: []int SID列表
func parseCFFCharset(data []byte, offset int, numGlyphs int) []int {
if offset >= len(data) {
return nil
}
format := data[offset]
var sids []int
count := numGlyphs - 1
pos := offset + 1
switch format {
case 0:
for i := 0; i < count && pos+2 <= len(data); i++ {
sid := int(binary.BigEndian.Uint16(data[pos:]))
sids = append(sids, sid)
pos += 2
}
case 1:
for len(sids) < count && pos+3 <= len(data) {
first := int(binary.BigEndian.Uint16(data[pos:]))
nLeft := int(data[pos+2])
pos += 3
for j := 0; j <= nLeft; j++ {
sids = append(sids, first+j)
}
}
case 2:
for len(sids) < count && pos+4 <= len(data) {
first := int(binary.BigEndian.Uint16(data[pos:]))
nLeft := int(binary.BigEndian.Uint16(data[pos+2:]))
pos += 4
for j := 0; j <= nLeft; j++ {
sids = append(sids, first+j)
}
}
}
if len(sids) > count {
sids = sids[:count]
}
return sids
}
// readStringIndexItem 读取 CFF 字符串索引项
// 入参: data CFF数据, offset 索引偏移, idx 索引号
// 返回: string 读取的字符串
func readStringIndexItem(data []byte, offset int, idx int) string {
if offset >= len(data) {
return ""
}
count := int(binary.BigEndian.Uint16(data[offset:]))
offSize := int(data[offset+2])
if idx >= count {
return ""
}
offArrayStart := offset + 3
p1 := offArrayStart + idx*offSize
p2 := p1 + offSize
if p2+offSize > len(data) {
return ""
}
loc1 := readCFFOffset(data, p1, offSize)
loc2 := readCFFOffset(data, p2, offSize)
dataStart := offArrayStart + (count+1)*offSize
start := dataStart + loc1 - 1
length := loc2 - loc1
if start < 0 || start+length > len(data) {
return ""
}
return string(data[start : start+length])
}
// getUnicodeFromName 根据字形名称获取对应的Unicode字符
// 入参: name 字形名称
// 返回: rune Unicode字符
func getUnicodeFromName(name string) rune {
if strings.HasPrefix(name, "uni") && len(name) == 7 {
hexStr := strings.ToUpper(name[3:])
if val, err := strconv.ParseInt(hexStr, 16, 32); err == nil {
return rune(val)
}
}
if strings.HasPrefix(name, "u") && len(name) >= 5 && len(name) <= 7 && !strings.HasPrefix(name, "uni") {
hexStr := strings.ToUpper(name[1:])
if val, err := strconv.ParseInt(hexStr, 16, 32); err == nil {
return rune(val)
}
}
switch name {
case "space":
return ' '
case "exclam":
return '!'
case "quotedbl":
return '"'
case "numbersign":
return '#'
case "dollar":
return '$'
case "percent":
return '%'
case "ampersand":
return '&'
case "quotesingle":
return '\''
case "parenleft":
return '('
case "parenright":
return ')'
case "asterisk":
return '*'
case "plus":
return '+'
case "comma":
return ','
case "hyphen":
return '-'
case "period":
return '.'
case "slash":
return '/'
case "colon":
return ':'
case "semicolon":
return ';'
case "less":
return '<'
case "equal":
return '='
case "greater":
return '>'
case "question":
return '?'
case "at":
return '@'
case "bracketleft":
return '['
case "backslash":
return '\\'
case "bracketright":
return ']'
case "asciicircum":
return '^'
case "underscore":
return '_'
case "grave":
return '`'
case "braceleft":
return '{'
case "bar":
return '|'
case "braceright":
return '}'
case "asciitilde":
return '~'
}
if len(name) == 1 {
return rune(name[0])
}
return 0
}
// cffStandardStrings CFF 标准字符串表
var cffStandardStrings = []string{
".notdef", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quoteright", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section", "currency", "quotesingle", "quotedblleft", "quotedblright", "guillemotleft", "guillemotright", "dagger", "daggerdbl", "fi", "fl", "endash", "emdash", "paragraph", "bullet", "quotesinglbase", "quotedblbase", "second", "circumflex", "breve", "dotaccent", "dieresis", "grave", "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "emspace",
"AE", "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine", "ae", "dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior", "logicalnot", "mu", "trademark", "Eth", "onehalf", "plusminus", "Thorn", "onequarter", "divide", "brokenbar", "degree", "thorn", "threequarters", "twosuperior", "registered", "minus", "eth", "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave", "Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis", "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex", "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron", "aacute", "acircumflex", "adieresis", "agrave", "aring", "atilde", "ccedilla", "eacute", "ecircumflex", "edieresis", "egrave", "iacute", "icircumflex", "idieresis", "igrave", "ntilde", "oacute", "ocircumflex", "odieresis", "ograve", "otilde", "scaron", "uacute", "ucircumflex", "udieresis", "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall", "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "2dotlead", "nbspace", "1dotlead", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "commasuperior", "threequartersemdash", "periodsuperior", "questionsmall", "asuperior", "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior", "tsuperior", "ff", "ffi", "ffl", "parenleftinferior", "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall", "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall", "questiondownsmall", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "zerosuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior", "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior", "dollarinferior", "periodinferior", "commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall", "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall", "001.000", "001.001", "001.002", "001.003", "Black", "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold",
}
ofdgo_font_ttf.go
+140
View File
@@ -0,0 +1,140 @@
// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ofdgo
import (
"encoding/binary"
)
// fixTrueType 尝试修复 TrueType/OpenType 字体数据
// 入参: data 原始字体数据, fixCmap 是否修复cmap, fixName 是否修复name
// 返回: bool 是否修复, []byte 修复后数据, map[rune]uint16 字符映射, bool 是否缺失cmap, error 错误信息
func fixTrueType(data []byte, fixCmap, fixName bool) (bool, []byte, map[rune]uint16, bool, error) {
if len(data) < 12 {
return false, data, nil, false, nil
}
numTables := binary.BigEndian.Uint16(data[4:6])
existingTables := make(map[string][]byte)
pos := 12
for i := 0; i < int(numTables); i++ {
if len(data) < pos+16 {
break
}
tag := string(data[pos : pos+4])
offset := binary.BigEndian.Uint32(data[pos+8 : pos+12])
length := binary.BigEndian.Uint32(data[pos+12 : pos+16])
if uint32(len(data)) >= offset+length {
existingTables[tag] = data[offset : offset+length]
}
pos += 16
}
missingHead := existingTables["head"] == nil
missingMaxp := existingTables["maxp"] == nil
missingHhea := existingTables["hhea"] == nil
missingHmtx := existingTables["hmtx"] == nil
missingOS2 := existingTables["OS/2"] == nil
missingCmap := existingTables["cmap"] == nil
if !missingCmap {
if !hasUsableCmap(existingTables["cmap"]) {
missingCmap = true
}
}
missingName := existingTables["name"] == nil
missingPost := existingTables["post"] == nil
if !missingHead && !missingMaxp && !missingHhea && !missingHmtx &&
!missingOS2 && !missingCmap && !missingName && !missingPost {
return false, data, nil, false, nil
}
newTables := make(map[string][]byte)
for k, v := range existingTables {
newTables[k] = v
}
var numGlyphs uint16 = 0
if !missingMaxp {
maxp := existingTables["maxp"]
if len(maxp) >= 6 {
numGlyphs = binary.BigEndian.Uint16(maxp[4:6])
}
}
if numGlyphs == 0 {
numGlyphs = 255
}
if missingHead {
newTables["head"] = buildHeadTable(1000)
}
if missingMaxp {
newTables["maxp"] = buildMaxpTable(numGlyphs)
}
if missingHhea {
newTables["hhea"] = buildHheaTable(numGlyphs)
}
if missingHmtx {
defWidths := make([]uint16, numGlyphs)
for i := range defWidths {
defWidths[i] = 500
}
newTables["hmtx"] = buildHmtxTable(defWidths)
}
ascender := int16(800)
descender := int16(-200)
if hhea, ok := newTables["hhea"]; ok && len(hhea) >= 10 {
ascender = int16(binary.BigEndian.Uint16(hhea[4:6]))
descender = int16(binary.BigEndian.Uint16(hhea[6:8]))
}
if missingOS2 {
newTables["OS/2"] = buildOS2TableWithMetrics(ascender, descender)
}
var mapping map[rune]uint16
if missingCmap && fixCmap {
mapping = make(map[rune]uint16)
for i := uint16(0); i < numGlyphs; i++ {
mapping[rune(i)] = i
}
newTables["cmap"] = buildCmapTable(numGlyphs, mapping)
}
if missingName && fixName {
newTables["name"] = buildNameTable()
}
if missingPost {
newTables["post"] = buildPostTable()
}
finalData, err := serializeOTF(newTables)
if err != nil {
return false, data, nil, missingCmap, err
}
return true, finalData, mapping, missingCmap, nil
}
// hasUsableCmap 检查是否存在可用的 cmap 子表
// 入参: data cmap表数据
// 返回: bool 是否可用
func hasUsableCmap(data []byte) bool {
if len(data) < 4 {
return false
}
numTables := binary.BigEndian.Uint16(data[2:4])
pos := 4
for i := 0; i < int(numTables); i++ {
if len(data) < pos+8 {
break
}
platformID := binary.BigEndian.Uint16(data[pos : pos+2])
if platformID == 0 || platformID == 3 {
return true
}
pos += 8
}
return false
}
ofdgo_font_util.go
+409
View File
@@ -0,0 +1,409 @@
// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ofdgo
import (
"bytes"
"encoding/binary"
"sort"
)
// align4 计算 4 字节对齐后的长度
// 入参: n 原始长度
// 返回: uint32 对齐后的长度
func align4(n uint32) uint32 {
return (n + 3) & ^uint32(3)
}
// calcTableChecksum 计算字体表校验和
// 入参: data 表数据
// 返回: uint32 校验和
func calcTableChecksum(data []byte) uint32 {
var sum uint32
length := len(data)
for i := 0; i < length; i += 4 {
if i+4 <= length {
sum += binary.BigEndian.Uint32(data[i : i+4])
} else {
var val uint32
rem := data[i:]
for j, b := range rem {
val |= uint32(b) << (24 - 8*j)
}
sum += val
}
}
return sum
}
// checkMissingCmap 检查是否缺失 cmap 表
// 入参: data 字体数据
// 返回: bool 是否缺失
func checkMissingCmap(data []byte) bool {
if len(data) < 12 {
return true
}
numTables := binary.BigEndian.Uint16(data[4:6])
for i := 0; i < int(numTables); i++ {
pos := 12 + i*16
if len(data) < pos+4 {
break
}
tag := string(data[pos : pos+4])
if tag == "cmap" {
return false
}
}
return true
}
// buildHeadTable 构建 head 表
// 入参: unitsPerEm 每em单位数
// 返回: []byte head表数据
func buildHeadTable(unitsPerEm uint16) []byte {
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint16(1))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0x5F0F3CF5))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, unitsPerEm)
binary.Write(buf, binary.BigEndian, int64(0))
binary.Write(buf, binary.BigEndian, int64(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(-500))
binary.Write(buf, binary.BigEndian, int16(1000))
binary.Write(buf, binary.BigEndian, int16(1000))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, int16(2))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
return buf.Bytes()
}
// buildHheaTable 构建 hhea 表
// 入参: numGlyphs 字形数量
// 返回: []byte hhea表数据
func buildHheaTable(numGlyphs uint16) []byte {
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint16(1))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, int16(800))
binary.Write(buf, binary.BigEndian, int16(-200))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, uint16(1000))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(1000))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, uint16(numGlyphs))
return buf.Bytes()
}
// buildMaxpTable 构建 maxp 表
// 入参: numGlyphs 字形数量
// 返回: []byte maxp表数据
func buildMaxpTable(numGlyphs uint16) []byte {
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint32(0x00005000))
binary.Write(buf, binary.BigEndian, uint16(numGlyphs))
return buf.Bytes()
}
// buildOS2Table 构建 OS/2 表 (使用默认 Metrics)
// 返回: []byte OS/2表数据
func buildOS2Table() []byte {
return buildOS2TableWithMetrics(800, -200)
}
// buildOS2TableWithMetrics 构建 OS/2 表
// 入参: ascender 上升部, descender 下降部
// 返回: []byte OS/2表数据
func buildOS2TableWithMetrics(ascender, descender int16) []byte {
os2 := new(bytes.Buffer)
binary.Write(os2, binary.BigEndian, uint16(3))
binary.Write(os2, binary.BigEndian, int16(500))
binary.Write(os2, binary.BigEndian, uint16(400))
binary.Write(os2, binary.BigEndian, uint16(5))
binary.Write(os2, binary.BigEndian, uint16(0))
binary.Write(os2, binary.BigEndian, int16(250))
binary.Write(os2, binary.BigEndian, int16(250))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(250))
binary.Write(os2, binary.BigEndian, int16(250))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(50))
binary.Write(os2, binary.BigEndian, int16(250))
binary.Write(os2, binary.BigEndian, int16(0))
os2.Write(make([]byte, 10))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
os2.WriteString("PfEd")
binary.Write(os2, binary.BigEndian, uint16(0x0040))
binary.Write(os2, binary.BigEndian, uint16(0))
binary.Write(os2, binary.BigEndian, uint16(255))
binary.Write(os2, binary.BigEndian, ascender)
binary.Write(os2, binary.BigEndian, descender)
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, uint16(ascender))
if descender < 0 {
binary.Write(os2, binary.BigEndian, uint16(-descender))
} else {
binary.Write(os2, binary.BigEndian, uint16(descender))
}
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, uint32(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, int16(0))
binary.Write(os2, binary.BigEndian, uint16(0))
binary.Write(os2, binary.BigEndian, uint16(0))
binary.Write(os2, binary.BigEndian, uint16(0))
return os2.Bytes()
}
// buildNameTable 构建 name 表 (最小化)
// 返回: []byte name表数据
func buildNameTable() []byte {
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint16(6))
return buf.Bytes()
}
// buildPostTable 构建 post 表 (版本 3.0, 无字形名称)
// 返回: []byte post表数据
func buildPostTable() []byte {
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint32(0x00030000))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, int16(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0))
binary.Write(buf, binary.BigEndian, uint32(0))
return buf.Bytes()
}
// buildHmtxTable 构建 hmtx 表
// 入参: widths 宽度列表
// 返回: []byte hmtx表数据
func buildHmtxTable(widths []uint16) []byte {
buf := new(bytes.Buffer)
for _, w := range widths {
binary.Write(buf, binary.BigEndian, uint16(w))
binary.Write(buf, binary.BigEndian, int16(0))
}
return buf.Bytes()
}
// cmapSegment cmap 表段结构
// 字段: start 开始字符, end 结束字符, delta 增量, offset 偏移
type cmapSegment struct {
start, end uint16
delta int16
offset uint16
}
// buildCmapTable 构建 cmap 表 (Format 4)
// 入参: numGlyphs 字形数量, mapping 字符映射
// 返回: []byte cmap表数据
func buildCmapTable(numGlyphs uint16, mapping map[rune]uint16) []byte {
var segs []cmapSegment
if mapping == nil {
end := uint16(0xFFFF)
if numGlyphs > 0 {
end = numGlyphs - 1
}
segs = append(segs, cmapSegment{start: 0, end: end, delta: 0, offset: 0})
} else {
var codes []int
for r := range mapping {
if r <= 0xFFFF {
codes = append(codes, int(r))
}
}
sort.Ints(codes)
if len(codes) > 0 {
start := codes[0]
prev := start
for i := 1; i < len(codes); i++ {
curr := codes[i]
if curr != prev+1 {
segs = append(segs, cmapSegment{start: uint16(start), end: uint16(prev), delta: 0, offset: 0})
start = curr
}
prev = curr
}
segs = append(segs, cmapSegment{start: uint16(start), end: uint16(prev), delta: 0, offset: 0})
}
}
segs = append(segs, cmapSegment{start: 0xFFFF, end: 0xFFFF, delta: 1, offset: 0})
segCount := uint16(len(segs))
searchRange := uint16(1)
entrySelector := uint16(0)
for searchRange*2 <= segCount {
searchRange *= 2
entrySelector++
}
searchRange *= 2
rangeShift := segCount*2 - searchRange
buf := new(bytes.Buffer)
binary.Write(buf, binary.BigEndian, uint16(4))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint16(0))
binary.Write(buf, binary.BigEndian, uint16(segCount*2))
binary.Write(buf, binary.BigEndian, searchRange)
binary.Write(buf, binary.BigEndian, entrySelector)
binary.Write(buf, binary.BigEndian, rangeShift)
var endCounts, startCounts, idDeltas, idRangeOffsets []uint16
var glyphIds []uint16
for _, s := range segs {
endCounts = append(endCounts, s.end)
startCounts = append(startCounts, s.start)
if mapping == nil {
idDeltas = append(idDeltas, 0)
idRangeOffsets = append(idRangeOffsets, 0)
continue
}
if s.start == 0xFFFF {
idDeltas = append(idDeltas, 1)
idRangeOffsets = append(idRangeOffsets, 0)
continue
}
idDeltas = append(idDeltas, 0)
currentGlyphIdx := len(glyphIds)
for c := int(s.start); c <= int(s.end); c++ {
gid := mapping[rune(c)]
glyphIds = append(glyphIds, gid)
}
offset := (int(segCount)-int(len(idRangeOffsets))-1)*2 + 2 + currentGlyphIdx*2
idRangeOffsets = append(idRangeOffsets, uint16(offset))
}
for _, v := range endCounts {
binary.Write(buf, binary.BigEndian, v)
}
binary.Write(buf, binary.BigEndian, uint16(0))
for _, v := range startCounts {
binary.Write(buf, binary.BigEndian, v)
}
for _, v := range idDeltas {
binary.Write(buf, binary.BigEndian, v)
}
for _, v := range idRangeOffsets {
binary.Write(buf, binary.BigEndian, v)
}
for _, v := range glyphIds {
binary.Write(buf, binary.BigEndian, v)
}
data := buf.Bytes()
binary.BigEndian.PutUint16(data[2:4], uint16(len(data)))
mainBuf := new(bytes.Buffer)
binary.Write(mainBuf, binary.BigEndian, uint16(0))
binary.Write(mainBuf, binary.BigEndian, uint16(1))
binary.Write(mainBuf, binary.BigEndian, uint16(3))
binary.Write(mainBuf, binary.BigEndian, uint16(1))
binary.Write(mainBuf, binary.BigEndian, uint32(12))
mainBuf.Write(data)
return mainBuf.Bytes()
}
// otfTableRecord OTF 表记录结构
// 字段: tag 标签, checksum 校验和, offset 偏移, length 长度, data 数据
type otfTableRecord struct {
tag string
checksum uint32
offset int
length int
data []byte
}
// serializeOTF 序列化 OpenType 字体结构
// 入参: tables 表数据映射
// 返回: []byte 完整字体数据, error 错误信息
func serializeOTF(tables map[string][]byte) ([]byte, error) {
numTables := uint16(len(tables))
entrySelector := 0
for 1<<(entrySelector+1) <= int(numTables) {
entrySelector++
}
searchRange := 1 << (entrySelector + 4)
rangeShift := int(numTables)*16 - searchRange
buf := new(bytes.Buffer)
if _, ok := tables["CFF "]; ok {
buf.WriteString("OTTO")
} else {
binary.Write(buf, binary.BigEndian, uint32(0x00010000))
}
binary.Write(buf, binary.BigEndian, numTables)
binary.Write(buf, binary.BigEndian, uint16(searchRange))
binary.Write(buf, binary.BigEndian, uint16(entrySelector))
binary.Write(buf, binary.BigEndian, uint16(rangeShift))
var tags []string
for t := range tables {
tags = append(tags, t)
}
sort.Strings(tags)
headerSize := 12 + 16*int(numTables)
offset := headerSize
var records []otfTableRecord
for _, tag := range tags {
data := tables[tag]
pad := (4 - (len(data) % 4)) % 4
padded := make([]byte, len(data)+pad)
copy(padded, data)
cs := calcTableChecksum(padded)
records = append(records, otfTableRecord{tag, cs, offset, len(data), padded})
offset += len(padded)
}
for _, r := range records {
buf.WriteString(r.tag)
binary.Write(buf, binary.BigEndian, r.checksum)
binary.Write(buf, binary.BigEndian, uint32(r.offset))
binary.Write(buf, binary.BigEndian, uint32(r.length))
}
for _, r := range records {
buf.Write(r.data)
}
fullData := buf.Bytes()
for _, r := range records {
if r.tag == "head" {
adjOffset := r.offset + 8
if adjOffset+4 <= len(fullData) {
binary.BigEndian.PutUint32(fullData[adjOffset:], 0)
cs := calcTableChecksum(fullData)
checksumAdj := 0xB1B0AFBA - cs
binary.BigEndian.PutUint32(fullData[adjOffset:], checksumAdj)
}
break
}
}
return fullData, nil
}
ofdgo_geom.go
+14
View File
@@ -63,6 +63,20 @@ func NewMatrix(s string) Matrix {
}
}
// Multiply 矩阵乘法 (m * o)
// 入参: o 右侧矩阵
// 返回: Matrix 结果矩阵
func (m Matrix) Multiply(o Matrix) Matrix {
return Matrix{
a: m.a*o.a + m.c*o.b,
b: m.b*o.a + m.d*o.b,
c: m.a*o.c + m.c*o.d,
d: m.b*o.c + m.d*o.d,
e: m.a*o.e + m.c*o.f + m.e,
f: m.b*o.e + m.d*o.f + m.f,
}
}
// Transform 应用变换矩阵
// 入参: x X坐标, y Y坐标
// 返回: float64 变换后X, float64 变换后Y
ofdgo_page.go
+57 -22
View File
@@ -38,41 +38,66 @@ type Content struct {
// Layer 图层
type Layer struct {
ID string `xml:"ID,attr"`
DrawParam string `xml:"DrawParam,attr"`
TextObject []TextObject `xml:"TextObject"`
PathObject []PathObject `xml:"PathObject"`
ImageObject []ImageObject `xml:"ImageObject"`
ID string `xml:"ID,attr"`
DrawParam string `xml:"DrawParam,attr"`
TextObject []TextObject `xml:"TextObject"`
PathObject []PathObject `xml:"PathObject"`
ImageObject []ImageObject `xml:"ImageObject"`
CompositeGraphicUnit []CompositeGraphicUnit `xml:"CompositeGraphicUnit"`
}
// Clips 裁剪区域集合
type Clips struct {
Clip []Clip `xml:"Clip"`
}
// Clip 裁剪
type Clip struct {
Area []ClipArea `xml:"Area"`
}
// ClipArea 裁剪区域
type ClipArea struct {
Path []PathObject `xml:"Path"`
Text []TextObject `xml:"Text"`
}
// TextObject 文本对象
type TextObject struct {
ID string `xml:"ID,attr"`
Boundary string `xml:"Boundary,attr"`
DrawParam string `xml:"DrawParam,attr"`
Font string `xml:"Font,attr"`
Size float64 `xml:"Size,attr"`
Weight int `xml:"Weight,attr"`
Italic bool `xml:"Italic,attr"`
Decoration string `xml:"Decoration,attr"`
HScale float64 `xml:"HScale,attr"`
CTM string `xml:"CTM,attr"`
FillColor *FillColor `xml:"FillColor"`
TextCode []TextCode `xml:"TextCode"`
ID string `xml:"ID,attr"`
Boundary string `xml:"Boundary,attr"`
DrawParam string `xml:"DrawParam,attr"`
LineWidth float64 `xml:"LineWidth,attr"`
Font string `xml:"Font,attr"`
Size float64 `xml:"Size,attr"`
Weight int `xml:"Weight,attr"`
Italic bool `xml:"Italic,attr"`
Decoration string `xml:"Decoration,attr"`
HScale float64 `xml:"HScale,attr"`
VScale float64 `xml:"VScale,attr"`
CTM string `xml:"CTM,attr"`
Fill *bool `xml:"Fill,attr"`
Stroke *bool `xml:"Stroke,attr"`
StrokeColor *StrokeColor `xml:"StrokeColor"`
FillColor *FillColor `xml:"FillColor"`
TextCode []TextCode `xml:"TextCode"`
Clips *Clips `xml:"Clips"`
}
// FillColor 填充颜色
type FillColor struct {
Value string `xml:"Value,attr"`
Alpha *int `xml:"Alpha,attr"`
}
// TextCode 文本内容节点
type TextCode struct {
X float64 `xml:"X,attr"`
Y float64 `xml:"Y,attr"`
DeltaX string `xml:"DeltaX,attr"`
DeltaY string `xml:"DeltaY,attr"`
Value string `xml:",chardata"`
X string `xml:"X,attr"`
Y string `xml:"Y,attr"`
DeltaX string `xml:"DeltaX,attr"`
DeltaY string `xml:"DeltaY,attr"`
Index string `xml:"Index,attr"`
Value string `xml:",chardata"`
}
// PathObject 路径对象
@@ -81,15 +106,24 @@ type PathObject struct {
Boundary string `xml:"Boundary,attr"`
DrawParam string `xml:"DrawParam,attr"`
LineWidth float64 `xml:"LineWidth,attr"`
Join string `xml:"Join,attr"`
Cap string `xml:"Cap,attr"`
DashOffset float64 `xml:"DashOffset,attr"`
DashPattern string `xml:"DashPattern,attr"`
MiterLimit float64 `xml:"MiterLimit,attr"`
CTM string `xml:"CTM,attr"`
Stroke *bool `xml:"Stroke,attr"`
Fill *bool `xml:"Fill,attr"`
StrokeColor *StrokeColor `xml:"StrokeColor"`
FillColor *FillColor `xml:"FillColor"`
AbbreviatedData string `xml:"AbbreviatedData"`
Clips *Clips `xml:"Clips"`
}
// StrokeColor 勾边颜色
type StrokeColor struct {
Value string `xml:"Value,attr"`
Alpha *int `xml:"Alpha,attr"`
}
// ImageObject 图片对象
@@ -98,4 +132,5 @@ type ImageObject struct {
Boundary string `xml:"Boundary,attr"`
ResourceID string `xml:"ResourceID,attr"`
CTM string `xml:"CTM,attr"`
Clips *Clips `xml:"Clips"`
}
ofdgo_reader.go
+16 -10
View File
@@ -25,16 +25,17 @@ import (
// Reader OFD文件阅读器
type Reader struct {
Path string
Zip *zip.Reader
Closer io.Closer
OFD *OFD
RootDir string
ResMap map[string]string
fontCache map[string]*Font
drawParamCache map[string]*DrawParam
doc *Document
Stamps map[string][]Stamp
Path string
Zip *zip.Reader
Closer io.Closer
OFD *OFD
RootDir string
ResMap map[string]string
fontCache map[string]*Font
drawParamCache map[string]*DrawParam
compositeGraphicUnitCache map[string]*CompositeGraphicUnit
doc *Document
Stamps map[string][]Stamp
}
// Close 关闭阅读器
@@ -61,6 +62,7 @@ func (r *Reader) initRoot() error {
r.ResMap = make(map[string]string)
r.fontCache = make(map[string]*Font)
r.drawParamCache = make(map[string]*DrawParam)
r.compositeGraphicUnitCache = make(map[string]*CompositeGraphicUnit)
return nil
}
@@ -185,6 +187,10 @@ func (r *Reader) loadRes(resPath string) {
dp := &res.DrawParams.DrawParam[i]
r.drawParamCache[dp.ID] = dp
}
for i := range res.CompositeGraphicUnits.CompositeGraphicUnit {
cgu := &res.CompositeGraphicUnits.CompositeGraphicUnit[i]
r.compositeGraphicUnitCache[cgu.ID] = cgu
}
}
// PageContent 获取页面内容
ofdgo_renderer.go
+390 -107
View File
@@ -21,6 +21,7 @@ import (
"image/color"
"io"
"io/fs"
"math"
"path/filepath"
"strconv"
"strings"
@@ -34,13 +35,15 @@ import (
// Renderer 渲染器实现
type Renderer struct {
Reader *Reader
DPI float64
fontFamily *canvas.FontFamily
DrawParams map[string]*DrawParam
FontMap map[string]*canvas.FontFamily
fontDirs []string
fontFS []fs.FS
Reader *Reader
DPI float64
fontFamily *canvas.FontFamily
DrawParams map[string]*DrawParam
CompositeGraphicUnits map[string]*CompositeGraphicUnit
FontMap map[string]*canvas.FontFamily
FontGIDMap map[string]map[uint16]rune
fontDirs []string
fontFS []fs.FS
}
// RendererOption 渲染器配置选项
@@ -103,7 +106,7 @@ func (r *Renderer) RenderPageToContext(ctx *canvas.Context, page *PageContent) e
}
if page.Content.Layer != nil {
for _, layer := range page.Content.Layer {
r.renderLayer(ctx, layer, pageH, nil, nil, 0)
r.renderLayer(ctx, layer, pageH, nil, nil, 0, nil)
}
}
if len(page.Template) > 0 && r.Reader.doc != nil {
@@ -237,36 +240,81 @@ func (r *Renderer) renderTemplate(ctx *canvas.Context, templateID string, pageH
}
if tplContent.Content.Layer != nil {
for _, layer := range tplContent.Content.Layer {
r.renderLayer(ctx, layer, pageH, nil, nil, 0)
r.renderLayer(ctx, layer, pageH, nil, nil, 0, nil)
}
}
}
// renderLayer 渲染图层
// 入参: ctx 画布上下文, layer 图层对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, defaultLW 默认线宽
func (r *Renderer) renderLayer(ctx *canvas.Context, layer Layer, pageH float64, defaultFill color.Color, defaultStroke color.Color, defaultLW float64) {
// 入参: ctx 画布上下文, layer 图层对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, defaultLW 默认线宽, parentCTM 父级CTM
func (r *Renderer) renderLayer(ctx *canvas.Context, layer Layer, pageH float64, defaultFill, defaultStroke color.Color, defaultLW float64, parentCTM *Matrix) {
if layer.DrawParam != "" {
if dp := r.getDrawParam(layer.DrawParam, nil); dp != nil {
if dp.LineWidth > 0 {
defaultLW = dp.LineWidth
}
if dp.FillColor != nil {
defaultFill = parseColor(dp.FillColor.Value)
defaultFill = parseColorWithAlpha(dp.FillColor.Value, dp.FillColor.Alpha)
}
if dp.StrokeColor != nil {
defaultStroke = parseColor(dp.StrokeColor.Value)
defaultStroke = parseColorWithAlpha(dp.StrokeColor.Value, dp.StrokeColor.Alpha)
}
}
}
for _, imgObj := range layer.ImageObject {
r.renderImage(ctx, imgObj, pageH)
for _, textObj := range layer.TextObject {
r.renderText(ctx, textObj, pageH, defaultFill, defaultStroke, parentCTM)
}
for _, pathObj := range layer.PathObject {
r.renderPath(ctx, pathObj, pageH, defaultFill, defaultStroke, defaultLW)
r.renderPath(ctx, pathObj, pageH, defaultFill, defaultStroke, defaultLW, parentCTM)
}
for _, textObj := range layer.TextObject {
r.renderText(ctx, textObj, pageH, defaultFill, defaultStroke)
for _, imgObj := range layer.ImageObject {
r.renderImage(ctx, imgObj, pageH, parentCTM)
}
for _, cgu := range layer.CompositeGraphicUnit {
r.renderCompositeGraphicUnit(ctx, cgu, pageH, defaultFill, defaultStroke, defaultLW, parentCTM)
}
}
// renderCompositeGraphicUnit 渲染复合图元
// 入参: ctx 画布上下文, cgu 复合图元对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, defaultLW 默认线宽, parentCTM 父级CTM
func (r *Renderer) renderCompositeGraphicUnit(ctx *canvas.Context, cgu CompositeGraphicUnit, pageH float64, defaultFill, defaultStroke color.Color, defaultLW float64, parentCTM *Matrix) {
ctx.Push()
currentCTM := NewMatrix(cgu.CTM)
if parentCTM != nil {
currentCTM = parentCTM.Multiply(currentCTM)
}
r.applyClips(ctx, cgu.Clips, pageH, &currentCTM)
if cgu.ResourceID != "" {
if ref, ok := r.CompositeGraphicUnits[cgu.ResourceID]; ok {
r.renderCompositeGraphicUnit(ctx, *ref, pageH, defaultFill, defaultStroke, defaultLW, &currentCTM)
}
}
if cgu.DrawParam != "" {
if dp := r.getDrawParam(cgu.DrawParam, nil); dp != nil {
if dp.LineWidth > 0 {
defaultLW = dp.LineWidth
}
if dp.FillColor != nil {
defaultFill = parseColorWithAlpha(dp.FillColor.Value, dp.FillColor.Alpha)
}
if dp.StrokeColor != nil {
defaultStroke = parseColorWithAlpha(dp.StrokeColor.Value, dp.StrokeColor.Alpha)
}
}
}
for _, imgObj := range cgu.ImageObject {
r.renderImage(ctx, imgObj, pageH, &currentCTM)
}
for _, pathObj := range cgu.PathObject {
r.renderPath(ctx, pathObj, pageH, defaultFill, defaultStroke, defaultLW, &currentCTM)
}
for _, textObj := range cgu.TextObject {
r.renderText(ctx, textObj, pageH, defaultFill, defaultStroke, &currentCTM)
}
for _, subCgu := range cgu.CompositeGraphicUnit {
r.renderCompositeGraphicUnit(ctx, subCgu, pageH, defaultFill, defaultStroke, defaultLW, &currentCTM)
}
ctx.Pop()
}
// getDrawParam 获取绘制参数逻辑
@@ -290,12 +338,37 @@ func (r *Renderer) getDrawParam(id string, visited map[string]bool) *DrawParam {
if dp.LineWidth > 0 {
merged.LineWidth = dp.LineWidth
}
if dp.Join != "" {
merged.Join = dp.Join
}
if dp.Cap != "" {
merged.Cap = dp.Cap
}
if dp.DashPattern != "" {
merged.DashPattern = dp.DashPattern
merged.DashOffset = dp.DashOffset
}
if dp.MiterLimit > 0 {
merged.MiterLimit = dp.MiterLimit
}
if dp.FillColor != nil {
merged.FillColor = dp.FillColor
}
if dp.StrokeColor != nil {
merged.StrokeColor = dp.StrokeColor
}
if dp.Font != "" {
merged.Font = dp.Font
}
if dp.Size > 0 {
merged.Size = dp.Size
}
if dp.Weight > 0 {
merged.Weight = dp.Weight
}
if dp.Italic {
merged.Italic = dp.Italic
}
return &merged
}
return dp
@@ -318,8 +391,8 @@ func (r *Renderer) initCommon() {
}
// renderImage 渲染图片
// 入参: ctx 画布上下文, obj 图片对象, pageH 页面高度
func (r *Renderer) renderImage(ctx *canvas.Context, obj ImageObject, pageH float64) {
// 入参: ctx 画布上下文, obj 图片对象, pageH 页面高度, parentCTM 父级CTM
func (r *Renderer) renderImage(ctx *canvas.Context, obj ImageObject, pageH float64, parentCTM *Matrix) {
resPath, ok := r.Reader.ResMap[obj.ResourceID]
if !ok {
return
@@ -342,9 +415,13 @@ func (r *Renderer) renderImage(ctx *canvas.Context, obj ImageObject, pageH float
if obj.CTM == "" {
ctm = Matrix{a: box.W, d: box.H}
}
if parentCTM != nil {
ctm = parentCTM.Multiply(ctm)
}
tx, ty := ctm.Transform(0, 1)
canvasX, canvasY := tx+box.X, pageH-(ty+box.Y)
ctx.Push()
r.applyClips(ctx, obj.Clips, pageH, &ctm)
ctx.Translate(canvasX, canvasY)
ctx.Scale(ctm.a/imgW, ctm.d/imgH)
ctx.DrawImage(0, 0, img, canvas.DPMM(1.0))
@@ -352,34 +429,47 @@ func (r *Renderer) renderImage(ctx *canvas.Context, obj ImageObject, pageH float
}
// renderPath 渲染路径
// 入参: ctx 画布上下文, obj 路径对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, defaultLW 默认线宽
func (r *Renderer) renderPath(ctx *canvas.Context, obj PathObject, pageH float64, defaultFill, defaultStroke color.Color, defaultLW float64) {
// 入参: ctx 画布上下文, obj 路径对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, defaultLW 默认线宽, parentCTM 父级CTM
func (r *Renderer) renderPath(ctx *canvas.Context, obj PathObject, pageH float64, defaultFill, defaultStroke color.Color, defaultLW float64, parentCTM *Matrix) {
ctx.Push()
bx, by := 0.0, 0.0
if obj.Boundary != "" {
if box, err := ParseBox(obj.Boundary); err == nil {
bx, by = box.X, box.Y
}
}
ctm := NewMatrix(obj.CTM)
fillColor, strokeColor := defaultFill, defaultStroke
if strokeColor == nil {
strokeColor = canvas.Black
if parentCTM != nil {
ctm = parentCTM.Multiply(ctm)
}
r.applyClips(ctx, obj.Clips, pageH, &ctm)
fillColor, strokeColor := defaultFill, defaultStroke
lineWidth := defaultLW
if lineWidth == 0 {
lineWidth = 0.353
}
lineCap := canvas.ButtCap
lineJoin := canvas.MiterJoin
dashOffset := 0.0
var dashPattern []float64
if obj.DrawParam != "" {
if dp := r.getDrawParam(obj.DrawParam, nil); dp != nil {
if dp.LineWidth > 0 {
lineWidth = dp.LineWidth
}
if dp.FillColor != nil {
fillColor = parseColor(dp.FillColor.Value)
fillColor = parseColorWithAlpha(dp.FillColor.Value, dp.FillColor.Alpha)
}
if dp.StrokeColor != nil {
strokeColor = parseColor(dp.StrokeColor.Value)
strokeColor = parseColorWithAlpha(dp.StrokeColor.Value, dp.StrokeColor.Alpha)
}
if dp.Cap == "Round" {
lineCap = canvas.RoundCap
} else if dp.Cap == "Square" {
lineCap = canvas.SquareCap
}
if dp.Join == "Round" {
lineJoin = canvas.RoundJoin
} else if dp.Join == "Bevel" {
lineJoin = canvas.BevelJoin
}
if dp.DashPattern != "" {
dashPattern = parseFloats(dp.DashPattern)
dashOffset = dp.DashOffset
}
}
}
@@ -387,64 +477,65 @@ func (r *Renderer) renderPath(ctx *canvas.Context, obj PathObject, pageH float64
lineWidth = obj.LineWidth
}
if obj.FillColor != nil {
fillColor = parseColor(obj.FillColor.Value)
fillColor = parseColorWithAlpha(obj.FillColor.Value, obj.FillColor.Alpha)
}
if obj.StrokeColor != nil {
strokeColor = parseColor(obj.StrokeColor.Value)
strokeColor = parseColorWithAlpha(obj.StrokeColor.Value, obj.StrokeColor.Alpha)
}
p := &canvas.Path{}
tokens := strings.Fields(obj.AbbreviatedData)
for i := 0; i < len(tokens); {
cmd := tokens[i]
i++
switch cmd {
case "M", "S":
if i+1 < len(tokens) {
x, _ := strconv.ParseFloat(tokens[i], 64)
y, _ := strconv.ParseFloat(tokens[i+1], 64)
tx, ty := ctm.Transform(x, y)
p.MoveTo(tx+bx, pageH-(ty+by))
i += 2
}
case "L":
if i+1 < len(tokens) {
x, _ := strconv.ParseFloat(tokens[i], 64)
y, _ := strconv.ParseFloat(tokens[i+1], 64)
tx, ty := ctm.Transform(x, y)
p.LineTo(tx+bx, pageH-(ty+by))
i += 2
}
case "B":
if i+5 < len(tokens) {
x1, _ := strconv.ParseFloat(tokens[i], 64)
y1, _ := strconv.ParseFloat(tokens[i+1], 64)
x2, _ := strconv.ParseFloat(tokens[i+2], 64)
y2, _ := strconv.ParseFloat(tokens[i+3], 64)
x3, _ := strconv.ParseFloat(tokens[i+4], 64)
y3, _ := strconv.ParseFloat(tokens[i+5], 64)
tx1, ty1 := ctm.Transform(x1, y1)
tx2, ty2 := ctm.Transform(x2, y2)
tx3, ty3 := ctm.Transform(x3, y3)
p.CubeTo(tx1+bx, pageH-(ty1+by), tx2+bx, pageH-(ty2+by), tx3+bx, pageH-(ty3+by))
i += 6
}
case "C":
p.Close()
if obj.Cap != "" {
if obj.Cap == "Round" {
lineCap = canvas.RoundCap
} else if obj.Cap == "Square" {
lineCap = canvas.SquareCap
} else {
lineCap = canvas.ButtCap
}
}
if fillColor != nil {
if obj.Join != "" {
if obj.Join == "Round" {
lineJoin = canvas.RoundJoin
} else if obj.Join == "Bevel" {
lineJoin = canvas.BevelJoin
} else {
lineJoin = canvas.MiterJoin
}
}
if obj.DashPattern != "" {
dashPattern = parseFloats(obj.DashPattern)
dashOffset = obj.DashOffset
}
p := r.buildPath(obj, pageH, ctm)
shouldFill := true
if obj.Fill != nil {
shouldFill = *obj.Fill
}
if shouldFill && fillColor != nil {
ctx.SetFillColor(fillColor)
ctx.DrawPath(0, 0, p)
}
ctx.SetStrokeColor(strokeColor)
ctx.SetStrokeWidth(lineWidth)
ctx.DrawPath(0, 0, p)
shouldStroke := true
if obj.Stroke != nil {
shouldStroke = *obj.Stroke
}
if shouldStroke {
if strokeColor == nil {
strokeColor = color.Transparent
}
ctx.SetStrokeColor(strokeColor)
ctx.SetStrokeWidth(lineWidth)
ctx.SetStrokeCapper(lineCap)
ctx.SetStrokeJoiner(lineJoin)
if len(dashPattern) > 0 {
ctx.SetDashes(dashOffset, dashPattern...)
}
ctx.DrawPath(0, 0, p)
}
ctx.Pop()
}
// renderText 渲染文本
// 入参: ctx 画布上下文, obj 文本对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色
func (r *Renderer) renderText(ctx *canvas.Context, obj TextObject, pageH float64, defaultFill, defaultStroke color.Color) {
// 入参: ctx 画布上下文, obj 文本对象, pageH 页面高度, defaultFill 默认填充色, defaultStroke 默认描边色, parentCTM 父级CTM
func (r *Renderer) renderText(ctx *canvas.Context, obj TextObject, pageH float64, defaultFill, defaultStroke color.Color, parentCTM *Matrix) {
ctx.Push()
bx, by := 0.0, 0.0
if obj.Boundary != "" {
@@ -453,34 +544,58 @@ func (r *Renderer) renderText(ctx *canvas.Context, obj TextObject, pageH float64
}
}
ctm := NewMatrix(obj.CTM)
if parentCTM != nil {
ctm = parentCTM.Multiply(ctm)
}
r.applyClips(ctx, obj.Clips, pageH, &ctm)
var dp *DrawParam
if obj.DrawParam != "" {
dp = r.getDrawParam(obj.DrawParam, nil)
}
sizeMM := obj.Size
if sizeMM == 0 && dp != nil && dp.Size > 0 {
sizeMM = dp.Size
}
if sizeMM == 0 {
sizeMM = 3.5
}
if obj.VScale != 0 {
sizeMM *= obj.VScale
}
if scale := ctm.YScale(); scale > 0 {
sizeMM *= scale
}
sizePt := sizeMM * 2.83465
textColor := defaultFill
if textColor == nil {
textColor = canvas.Black
fillColor := defaultFill
if fillColor == nil {
fillColor = canvas.Black
}
if obj.DrawParam != "" {
if dp := r.getDrawParam(obj.DrawParam, nil); dp != nil && dp.FillColor != nil {
textColor = parseColor(dp.FillColor.Value)
}
if dp != nil && dp.FillColor != nil {
fillColor = parseColorWithAlpha(dp.FillColor.Value, dp.FillColor.Alpha)
}
if obj.FillColor != nil {
textColor = parseColor(obj.FillColor.Value)
fillColor = parseColorWithAlpha(obj.FillColor.Value, obj.FillColor.Alpha)
}
fontStyle := canvas.FontRegular
if obj.Weight >= 700 {
weight := obj.Weight
if weight == 0 && dp != nil && dp.Weight > 0 {
weight = dp.Weight
}
if weight >= 700 {
fontStyle |= canvas.FontBold
}
if obj.Italic {
italic := obj.Italic
if !italic && dp != nil && dp.Italic {
italic = true
}
if italic {
fontStyle |= canvas.FontItalic
}
if of, ok := r.Reader.fontCache[obj.Font]; ok {
fontID := obj.Font
if fontID == "" && dp != nil && dp.Font != "" {
fontID = dp.Font
}
if of, ok := r.Reader.fontCache[fontID]; ok {
if of.Bold {
fontStyle |= canvas.FontBold
}
@@ -488,20 +603,41 @@ func (r *Renderer) renderText(ctx *canvas.Context, obj TextObject, pageH float64
fontStyle |= canvas.FontItalic
}
}
ff := r.loadFont(obj.Font)
face := ff.Face(sizePt, textColor, fontStyle, canvas.FontNormal)
ff := r.loadFont(fontID)
if ff == nil {
return
}
face := ff.Face(sizePt, fillColor, fontStyle, canvas.FontNormal)
for _, tc := range obj.TextCode {
runes := []rune(tc.Value)
var runes []rune
if tc.Index != "" {
runes = r.parseIndexRunes(tc.Index, fontID)
} else {
runes = []rune(tc.Value)
}
dxs, dys := parseFloats(tc.DeltaX), parseFloats(tc.DeltaY)
cx, cy := tc.X, tc.Y
xs, ys := parseFloats(tc.X), parseFloats(tc.Y)
cx, cy := 0.0, 0.0
if len(xs) > 0 {
cx = xs[0]
}
if len(ys) > 0 {
cy = ys[0]
}
for i, run := range runes {
str := string(run)
if i > 0 {
if i < len(xs) {
cx = xs[i]
} else if i > 0 {
if i-1 < len(dxs) {
cx += dxs[i-1]
} else {
} else if len(dys) == 0 {
cx += face.TextWidth(str)
}
}
if i < len(ys) {
cy = ys[i]
} else if i > 0 {
if i-1 < len(dys) {
cy += dys[i-1]
}
@@ -509,14 +645,14 @@ func (r *Renderer) renderText(ctx *canvas.Context, obj TextObject, pageH float64
tx, ty := ctm.Transform(cx, cy)
canvasX, canvasY := tx+bx, pageH-(ty+by)
text := canvas.NewTextLine(face, str, canvas.Left)
ctx.DrawText(canvasX, canvasY, text)
if fillColor != nil {
ctx.SetFillColor(fillColor)
ctx.DrawText(canvasX, canvasY, text)
}
if strings.Contains(obj.Decoration, "Underline") {
uw := sizeMM * 0.05
if uw < 0.05 {
uw = 0.05
}
ctx.SetStrokeWidth(uw)
ctx.SetStrokeColor(textColor)
ctx.SetStrokeColor(fillColor)
off := sizeMM * 0.1
ctx.MoveTo(canvasX, canvasY-off)
ctx.LineTo(canvasX+face.TextWidth(str), canvasY-off)
@@ -542,8 +678,18 @@ func (r *Renderer) loadFont(fontID string) *canvas.FontFamily {
ff := canvas.NewFontFamily(of.FontName)
if of.FontFile != "" {
if fontData, err := r.Reader.ResData(of.FontFile); err == nil {
if _, fixedData, err := FixFontData(fontData); err == nil {
if _, fixedData, mapping, _, err := FixFontDataAggressive(fontData, true, true); err == nil {
fontData = fixedData
if mapping != nil {
if r.FontGIDMap == nil {
r.FontGIDMap = make(map[string]map[uint16]rune)
}
inv := make(map[uint16]rune)
for k, v := range mapping {
inv[v] = k
}
r.FontGIDMap[fontID] = inv
}
}
var fontStyle canvas.FontStyle
if of.Bold {
@@ -556,7 +702,9 @@ func (r *Renderer) loadFont(fontID string) *canvas.FontFamily {
r.FontMap[fontID] = ff
return ff
}
return nil
}
return nil
}
var fontStyle canvas.FontStyle
if of.Bold {
@@ -593,15 +741,15 @@ func (r *Renderer) loadFont(fontID string) *canvas.FontFamily {
names := []string{of.FamilyName, of.FontName}
aliases := map[string]string{
"simhei": "SimHei",
"黑体": "SimHei",
"黑体": "SimHei",
"microsoft yahei": "Microsoft YaHei",
"微软雅黑": "Microsoft YaHei",
"微软雅黑": "Microsoft YaHei",
"simsun": "SimSun",
"宋体": "SimSun",
"宋体": "SimSun",
"kaiti": "KaiTi",
"楷体": "KaiTi",
"楷体": "KaiTi",
"fangsong": "FangSong",
"仿宋": "FangSong",
"仿宋": "FangSong",
"arial": "Arial",
"segoe ui": "Segoe UI",
"times new roman": "Times New Roman",
@@ -710,3 +858,138 @@ func (r *Renderer) renderStamp(ctx *canvas.Context, s Stamp, pageH float64) {
}
ctx.Pop()
}
// applyClips 应用裁剪
// 入参: ctx 画布上下文, clips 裁剪对象, pageH 页面高度, parentCTM 父级CTM
func (r *Renderer) applyClips(ctx *canvas.Context, clips *Clips, pageH float64, parentCTM *Matrix) {
if clips == nil {
return
}
for _, clip := range clips.Clip {
for _, area := range clip.Area {
for _, pathObj := range area.Path {
clipCTM := NewMatrix(pathObj.CTM)
if parentCTM != nil {
clipCTM = parentCTM.Multiply(clipCTM)
}
r.buildPath(pathObj, pageH, clipCTM)
}
}
}
}
// buildPath 解析路径并返回Canvas Path
// 入参: obj 路径对象, pageH 页面高度, ctm 变换矩阵
// 返回: *canvas.Path 路径对象
func (r *Renderer) buildPath(obj PathObject, pageH float64, ctm Matrix) *canvas.Path {
bx, by := 0.0, 0.0
if obj.Boundary != "" {
if box, err := ParseBox(obj.Boundary); err == nil {
bx, by = box.X, box.Y
}
}
p := &canvas.Path{}
tokens := strings.Fields(obj.AbbreviatedData)
for i := 0; i < len(tokens); {
cmd := tokens[i]
i++
switch cmd {
case "M", "S":
if i+1 < len(tokens) {
x, _ := strconv.ParseFloat(tokens[i], 64)
y, _ := strconv.ParseFloat(tokens[i+1], 64)
tx, ty := ctm.Transform(x, y)
p.MoveTo(tx+bx, pageH-(ty+by))
i += 2
}
case "L":
if i+1 < len(tokens) {
x, _ := strconv.ParseFloat(tokens[i], 64)
y, _ := strconv.ParseFloat(tokens[i+1], 64)
tx, ty := ctm.Transform(x, y)
p.LineTo(tx+bx, pageH-(ty+by))
i += 2
}
case "B":
if i+5 < len(tokens) {
x1, _ := strconv.ParseFloat(tokens[i], 64)
y1, _ := strconv.ParseFloat(tokens[i+1], 64)
x2, _ := strconv.ParseFloat(tokens[i+2], 64)
y2, _ := strconv.ParseFloat(tokens[i+3], 64)
x3, _ := strconv.ParseFloat(tokens[i+4], 64)
y3, _ := strconv.ParseFloat(tokens[i+5], 64)
tx1, ty1 := ctm.Transform(x1, y1)
tx2, ty2 := ctm.Transform(x2, y2)
tx3, ty3 := ctm.Transform(x3, y3)
p.CubeTo(tx1+bx, pageH-(ty1+by), tx2+bx, pageH-(ty2+by), tx3+bx, pageH-(ty3+by))
i += 6
}
case "Q":
if i+3 < len(tokens) {
x1, _ := strconv.ParseFloat(tokens[i], 64)
y1, _ := strconv.ParseFloat(tokens[i+1], 64)
x2, _ := strconv.ParseFloat(tokens[i+2], 64)
y2, _ := strconv.ParseFloat(tokens[i+3], 64)
tx1, ty1 := ctm.Transform(x1, y1)
tx2, ty2 := ctm.Transform(x2, y2)
p.QuadTo(tx1+bx, pageH-(ty1+by), tx2+bx, pageH-(ty2+by))
i += 4
}
case "A":
if i+6 < len(tokens) {
rx, _ := strconv.ParseFloat(tokens[i], 64)
ry, _ := strconv.ParseFloat(tokens[i+1], 64)
rot, _ := strconv.ParseFloat(tokens[i+2], 64)
large, _ := strconv.ParseBool(tokens[i+3])
sweep, _ := strconv.ParseBool(tokens[i+4])
x, _ := strconv.ParseFloat(tokens[i+5], 64)
y, _ := strconv.ParseFloat(tokens[i+6], 64)
sx := math.Hypot(ctm.a, ctm.c)
sy := math.Hypot(ctm.b, ctm.d)
ctmRot := math.Atan2(ctm.b, ctm.a) * 180 / math.Pi
tx, ty := ctm.Transform(x, y)
sweep = !sweep
p.ArcTo(rx*sx, ry*sy, -(rot + ctmRot), large, sweep, tx+bx, pageH-(ty+by))
i += 7
}
case "C":
p.Close()
}
}
return p
}
// parseIndexRunes 解析索引字形
// 入参: indexStr 索引字符串, fontID 字体ID
// 返回: []rune 字形列表
func (r *Renderer) parseIndexRunes(indexStr string, fontID string) []rune {
var gids []int
parts := strings.Fields(indexStr)
for _, p := range parts {
if strings.Contains(p, "-") {
sub := strings.Split(p, "-")
if len(sub) == 2 {
start, _ := strconv.Atoi(sub[0])
end, _ := strconv.Atoi(sub[1])
for k := start; k <= end; k++ {
gids = append(gids, k)
}
}
} else {
val, _ := strconv.Atoi(p)
gids = append(gids, val)
}
}
mapping := r.FontGIDMap[fontID]
var res []rune
for _, gid := range gids {
if mapping != nil {
if rVal, ok := mapping[uint16(gid)]; ok {
res = append(res, rVal)
continue
}
}
res = append(res, rune(gid))
}
return res
}
ofdgo_res.go
+22 -3
View File
@@ -68,7 +68,17 @@ type DrawParam struct {
Relative string `xml:"Relative,attr"`
ResourceID string `xml:"ResourceID,attr"`
BaseLoc string `xml:"BaseLoc,attr"`
Link string `xml:"Link,attr"`
LineWidth float64 `xml:"LineWidth,attr"`
Join string `xml:"Join,attr"`
Cap string `xml:"Cap,attr"`
DashOffset float64 `xml:"DashOffset,attr"`
DashPattern string `xml:"DashPattern,attr"`
MiterLimit float64 `xml:"MiterLimit,attr"`
Font string `xml:"Font,attr"`
Size float64 `xml:"Size,attr"`
Weight int `xml:"Weight,attr"`
Italic bool `xml:"Italic,attr"`
FillColor *FillColor `xml:"FillColor"`
StrokeColor *StrokeColor `xml:"StrokeColor"`
}
@@ -80,7 +90,16 @@ type CompositeGraphicUnits struct {
// CompositeGraphicUnit 复合图元
type CompositeGraphicUnit struct {
ID string `xml:"ID,attr"`
BaseLoc string `xml:"BaseLoc,attr"`
ResourceID string `xml:"ResourceID,attr"`
ID string `xml:"ID,attr"`
BaseLoc string `xml:"BaseLoc,attr"`
ResourceID string `xml:"ResourceID,attr"`
Boundary string `xml:"Boundary,attr"`
CTM string `xml:"CTM,attr"`
DrawParam string `xml:"DrawParam,attr"`
Alpha *int `xml:"Alpha,attr"`
TextObject []TextObject `xml:"TextObject"`
PathObject []PathObject `xml:"PathObject"`
ImageObject []ImageObject `xml:"ImageObject"`
CompositeGraphicUnit []CompositeGraphicUnit `xml:"CompositeGraphicUnit"`
Clips *Clips `xml:"Clips"`
}
ofdgo_text.go
+10 -1
View File
@@ -24,12 +24,21 @@ import (
// 入参: val 颜色值(R G B)
// 返回: color.Color 颜色对象
func parseColor(val string) color.Color {
return parseColorWithAlpha(val, nil)
}
// parseColorWithAlpha 解析带透明度的颜色
func parseColorWithAlpha(val string, alpha *int) color.Color {
parts := strings.Fields(val)
if len(parts) >= 3 {
r, _ := strconv.Atoi(parts[0])
g, _ := strconv.Atoi(parts[1])
b, _ := strconv.Atoi(parts[2])
return color.RGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: 255}
a := 255
if alpha != nil {
a = *alpha
}
return color.RGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: uint8(a)}
}
return color.Black
}