887 lines
22 KiB
Go
887 lines
22 KiB
Go
package font2img
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/xml"
|
||
"errors"
|
||
"fmt"
|
||
"image"
|
||
"image/color"
|
||
"image/draw"
|
||
"os"
|
||
"strings"
|
||
"sync"
|
||
"unicode"
|
||
|
||
"github.com/golang/freetype"
|
||
"github.com/golang/freetype/truetype"
|
||
"github.com/srwiley/oksvg"
|
||
"github.com/srwiley/rasterx"
|
||
"golang.org/x/image/font"
|
||
"golang.org/x/image/math/fixed"
|
||
|
||
_ "embed"
|
||
)
|
||
|
||
//go:embed NotoEmoji-VariableFont_wght.svg
|
||
var svgEmojiBytes []byte
|
||
|
||
//go:embed fusion-pixel-12px-monospaced.ttf
|
||
var ttfBytes []byte
|
||
|
||
// 全局emoji字体和相关变量
|
||
var (
|
||
svgEmojiPath string
|
||
svgEmojiLock sync.RWMutex
|
||
|
||
// 添加SVG缓存，避免重复解析相同的SVG文件
|
||
svgCache map[rune][]byte
|
||
svgCacheLock sync.RWMutex
|
||
|
||
// 保存已加载的SVG字体文件
|
||
svgFontData []byte
|
||
svgFontLock sync.RWMutex
|
||
svgFontCache *SVG
|
||
)
|
||
|
||
func init() {
|
||
// 初始化SVG缓存
|
||
svgCache = make(map[rune][]byte)
|
||
|
||
// 初始化嵌入的SVG字体
|
||
var svg SVG
|
||
if err := xml.Unmarshal(svgEmojiBytes, &svg); err == nil {
|
||
svgFontLock.Lock()
|
||
svgFontData = svgEmojiBytes
|
||
svgFontCache = &svg
|
||
svgFontLock.Unlock()
|
||
}
|
||
}
|
||
|
||
// SVG表示一个简单的SVG解析结构
|
||
type SVG struct {
|
||
Width int `xml:"width,attr"`
|
||
Height int `xml:"height,attr"`
|
||
ViewBox string `xml:"viewBox,attr"`
|
||
Defs struct {
|
||
Font struct {
|
||
Glyphs []struct {
|
||
GlyphName string `xml:"glyph-name,attr"`
|
||
Unicode string `xml:"unicode,attr"`
|
||
VertAdvY string `xml:"vert-adv-y,attr"`
|
||
Path string `xml:"d,attr"`
|
||
} `xml:"glyph"`
|
||
} `xml:"font"`
|
||
} `xml:"defs"`
|
||
}
|
||
|
||
// SetSVGEmojiPath 设置SVG格式emoji的字体文件路径
|
||
func SetSVGEmojiPath(path string) error {
|
||
// 检查文件是否存在
|
||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||
return errors.New("SVG emoji字体文件不存在")
|
||
}
|
||
|
||
svgEmojiLock.Lock()
|
||
defer svgEmojiLock.Unlock()
|
||
|
||
// 清除之前的缓存
|
||
svgFontLock.Lock()
|
||
svgFontData = nil
|
||
svgFontCache = nil
|
||
svgFontLock.Unlock()
|
||
|
||
svgCacheLock.Lock()
|
||
svgCache = make(map[rune][]byte)
|
||
svgCacheLock.Unlock()
|
||
|
||
svgEmojiPath = path
|
||
return nil
|
||
}
|
||
|
||
// loadSVGEmoji 加载特定码点的SVG Emoji
|
||
func loadSVGEmoji(codePoint rune) ([]byte, error) {
|
||
// 先从缓存中查找
|
||
svgCacheLock.RLock()
|
||
if data, ok := svgCache[codePoint]; ok {
|
||
svgCacheLock.RUnlock()
|
||
return data, nil
|
||
}
|
||
svgCacheLock.RUnlock()
|
||
|
||
// 缓存中没有，从SVG字体文件加载
|
||
svgFontLock.RLock()
|
||
fontData := svgFontData
|
||
fontCache := svgFontCache
|
||
svgFontLock.RUnlock()
|
||
|
||
// 如果没有字体数据，且有指定路径，则从文件加载
|
||
if len(fontData) == 0 {
|
||
svgEmojiLock.RLock()
|
||
path := svgEmojiPath
|
||
svgEmojiLock.RUnlock()
|
||
|
||
if path != "" {
|
||
// 读取SVG字体文件
|
||
var err error
|
||
fontData, err = os.ReadFile(path)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 解析SVG字体
|
||
var svg SVG
|
||
if err := xml.Unmarshal(fontData, &svg); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 保存到缓存
|
||
svgFontLock.Lock()
|
||
svgFontData = fontData
|
||
svgFontCache = &svg
|
||
fontCache = &svg
|
||
svgFontLock.Unlock()
|
||
} else {
|
||
// 没有外部路径，直接使用嵌入的字体数据
|
||
fontData = svgEmojiBytes
|
||
|
||
// 如果未初始化，则解析嵌入的字体
|
||
if fontCache == nil {
|
||
var svg SVG
|
||
if err := xml.Unmarshal(fontData, &svg); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
svgFontLock.Lock()
|
||
svgFontCache = &svg
|
||
fontCache = &svg
|
||
svgFontLock.Unlock()
|
||
}
|
||
}
|
||
}
|
||
|
||
// 在字体中查找匹配的字形
|
||
targetChar := string(codePoint)
|
||
|
||
if fontCache != nil {
|
||
for _, glyph := range fontCache.Defs.Font.Glyphs {
|
||
if glyph.Unicode == targetChar {
|
||
// 创建包含该字形的SVG数据
|
||
glyphSVG := createGlyphSVG(glyph, fontCache)
|
||
|
||
// 添加到缓存
|
||
svgCacheLock.Lock()
|
||
svgCache[codePoint] = []byte(glyphSVG)
|
||
svgCacheLock.Unlock()
|
||
|
||
return []byte(glyphSVG), nil
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil, errors.New("未找到匹配的SVG字形")
|
||
}
|
||
|
||
// createGlyphSVG 从字形数据创建独立的SVG
|
||
func createGlyphSVG(glyph struct {
|
||
GlyphName string `xml:"glyph-name,attr"`
|
||
Unicode string `xml:"unicode,attr"`
|
||
VertAdvY string `xml:"vert-adv-y,attr"`
|
||
Path string `xml:"d,attr"`
|
||
}, fontInfo *SVG) string {
|
||
// 获取视口尺寸
|
||
viewBox := fontInfo.ViewBox
|
||
if viewBox == "" {
|
||
viewBox = "0 0 1000 1000" // 默认视口
|
||
}
|
||
|
||
// 创建独立的SVG标记
|
||
svgTemplate := `<svg xmlns="http://www.w3.org/2000/svg" viewBox="%s">
|
||
<path d="%s" fill="currentColor"/>
|
||
</svg>`
|
||
|
||
return fmt.Sprintf(svgTemplate, viewBox, glyph.Path)
|
||
}
|
||
|
||
// renderSVGEmojiToImage 将SVG转换为图像
|
||
func renderSVGEmojiToImage(svgData []byte, size float64, col color.Color) (*image.RGBA, error) {
|
||
// 解析SVG以获取尺寸信息
|
||
var svg SVG
|
||
if err := xml.Unmarshal(svgData, &svg); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 准备输入数据
|
||
r, g, b, _ := col.RGBA()
|
||
hexColor := rgbaToHex(uint8(r>>8), uint8(g>>8), uint8(b>>8))
|
||
|
||
// 替换currentColor为指定的颜色
|
||
svgStr := string(svgData)
|
||
svgStr = strings.ReplaceAll(svgStr, "currentColor", hexColor)
|
||
|
||
// 创建输出图像
|
||
imgSize := int(size)
|
||
if imgSize < 10 {
|
||
imgSize = 10
|
||
}
|
||
|
||
// 创建一个透明背景的RGBA图像
|
||
rgba := image.NewRGBA(image.Rect(0, 0, imgSize, imgSize))
|
||
draw.Draw(rgba, rgba.Bounds(), image.Transparent, image.Point{}, draw.Src)
|
||
|
||
// 直接渲染SVG数据到图像
|
||
err := renderSVGDataToImage([]byte(svgStr), rgba)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return rgba, nil
|
||
}
|
||
|
||
// renderSVGDataToImage 使用oksvg库渲染SVG数据到图像
|
||
func renderSVGDataToImage(svgData []byte, dst *image.RGBA) error {
|
||
// 从字节数据创建SVG图标
|
||
icon, err := oksvg.ReadIconStream(bytes.NewReader(svgData), oksvg.StrictErrorMode)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 设置图标大小适应目标图像
|
||
bounds := dst.Bounds()
|
||
width, height := float64(bounds.Dx()), float64(bounds.Dy())
|
||
|
||
// 创建转换后的图像（先渲染到这里，然后再处理翻转）
|
||
tempImg := image.NewRGBA(image.Rect(0, 0, bounds.Dx(), bounds.Dy()))
|
||
|
||
// 适应目标大小
|
||
icon.SetTarget(0, width/8, width/2.7, height/2.7)
|
||
|
||
// 创建光栅化器
|
||
scanner := rasterx.NewScannerGV(bounds.Dx(), bounds.Dy(), tempImg, tempImg.Bounds())
|
||
raster := rasterx.NewDasher(bounds.Dx(), bounds.Dy(), scanner)
|
||
|
||
// 渲染图标
|
||
icon.Draw(raster, 1.0)
|
||
|
||
// 只垂直翻转图像（处理上下颠倒问题）
|
||
for y := 0; y < bounds.Dy(); y++ {
|
||
for x := 0; x < bounds.Dx(); x++ {
|
||
// 计算垂直翻转后的坐标
|
||
flippedY := bounds.Dy() - y - 1
|
||
|
||
// 将翻转后的像素复制到目标图像
|
||
dst.Set(x, y, tempImg.At(x, flippedY))
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// rgbaToHex 将RGB颜色分量转换为十六进制字符串
|
||
func rgbaToHex(r, g, b uint8) string {
|
||
return "#" + colorToHex(r) + colorToHex(g) + colorToHex(b)
|
||
}
|
||
|
||
// colorToHex 将单个颜色分量转换为十六进制
|
||
func colorToHex(c uint8) string {
|
||
hex := "0123456789ABCDEF"
|
||
return string(hex[c>>4]) + string(hex[c&0x0F])
|
||
}
|
||
|
||
// IsEmoji 检测一个字符是否是emoji
|
||
func IsEmoji(r rune) bool {
|
||
// 简单检测一些常见的emoji范围
|
||
return unicode.Is(unicode.So, r) || // Symbol, Other
|
||
// 表情符号范围
|
||
(r >= 0x1F600 && r <= 0x1F64F) || // Emoticons
|
||
(r >= 0x1F300 && r <= 0x1F5FF) || // Misc Symbols and Pictographs
|
||
(r >= 0x1F680 && r <= 0x1F6FF) || // Transport and Map
|
||
(r >= 0x1F700 && r <= 0x1F77F) || // Alchemical Symbols
|
||
(r >= 0x1F780 && r <= 0x1F7FF) || // Geometric Shapes
|
||
(r >= 0x1F800 && r <= 0x1F8FF) || // Supplemental Arrows-C
|
||
(r >= 0x1F900 && r <= 0x1F9FF) || // Supplemental Symbols and Pictographs
|
||
(r >= 0x1FA00 && r <= 0x1FA6F) || // Chess Symbols
|
||
(r >= 0x1FA70 && r <= 0x1FAFF) || // Symbols and Pictographs Extended-A
|
||
// 国旗符号
|
||
(r >= 0x1F1E6 && r <= 0x1F1FF)
|
||
}
|
||
|
||
// HasGlyph 检查字体是否包含该字符的字形
|
||
func HasGlyph(fontContent *truetype.Font, char rune) bool {
|
||
if fontContent == nil {
|
||
return false
|
||
}
|
||
// 尝试获取字符索引
|
||
index := fontContent.Index(char)
|
||
return index != 0 // 索引0通常是notdef字形
|
||
}
|
||
|
||
// SafeGlyphAdvance 安全获取字符宽度，避免崩溃
|
||
func SafeGlyphAdvance(face font.Face, char rune) (fixed.Int26_6, bool) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
// 发生panic，忽略
|
||
}
|
||
}()
|
||
|
||
return face.GlyphAdvance(char)
|
||
}
|
||
|
||
// SafeGlyphBounds 安全获取字符边界，避免崩溃
|
||
func SafeGlyphBounds(face font.Face, char rune) (fixed.Rectangle26_6, fixed.Int26_6, bool) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
// 发生panic，忽略
|
||
}
|
||
}()
|
||
|
||
return face.GlyphBounds(char)
|
||
}
|
||
|
||
// SafeDrawString 安全绘制字符串，避免崩溃
|
||
func SafeDrawString(ctx *freetype.Context, text string, pt fixed.Point26_6) (fixed.Point26_6, error) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
// 发生panic，忽略
|
||
}
|
||
}()
|
||
|
||
return ctx.DrawString(text, pt)
|
||
}
|
||
|
||
// ParseFont 解析字体文件或使用内嵌字体
|
||
func ParseFont(fontPath string) (*truetype.Font, error) {
|
||
// 如果提供了路径，尝试从文件加载
|
||
if fontPath != "" {
|
||
fontBytes, err := os.ReadFile(fontPath)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
fontCache, err := truetype.Parse(fontBytes)
|
||
return fontCache, err
|
||
}
|
||
|
||
// 没有提供路径，使用嵌入的TTF字体
|
||
fontCache, err := truetype.Parse(ttfBytes)
|
||
return fontCache, err
|
||
}
|
||
|
||
// RenderCharToImage 将单个字符渲染为图像
|
||
// fontSize: 字体大小（点数）
|
||
// textColor: 字体颜色
|
||
// 返回字符的图像
|
||
func RenderCharToImage(fontContent *truetype.Font, char rune, fontSize float64, textColor color.Color) (*image.RGBA, error) {
|
||
// 确保字体已加载
|
||
if fontContent == nil {
|
||
// 尝试使用嵌入的字体
|
||
var err error
|
||
fontContent, err = truetype.Parse(ttfBytes)
|
||
if err != nil {
|
||
return nil, ErrFontNotLoaded
|
||
}
|
||
}
|
||
|
||
// 检查是否是emoji，且应该使用SVG格式
|
||
if IsEmoji(char) {
|
||
// 尝试加载SVG emoji
|
||
svgData, err := loadSVGEmoji(char)
|
||
if err == nil {
|
||
// 成功加载SVG，渲染为图像
|
||
return renderSVGEmojiToImage(svgData, fontSize, textColor)
|
||
}
|
||
// 如果加载失败，回退到使用普通emoji字体
|
||
return createPlaceholderImage(fontSize, textColor), nil
|
||
}
|
||
|
||
// 创建字体上下文
|
||
c := freetype.NewContext()
|
||
c.SetDPI(72) // 标准DPI
|
||
c.SetFont(fontContent)
|
||
c.SetFontSize(fontSize)
|
||
c.SetHinting(font.HintingFull)
|
||
|
||
// 计算字符尺寸
|
||
opts := truetype.Options{
|
||
Size: fontSize,
|
||
DPI: 72,
|
||
Hinting: font.HintingFull,
|
||
}
|
||
face := truetype.NewFace(fontContent, &opts)
|
||
|
||
// 测量单个字符宽度
|
||
charWidth, ok := SafeGlyphAdvance(face, char)
|
||
if !ok {
|
||
// 无法获取字符宽度，使用替代图像
|
||
return createPlaceholderImage(fontSize, textColor), nil
|
||
}
|
||
widthInPixels := charWidth.Ceil()
|
||
if widthInPixels <= 0 {
|
||
widthInPixels = int(fontSize / 2)
|
||
}
|
||
|
||
// 计算字体高度和基线位置
|
||
bounds, _, ok := SafeGlyphBounds(face, char)
|
||
if !ok {
|
||
// 无法获取字符边界，使用替代图像
|
||
return createPlaceholderImage(fontSize, textColor), nil
|
||
}
|
||
height := (bounds.Max.Y - bounds.Min.Y).Ceil()
|
||
if height <= 0 {
|
||
height = int(fontSize)
|
||
}
|
||
|
||
// 添加少量额外空间确保字符完全显示
|
||
heightInPixels := height + int(fontSize/8)
|
||
|
||
// 创建图像，确保有足够空间
|
||
rgba := image.NewRGBA(image.Rect(0, 0, widthInPixels, heightInPixels))
|
||
draw.Draw(rgba, rgba.Bounds(), image.Transparent, image.Point{}, draw.Src)
|
||
|
||
// 设置绘图属性
|
||
c.SetDst(rgba)
|
||
c.SetClip(rgba.Bounds())
|
||
c.SetSrc(image.NewUniform(textColor))
|
||
|
||
// 计算正确的基线位置
|
||
// 基线应该在字符下降部分的上方
|
||
baseline := (-bounds.Min.Y).Ceil()
|
||
|
||
// 绘制字符，Y坐标需要考虑一个偏移以确保完整显示
|
||
pt := fixed.Point26_6{
|
||
X: fixed.Int26_6(0 << 6),
|
||
Y: fixed.Int26_6(baseline << 6),
|
||
}
|
||
_, err := SafeDrawString(c, string(char), pt)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 裁剪图像，去除多余的空白
|
||
trimmedRGBA := trimImage(rgba)
|
||
return trimmedRGBA, nil
|
||
}
|
||
|
||
// trimImage 裁剪图像，去除底部、顶部、左侧和右侧的空白
|
||
func trimImage(img *image.RGBA) *image.RGBA {
|
||
bounds := img.Bounds()
|
||
min, max := bounds.Min, bounds.Max
|
||
|
||
// 找到字符的实际底部（最后一个非透明像素的行）
|
||
bottom := min.Y
|
||
for y := max.Y - 1; y >= min.Y; y-- {
|
||
isEmpty := true
|
||
for x := min.X; x < max.X; x++ {
|
||
_, _, _, a := img.At(x, y).RGBA()
|
||
if a > 0 {
|
||
isEmpty = false
|
||
break
|
||
}
|
||
}
|
||
if !isEmpty {
|
||
bottom = y + 1 // 找到最后一个非空行
|
||
break
|
||
}
|
||
}
|
||
|
||
// 找到字符的实际顶部（第一个非透明像素的行）
|
||
top := max.Y - 1
|
||
for y := min.Y; y < max.Y; y++ {
|
||
isEmpty := true
|
||
for x := min.X; x < max.X; x++ {
|
||
_, _, _, a := img.At(x, y).RGBA()
|
||
if a > 0 {
|
||
isEmpty = false
|
||
break
|
||
}
|
||
}
|
||
if !isEmpty {
|
||
top = y // 找到第一个非空行
|
||
break
|
||
}
|
||
}
|
||
|
||
// 找到字符的实际左侧边缘（第一个非透明像素的列）
|
||
left := max.X - 1
|
||
for x := min.X; x < max.X; x++ {
|
||
isEmpty := true
|
||
for y := min.Y; y < max.Y; y++ {
|
||
_, _, _, a := img.At(x, y).RGBA()
|
||
if a > 0 {
|
||
isEmpty = false
|
||
break
|
||
}
|
||
}
|
||
if !isEmpty {
|
||
left = x // 找到第一个非空列
|
||
break
|
||
}
|
||
}
|
||
|
||
// 找到字符的实际右侧边缘（最后一个非透明像素的列）
|
||
right := min.X
|
||
for x := max.X - 1; x >= min.X; x-- {
|
||
isEmpty := true
|
||
for y := min.Y; y < max.Y; y++ {
|
||
_, _, _, a := img.At(x, y).RGBA()
|
||
if a > 0 {
|
||
isEmpty = false
|
||
break
|
||
}
|
||
}
|
||
if !isEmpty {
|
||
right = x + 1 // 找到最后一个非空列
|
||
break
|
||
}
|
||
}
|
||
|
||
// 防止空图像情况
|
||
if top >= bottom || left >= right {
|
||
return img // 返回原图
|
||
}
|
||
|
||
// 创建新图像并复制内容
|
||
newWidth := right - left
|
||
newHeight := bottom - top
|
||
newImg := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
|
||
for y := 0; y < newHeight; y++ {
|
||
for x := 0; x < newWidth; x++ {
|
||
newImg.Set(x, y, img.At(x+left, y+top))
|
||
}
|
||
}
|
||
|
||
return newImg
|
||
}
|
||
|
||
// RenderTextToImage 将一段文本渲染为图像
|
||
// text: 要渲染的文本，支持换行符
|
||
// fontSize: 字体大小（点数）
|
||
// textColor: 字体颜色
|
||
// charSpacing: 字符间距（像素）
|
||
// lineSpacing: 行间距（像素）
|
||
// 返回渲染后的图像
|
||
func RenderTextToImage(fontContent *truetype.Font, text string, fontSize float64, textColor color.Color, charSpacing, lineSpacing int) (*image.RGBA, error) {
|
||
// 确保字体已加载
|
||
if fontContent == nil {
|
||
// 尝试使用嵌入的字体
|
||
var err error
|
||
fontContent, err = truetype.Parse(ttfBytes)
|
||
if err != nil {
|
||
return nil, ErrFontNotLoaded
|
||
}
|
||
}
|
||
|
||
// 检查是否有SVG emoji数据
|
||
hasSVGData := false
|
||
svgFontLock.RLock()
|
||
hasSVGData = svgFontCache != nil
|
||
svgFontLock.RUnlock()
|
||
|
||
// 首先需要计算整个文本的尺寸
|
||
lines := splitTextIntoLines(text)
|
||
if len(lines) == 0 {
|
||
return image.NewRGBA(image.Rect(0, 0, 1, 1)), nil // 返回1x1空图像
|
||
}
|
||
|
||
// 创建字体配置
|
||
opts := truetype.Options{
|
||
Size: fontSize,
|
||
DPI: 72,
|
||
Hinting: font.HintingFull,
|
||
}
|
||
face := truetype.NewFace(fontContent, &opts)
|
||
|
||
// 计算每行的宽度和整体高度
|
||
var maxWidth int
|
||
lineHeights := make([]int, len(lines))
|
||
lineBounds := make([]fixed.Rectangle26_6, len(lines))
|
||
|
||
for i, line := range lines {
|
||
var lineWidth int
|
||
// 计算一行的宽度
|
||
for _, char := range line {
|
||
// 决定使用哪个字体
|
||
currentFace := face
|
||
|
||
// 处理SVG emoji
|
||
if hasSVGData && IsEmoji(char) {
|
||
// 对于SVG emoji，使用固定宽度
|
||
lineWidth += int(fontSize) + charSpacing
|
||
continue
|
||
}
|
||
|
||
advance, ok := SafeGlyphAdvance(currentFace, char)
|
||
if !ok {
|
||
// 如果无法获取宽度，使用默认宽度
|
||
lineWidth += int(fontSize/2) + charSpacing
|
||
continue
|
||
}
|
||
lineWidth += advance.Ceil() + charSpacing
|
||
}
|
||
|
||
// 如果一行有字符，减去最后一个字符后多加的间距
|
||
if len(line) > 0 {
|
||
lineWidth -= charSpacing
|
||
}
|
||
|
||
// 计算行的边界，用于高度计算
|
||
lineBound := fixed.Rectangle26_6{
|
||
Min: fixed.Point26_6{X: 0, Y: fixed.Int26_6(-int(fontSize) << 6)},
|
||
Max: fixed.Point26_6{X: 0, Y: fixed.Int26_6(int(fontSize) << 6)},
|
||
}
|
||
|
||
for _, char := range line {
|
||
// 如果是SVG emoji，跳过边界计算
|
||
if hasSVGData && IsEmoji(char) {
|
||
continue
|
||
}
|
||
|
||
// 决定使用哪个字体
|
||
currentFace := face
|
||
|
||
bound, _, ok := SafeGlyphBounds(currentFace, char)
|
||
if !ok {
|
||
continue
|
||
}
|
||
if bound.Min.Y < lineBound.Min.Y {
|
||
lineBound.Min.Y = bound.Min.Y
|
||
}
|
||
if bound.Max.Y > lineBound.Max.Y {
|
||
lineBound.Max.Y = bound.Max.Y
|
||
}
|
||
}
|
||
|
||
lineBounds[i] = lineBound
|
||
lineHeight := int(fontSize)
|
||
lineHeights[i] = lineHeight
|
||
|
||
if lineWidth > maxWidth {
|
||
maxWidth = lineWidth
|
||
}
|
||
}
|
||
|
||
// 防止创建太小的图像
|
||
if maxWidth <= 0 {
|
||
maxWidth = int(fontSize)
|
||
}
|
||
|
||
// 计算总高度（每行高度+行间距）
|
||
totalHeight := 0
|
||
for _, height := range lineHeights {
|
||
totalHeight += height + lineSpacing + 1
|
||
}
|
||
// 减去最后一行多加的行间距
|
||
if len(lineHeights) > 0 {
|
||
totalHeight -= lineSpacing
|
||
}
|
||
|
||
// 防止创建太小的图像
|
||
if totalHeight <= 0 {
|
||
totalHeight = int(fontSize)
|
||
}
|
||
|
||
// 创建图像
|
||
rgba := image.NewRGBA(image.Rect(0, 0, maxWidth, totalHeight))
|
||
draw.Draw(rgba, rgba.Bounds(), image.Transparent, image.Point{}, draw.Src)
|
||
|
||
// 设置字体上下文
|
||
c := freetype.NewContext()
|
||
c.SetDPI(72)
|
||
c.SetFontSize(fontSize)
|
||
c.SetHinting(font.HintingFull)
|
||
c.SetDst(rgba)
|
||
c.SetClip(rgba.Bounds())
|
||
c.SetSrc(image.NewUniform(textColor))
|
||
|
||
// 渲染每一行文本
|
||
y := 0
|
||
for i, line := range lines {
|
||
if len(line) == 0 {
|
||
y += lineHeights[i] + lineSpacing
|
||
continue
|
||
}
|
||
|
||
// 计算基线位置
|
||
baseline := y + (-lineBounds[i].Min.Y).Ceil()
|
||
|
||
// 绘制每个字符
|
||
x := 0
|
||
for _, char := range line {
|
||
// 如果是SVG格式的emoji，单独处理
|
||
if hasSVGData && IsEmoji(char) {
|
||
svgData, err := loadSVGEmoji(char)
|
||
if err == nil {
|
||
// 渲染SVG emoji
|
||
emojiImg, err := renderSVGEmojiToImage(svgData, fontSize, textColor)
|
||
if err == nil {
|
||
emojiBounds := emojiImg.Bounds()
|
||
draw.Draw(rgba,
|
||
image.Rect(x, baseline-int(fontSize), x+emojiBounds.Dx(), baseline),
|
||
emojiImg,
|
||
image.Point{},
|
||
draw.Over)
|
||
x += emojiBounds.Dx() + charSpacing
|
||
continue
|
||
}
|
||
}
|
||
// 如果加载或渲染SVG失败，回退到使用普通方式
|
||
}
|
||
|
||
// 决定使用哪个字体
|
||
currentFont := fontContent
|
||
currentFace := face
|
||
useCurrentFont := true
|
||
|
||
if useCurrentFont {
|
||
// 设置当前字符的字体
|
||
c.SetFont(currentFont)
|
||
|
||
// 绘制字符
|
||
pt := fixed.Point26_6{
|
||
X: fixed.Int26_6(x << 6),
|
||
Y: fixed.Int26_6(baseline << 6),
|
||
}
|
||
|
||
width, ok := SafeGlyphAdvance(currentFace, char)
|
||
if !ok {
|
||
// 无法获取宽度，使用默认宽度
|
||
x += int(fontSize/2) + charSpacing
|
||
continue
|
||
}
|
||
|
||
_, err := SafeDrawString(c, string(char), pt)
|
||
if err != nil {
|
||
// 绘制失败，使用替代方法
|
||
drawPlaceholder(rgba, x, baseline, int(fontSize), textColor)
|
||
x += int(fontSize/2) + charSpacing
|
||
continue
|
||
}
|
||
|
||
// 移动到下一个字符位置
|
||
x += width.Ceil() + charSpacing
|
||
} else {
|
||
// 不能使用当前字体，绘制占位符
|
||
drawPlaceholder(rgba, x, baseline, int(fontSize/2), textColor)
|
||
x += int(fontSize/2) + charSpacing
|
||
}
|
||
}
|
||
|
||
// 移动到下一行
|
||
y += lineHeights[i] + lineSpacing
|
||
}
|
||
|
||
return rgba, nil
|
||
}
|
||
|
||
// RenderTextToTrimmedImage 将一段文本渲染为图像并裁剪多余空白
|
||
// 与RenderTextToImage功能相同，但会自动裁剪图像边缘的空白
|
||
func RenderTextToTrimmedImage(fontContent *truetype.Font, text string, fontSize float64, textColor color.Color, charSpacing, lineSpacing int) (*image.RGBA, error) {
|
||
// 如果字体为nil，尝试使用嵌入的字体
|
||
if fontContent == nil {
|
||
var err error
|
||
fontContent, err = truetype.Parse(ttfBytes)
|
||
if err != nil {
|
||
return nil, ErrFontNotLoaded
|
||
}
|
||
}
|
||
|
||
img, err := RenderTextToImage(fontContent, text, fontSize, textColor, charSpacing, lineSpacing)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 裁剪图像四周的空白
|
||
return trimImage(img), nil
|
||
}
|
||
|
||
// splitTextIntoLines 将文本按换行符分割成行
|
||
func splitTextIntoLines(text string) [][]rune {
|
||
lines := [][]rune{}
|
||
currentLine := []rune{}
|
||
|
||
for _, char := range text {
|
||
if char == '\n' {
|
||
lines = append(lines, currentLine)
|
||
currentLine = []rune{}
|
||
} else {
|
||
currentLine = append(currentLine, char)
|
||
}
|
||
}
|
||
|
||
// 添加最后一行
|
||
if len(currentLine) > 0 {
|
||
lines = append(lines, currentLine)
|
||
}
|
||
|
||
return lines
|
||
}
|
||
|
||
// ErrFontNotLoaded 表示字体未加载错误
|
||
var ErrFontNotLoaded = ErrorMessage("字体未加载，请先调用ParseFont加载字体")
|
||
|
||
// ErrorMessage 是一个自定义错误类型
|
||
type ErrorMessage string
|
||
|
||
func (e ErrorMessage) Error() string {
|
||
return string(e)
|
||
}
|
||
|
||
// createPlaceholderImage 创建替代图像，用于不支持的字符
|
||
func createPlaceholderImage(fontSize float64, textColor color.Color) *image.RGBA {
|
||
size := int(fontSize)
|
||
if size < 10 {
|
||
size = 10
|
||
}
|
||
|
||
// 创建正方形图像
|
||
img := image.NewRGBA(image.Rect(0, 0, size, size))
|
||
draw.Draw(img, img.Bounds(), image.Transparent, image.Point{}, draw.Src)
|
||
|
||
// 绘制边框
|
||
for x := 0; x < size; x++ {
|
||
img.Set(x, 0, textColor)
|
||
img.Set(x, size-1, textColor)
|
||
}
|
||
for y := 0; y < size; y++ {
|
||
img.Set(0, y, textColor)
|
||
img.Set(size-1, y, textColor)
|
||
}
|
||
|
||
// 绘制对角线
|
||
for i := 0; i < size; i++ {
|
||
if i < size {
|
||
img.Set(i, i, textColor)
|
||
img.Set(i, size-i-1, textColor)
|
||
}
|
||
}
|
||
|
||
return img
|
||
}
|
||
|
||
// drawPlaceholder 在图像上绘制占位符
|
||
func drawPlaceholder(img *image.RGBA, x, y, size int, c color.Color) {
|
||
halfSize := size / 2
|
||
|
||
// 绘制一个简单的方框
|
||
for i := 0; i < size; i++ {
|
||
img.Set(x+i, y-halfSize, c) // 顶边
|
||
img.Set(x+i, y+halfSize, c) // 底边
|
||
}
|
||
|
||
for i := -halfSize; i <= halfSize; i++ {
|
||
img.Set(x, y+i, c) // 左边
|
||
img.Set(x+size-1, y+i, c) // 右边
|
||
}
|
||
|
||
// 绘制对角线
|
||
for i := 0; i < size; i++ {
|
||
y1 := y - halfSize + i
|
||
y2 := y + halfSize - i
|
||
|
||
if y1 >= 0 && y1 < img.Bounds().Max.Y &&
|
||
y2 >= 0 && y2 < img.Bounds().Max.Y {
|
||
img.Set(x+i, y1, c)
|
||
img.Set(x+i, y2, c)
|
||
}
|
||
}
|
||
}
|