180 lines
5.4 KiB
Go
180 lines
5.4 KiB
Go
package logic
|
|
|
|
import (
|
|
"bytes"
|
|
"math"
|
|
"math/rand"
|
|
"strconv"
|
|
"toolbox/pkg/learnnumber/data"
|
|
|
|
"github.com/signintech/gopdf"
|
|
)
|
|
|
|
type WritingRequest struct {
|
|
StartNum int `json:"start_num"`
|
|
EndNum int `json:"end_num"`
|
|
PaperSize string `json:"paper_size"`
|
|
}
|
|
|
|
type WritingNode struct {
|
|
X, Y, R float64
|
|
AngleA, AngleB float64
|
|
BulgeR, Dist float64
|
|
Number int
|
|
}
|
|
|
|
func GenerateWritingPDF(req WritingRequest) ([]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})
|
|
|
|
err := pdf.AddTTFFontData("basic", data.FontContent)
|
|
if err != nil { return nil, err }
|
|
|
|
currentNum := req.StartNum
|
|
// 只要还没达到 EndNum，就继续生成“整页”内容
|
|
for currentNum <= req.EndNum {
|
|
pdf.AddPage()
|
|
lastPlaced := drawOneFullPage(pdf, currentNum, rect.W, rect.H)
|
|
currentNum = lastPlaced + 1
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
_, err = pdf.WriteTo(&buf)
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
// 核心改变：不再受限于 end 参数，而是尝试填满整页
|
|
func drawOneFullPage(pdf *gopdf.GoPdf, start int, pW, pH float64) int {
|
|
margin := 80.0
|
|
boxW, boxH := pW-2*margin, pH-160.0
|
|
xBase, yBase := margin, 100.0
|
|
|
|
nodeR := 28.0
|
|
bulgeR := nodeR * 0.32
|
|
dist := nodeR + bulgeR + 18.0
|
|
checkR := nodeR * 1.3
|
|
|
|
var nodes []WritingNode
|
|
num := start
|
|
|
|
// 无限循环，直到页面塞不下为止
|
|
for {
|
|
placed := false
|
|
for retry := 0; retry < 1000; retry++ {
|
|
rx := xBase + dist + 20 + rand.Float64()*(boxW - 2*dist - 40)
|
|
ry := yBase + dist + 20 + rand.Float64()*(boxH - 2*dist - 40)
|
|
|
|
if isColliding(rx, ry, checkR, nodes) { continue }
|
|
|
|
angleA := rand.Float64() * 2 * math.Pi
|
|
angleB := angleA + math.Pi + (rand.Float64()-0.5)*1.5
|
|
nodes = append(nodes, WritingNode{X: rx, Y: ry, R: nodeR, AngleA: angleA, AngleB: angleB, BulgeR: bulgeR, Dist: dist, Number: num})
|
|
placed = true
|
|
break
|
|
}
|
|
|
|
if !placed {
|
|
// 页面已满
|
|
break
|
|
}
|
|
num++
|
|
}
|
|
|
|
// 空间优化
|
|
optimizeSpace(nodes, xBase, yBase, boxW, boxH, dist, checkR)
|
|
|
|
// 绘制
|
|
for _, n := range nodes {
|
|
drawFullNode(pdf, n)
|
|
}
|
|
|
|
// 返回本页最后一个数字
|
|
if len(nodes) > 0 {
|
|
return nodes[len(nodes)-1].Number
|
|
}
|
|
return start
|
|
}
|
|
|
|
func optimizeSpace(nodes []WritingNode, xBase, yBase, boxW, boxH, dist, checkR float64) {
|
|
if len(nodes) < 2 { return }
|
|
for iter := 0; iter < 120; iter++ {
|
|
for i := range nodes {
|
|
bestX, bestY := nodes[i].X, nodes[i].Y
|
|
maxMinDist := calcMinDist(bestX, bestY, i, nodes)
|
|
for k := 0; k < 8; k++ {
|
|
moveAngle := rand.Float64() * 2 * math.Pi
|
|
nx := nodes[i].X + math.Cos(moveAngle)*5.0
|
|
ny := nodes[i].Y + math.Sin(moveAngle)*5.0
|
|
if nx-dist < xBase || nx+dist > xBase+boxW || ny-dist < yBase || ny+dist > yBase+boxH { continue }
|
|
if isColliding(nx, ny, checkR, nodes[:i]) || isColliding(nx, ny, checkR, nodes[i+1:]) { continue }
|
|
newMinDist := calcMinDist(nx, ny, i, nodes)
|
|
if newMinDist > maxMinDist {
|
|
maxMinDist = newMinDist; bestX, bestY = nx, ny
|
|
}
|
|
}
|
|
nodes[i].X, nodes[i].Y = bestX, bestY
|
|
}
|
|
}
|
|
}
|
|
|
|
func isColliding(x, y, r float64, existing []WritingNode) bool {
|
|
for _, e := range existing {
|
|
d := math.Sqrt(math.Pow(x-e.X, 2) + math.Pow(y-e.Y, 2))
|
|
if d < (r + e.R*1.3 + 30.0) { return true }
|
|
}
|
|
return false
|
|
}
|
|
|
|
func calcMinDist(x, y float64, idx int, nodes []WritingNode) float64 {
|
|
minD := 10000.0
|
|
for i, n := range nodes {
|
|
if i == idx { continue }
|
|
d := math.Sqrt(math.Pow(x-n.X, 2) + math.Pow(y-n.Y, 2))
|
|
if d < minD { minD = d }
|
|
}
|
|
return minD
|
|
}
|
|
|
|
func getEdgePoint(x, y, r, angle float64, isCircle bool) (float64, float64) {
|
|
gap := 2.0
|
|
er := r + gap
|
|
if isCircle { return x + math.Cos(angle)*er, y + math.Sin(angle)*er }
|
|
absCos, absSin := math.Abs(math.Cos(angle)), math.Abs(math.Sin(angle))
|
|
var d float64
|
|
if absCos > absSin { d = er / absCos } else { d = er / absSin }
|
|
return x + math.Cos(angle)*d, y + math.Sin(angle)*d
|
|
}
|
|
|
|
func drawCenteredText(pdf *gopdf.GoPdf, cx, cy float64, text string, fontSize float64) {
|
|
pdf.SetFont("basic", "", fontSize)
|
|
tw, _ := pdf.MeasureTextWidth(text)
|
|
pdf.SetXY(cx - tw/2, cy + fontSize*0.38)
|
|
pdf.Text(text)
|
|
}
|
|
|
|
func drawFullNode(pdf *gopdf.GoPdf, n WritingNode) {
|
|
isOdd := n.Number%2 != 0
|
|
pdf.SetStrokeColor(0, 0, 0); pdf.SetLineWidth(1.8)
|
|
if isOdd { pdf.Oval(n.X-n.R, n.Y-n.R, n.X+n.R, n.Y+n.R) } else { pdf.RectFromUpperLeft(n.X-n.R, n.Y-n.R, n.R*2, n.R*2) }
|
|
pdf.SetTextColor(220, 220, 220)
|
|
drawCenteredText(pdf, n.X, n.Y, strconv.Itoa(n.Number), n.R*1.35)
|
|
|
|
pdf.SetStrokeColor(180, 180, 180); pdf.SetLineWidth(1.0)
|
|
ax, ay := n.X + math.Cos(n.AngleA)*n.Dist, n.Y + math.Sin(n.AngleA)*n.Dist
|
|
lx1, ly1 := getEdgePoint(n.X, n.Y, n.R, n.AngleA, isOdd)
|
|
lx2, ly2 := getEdgePoint(ax, ay, n.BulgeR, n.AngleA+math.Pi, !isOdd)
|
|
pdf.Line(lx1, ly1, lx2, ly2)
|
|
if isOdd { pdf.RectFromUpperLeft(ax-n.BulgeR, ay-n.BulgeR, n.BulgeR*2, n.BulgeR*2) } else { pdf.Oval(ax-n.BulgeR, ay-n.BulgeR, ax+n.BulgeR, ay+n.BulgeR) }
|
|
|
|
bx, by := n.X + math.Cos(n.AngleB)*n.Dist, n.Y + math.Sin(n.AngleB)*n.Dist
|
|
lx3, ly3 := getEdgePoint(n.X, n.Y, n.R, n.AngleB, isOdd)
|
|
lx4, ly4 := getEdgePoint(bx, by, n.BulgeR, n.AngleB+math.Pi, !isOdd)
|
|
pdf.Line(lx3, ly3, lx4, ly4)
|
|
if isOdd { pdf.RectFromUpperLeft(bx-n.BulgeR, by-n.BulgeR, n.BulgeR*2, n.BulgeR*2) } else { pdf.Oval(bx-n.BulgeR, by-n.BulgeR, bx+n.BulgeR, by+n.BulgeR) }
|
|
|
|
pdf.SetTextColor(120, 120, 120)
|
|
drawCenteredText(pdf, bx, by, strconv.Itoa(n.Number+1), math.Max(7, n.BulgeR*1.2))
|
|
}
|