haopengzhan
5c185da0a9
- Implement dynamic SEO meta tags and sitemap.xml for toolbox.pengzhan.dev - Fix SPA title/meta refresh issue in layout.html - Address golangci-lint findings: - Refactor switch-case for tool path and SVG token parsing - Replace math.Pow with direct multiplication for performance - Fix unhandled error returns and unused imports - Omit redundant type declarations
341 lines
8.0 KiB
Go
341 lines
8.0 KiB
Go
package logic
|
|
|
|
import (
|
|
"bytes"
|
|
"math"
|
|
"math/rand"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"toolbox/pkg/learnnumber/data"
|
|
|
|
"github.com/signintech/gopdf"
|
|
)
|
|
|
|
type CountingRequest struct {
|
|
TotalCount int `json:"total_count"`
|
|
IconTypes int `json:"icon_types"`
|
|
PageCount int `json:"page_count"`
|
|
Category string `json:"category"`
|
|
PaperSize string `json:"paper_size"`
|
|
}
|
|
|
|
type PlacedIcon struct {
|
|
X, Y, Radius float64
|
|
}
|
|
|
|
type PathResult struct {
|
|
Points []gopdf.Point
|
|
Closed bool
|
|
}
|
|
|
|
var reSVGToken = regexp.MustCompile(`[a-zA-Z]|-?\d+\.?\d*`)
|
|
|
|
func GenerateCountingPDF(req CountingRequest) ([]byte, error) {
|
|
pdf := &gopdf.GoPdf{}
|
|
rect := gopdf.Rect{W: 595.28, H: 841.89}
|
|
if req.PaperSize == "Letter" {
|
|
rect = gopdf.Rect{W: 612, H: 792}
|
|
}
|
|
pdf.Start(gopdf.Config{PageSize: rect})
|
|
|
|
// 硬性限制：页数 1-10 页，防止资源耗尽
|
|
if req.PageCount < 1 {
|
|
req.PageCount = 1
|
|
}
|
|
if req.PageCount > 10 {
|
|
req.PageCount = 10
|
|
}
|
|
|
|
for i := 0; i < req.PageCount; i++ {
|
|
pdf.AddPage()
|
|
drawProblemV4(pdf, req, 0, rect.W, rect.H/2)
|
|
drawProblemV4(pdf, req, rect.H/2, rect.W, rect.H/2)
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
_, err := pdf.WriteTo(&buf)
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
func drawProblemV4(pdf *gopdf.GoPdf, req CountingRequest, startY, pW, pH float64) {
|
|
margin := 40.0
|
|
boxW, boxH := (pW-2*margin)*0.7, pH-60.0
|
|
xBase, yBase := margin, startY+30.0
|
|
|
|
pdf.SetStrokeColor(0, 0, 0)
|
|
pdf.SetLineWidth(2.5)
|
|
pdf.RectFromUpperLeft(xBase, yBase, boxW, boxH)
|
|
|
|
catIcons := data.IconCategories[req.Category]
|
|
if len(catIcons) == 0 {
|
|
catIcons = data.IconCategories["shapes"]
|
|
}
|
|
|
|
numTypes := req.IconTypes
|
|
if numTypes < 1 {
|
|
numTypes = 1
|
|
}
|
|
if numTypes > 6 {
|
|
numTypes = 6
|
|
}
|
|
if numTypes > len(catIcons) {
|
|
numTypes = len(catIcons)
|
|
}
|
|
|
|
total := req.TotalCount
|
|
if total < numTypes {
|
|
total = numTypes
|
|
}
|
|
if total > 30 {
|
|
total = 30
|
|
}
|
|
|
|
allIconsPerm := rand.Perm(len(catIcons))
|
|
var selectedIcons []data.Icon
|
|
counts := make([]int, numTypes)
|
|
|
|
// 随机分配逻辑
|
|
for i := 0; i < numTypes; i++ {
|
|
selectedIcons = append(selectedIcons, catIcons[allIconsPerm[i]])
|
|
counts[i] = 1
|
|
}
|
|
remaining := total - numTypes
|
|
for i := 0; i < remaining; i++ {
|
|
counts[rand.Intn(numTypes)]++
|
|
}
|
|
|
|
avgRadius := math.Sqrt((boxW * boxH * 0.22) / (float64(total) * math.Pi))
|
|
if avgRadius > 35.0 {
|
|
avgRadius = 35.0
|
|
}
|
|
|
|
var placed []PlacedIcon
|
|
iconTypeIdx, currentInType := 0, 0
|
|
for i := 0; i < total; i++ {
|
|
scaleVar := 0.9 + rand.Float64()*0.2
|
|
r := avgRadius * scaleVar
|
|
for retry := 0; retry < 200; retry++ {
|
|
randX := xBase + r + 5 + rand.Float64()*(boxW-2*r-10)
|
|
randY := yBase + r + 5 + rand.Float64()*(boxH-2*r-10)
|
|
collision := false
|
|
for _, p := range placed {
|
|
dx := randX - p.X
|
|
dy := randY - p.Y
|
|
if math.Sqrt(dx*dx+dy*dy) < (r + p.Radius + 10.0) {
|
|
collision = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !collision {
|
|
drawSimpleIcon(pdf, selectedIcons[iconTypeIdx], randX, randY, r*2)
|
|
placed = append(placed, PlacedIcon{X: randX, Y: randY, Radius: r})
|
|
break
|
|
}
|
|
}
|
|
currentInType++
|
|
if currentInType >= counts[iconTypeIdx] {
|
|
iconTypeIdx++
|
|
currentInType = 0
|
|
}
|
|
}
|
|
|
|
legendX, legendStepY := xBase+boxW+20.0, boxH/float64(numTypes+1)
|
|
for i := 0; i < numTypes; i++ {
|
|
lY := yBase + float64(i+1)*legendStepY
|
|
drawSimpleIcon(pdf, selectedIcons[i], legendX+25, lY, 35)
|
|
pdf.SetStrokeColor(150, 150, 150)
|
|
pdf.SetLineWidth(1.0)
|
|
pdf.RectFromUpperLeft(legendX+60, lY-15, 35, 35)
|
|
}
|
|
}
|
|
|
|
func drawSimpleIcon(pdf *gopdf.GoPdf, icon data.Icon, cX, cY, size float64) {
|
|
rawResults := parseMultiPath(icon, 1.0, 0, 0)
|
|
if len(rawResults) == 0 {
|
|
return
|
|
}
|
|
var minX, minY, maxX, maxY = 1e9, 1e9, -1e9, -1e9
|
|
for _, res := range rawResults {
|
|
for _, p := range res.Points {
|
|
if p.X < minX {
|
|
minX = p.X
|
|
}
|
|
if p.X > maxX {
|
|
maxX = p.X
|
|
}
|
|
if p.Y < minY {
|
|
minY = p.Y
|
|
}
|
|
if p.Y > maxY {
|
|
maxY = p.Y
|
|
}
|
|
}
|
|
}
|
|
curW, curH := maxX-minX, maxY-minY
|
|
if curW <= 0 {
|
|
curW = 1
|
|
}
|
|
if curH <= 0 {
|
|
curH = 1
|
|
}
|
|
scale := size / math.Max(curW, curH)
|
|
ox, oy := cX-(curW*scale)/2-minX*scale, cY-(curH*scale)/2-minY*scale
|
|
|
|
pdf.SetStrokeColor(0, 0, 0)
|
|
if strings.Contains(strings.ToLower(icon.Name), "item") || len(icon.Paths) > 1 {
|
|
pdf.SetLineWidth(size / 60.0) // 复杂素材用细线 (30% less than 45 is approx 60)
|
|
} else {
|
|
pdf.SetLineWidth(size / 22.0) // 基础图形用粗线
|
|
}
|
|
for _, res := range rawResults {
|
|
scaledPts := make([]gopdf.Point, len(res.Points))
|
|
for i, p := range res.Points {
|
|
scaledPts[i] = gopdf.Point{X: ox + p.X*scale, Y: oy + p.Y*scale}
|
|
}
|
|
if len(scaledPts) > 1 {
|
|
if res.Closed {
|
|
pdf.Polygon(scaledPts, "D")
|
|
} else {
|
|
for j := 0; j < len(scaledPts)-1; j++ {
|
|
pdf.Line(scaledPts[j].X, scaledPts[j].Y, scaledPts[j+1].X, scaledPts[j+1].Y)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseMultiPath(icon data.Icon, scale, ox, oy float64) []PathResult {
|
|
var results []PathResult
|
|
for _, path := range icon.Paths {
|
|
tokens := reSVGToken.FindAllString(path, -1)
|
|
var lx, ly, startX, startY float64
|
|
var pts []gopdf.Point
|
|
var currentCmd string
|
|
var isRel bool
|
|
for i := 0; i < len(tokens); {
|
|
token := tokens[i]
|
|
if (token[0] >= 'a' && token[0] <= 'z') || (token[0] >= 'A' && token[0] <= 'Z') {
|
|
cmd := strings.ToUpper(token)
|
|
if cmd == "M" {
|
|
if len(pts) > 0 {
|
|
results = append(results, PathResult{Points: pts, Closed: false})
|
|
pts = nil
|
|
}
|
|
} else if cmd == "Z" {
|
|
if len(pts) > 0 {
|
|
results = append(results, PathResult{Points: pts, Closed: true})
|
|
pts = nil
|
|
}
|
|
lx, ly = startX, startY
|
|
i++
|
|
continue
|
|
}
|
|
currentCmd = cmd
|
|
isRel = (token[0] >= 'a' && token[0] <= 'z')
|
|
i++
|
|
continue
|
|
}
|
|
switch currentCmd {
|
|
case "M", "L":
|
|
if i+1 >= len(tokens) {
|
|
i = len(tokens)
|
|
break
|
|
}
|
|
x, _ := strconv.ParseFloat(tokens[i], 64)
|
|
y, _ := strconv.ParseFloat(tokens[i+1], 64)
|
|
if isRel {
|
|
x += lx
|
|
y += ly
|
|
}
|
|
if currentCmd == "M" {
|
|
startX, startY = x, y
|
|
}
|
|
lx, ly = x, y
|
|
pts = append(pts, gopdf.Point{X: ox + x*scale, Y: oy + y*scale})
|
|
i += 2
|
|
if currentCmd == "M" {
|
|
currentCmd = "L"
|
|
}
|
|
case "H":
|
|
x, _ := strconv.ParseFloat(tokens[i], 64)
|
|
if isRel {
|
|
x += lx
|
|
}
|
|
lx = x
|
|
pts = append(pts, gopdf.Point{X: ox + x*scale, Y: oy + ly*scale})
|
|
i++
|
|
case "V":
|
|
y, _ := strconv.ParseFloat(tokens[i], 64)
|
|
if isRel {
|
|
y += ly
|
|
}
|
|
ly = y
|
|
pts = append(pts, gopdf.Point{X: ox + lx*scale, Y: oy + y*scale})
|
|
i++
|
|
case "C":
|
|
if i+5 >= len(tokens) {
|
|
i = len(tokens)
|
|
break
|
|
}
|
|
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)
|
|
x, _ := strconv.ParseFloat(tokens[i+4], 64)
|
|
y, _ := strconv.ParseFloat(tokens[i+5], 64)
|
|
if isRel {
|
|
x1 += lx
|
|
y1 += ly
|
|
x2 += lx
|
|
y2 += ly
|
|
x += lx
|
|
y += ly
|
|
}
|
|
for t := 0.2; t <= 1.0; t += 0.2 {
|
|
invT := 1 - t
|
|
tx := invT*invT*invT*lx + 3*invT*invT*t*x1 + 3*invT*t*t*x2 + t*t*t*x
|
|
ty := invT*invT*invT*ly + 3*invT*invT*t*y1 + 3*invT*t*t*y2 + t*t*t*y
|
|
pts = append(pts, gopdf.Point{X: ox + tx*scale, Y: oy + ty*scale})
|
|
}
|
|
|
|
lx, ly = x, y
|
|
i += 6
|
|
case "Q":
|
|
if i+3 >= len(tokens) {
|
|
i = len(tokens)
|
|
break
|
|
}
|
|
x1, _ := strconv.ParseFloat(tokens[i], 64)
|
|
y1, _ := strconv.ParseFloat(tokens[i+1], 64)
|
|
x, _ := strconv.ParseFloat(tokens[i+2], 64)
|
|
y, _ := strconv.ParseFloat(tokens[i+3], 64)
|
|
if isRel {
|
|
x1 += lx
|
|
y1 += ly
|
|
x += lx
|
|
y += ly
|
|
}
|
|
for t := 0.25; t <= 1.0; t += 0.25 {
|
|
invT := 1 - t
|
|
tx := invT*invT*lx + 2*invT*t*x1 + t*t*x
|
|
ty := invT*invT*ly + 2*invT*t*y1 + t*t*y
|
|
pts = append(pts, gopdf.Point{X: ox + tx*scale, Y: oy + ty*scale})
|
|
}
|
|
|
|
lx, ly = x, y
|
|
i += 4
|
|
case "A":
|
|
i += 7
|
|
default:
|
|
i++
|
|
}
|
|
}
|
|
if len(pts) > 0 {
|
|
results = append(results, PathResult{Points: pts, Closed: false})
|
|
}
|
|
}
|
|
return results
|
|
}
|