func TraceQuad(t Liner, quad []float64, flatteningThreshold float64) {
	const curveLen = CurveRecursionLimit * 6
	const curveEndIndex = curveLen - 1
	const lastIteration = CurveRecursionLimit - 1
	curves := make([]float64, curveLen)
	copy(curves[0:6], quad[0:6])
	var i int
	var c []float64
	var dx, dy, d float64
	for i >= 0 {
		c = traceGetWindow(curves, i)
		dx, dy, d = traceCalcDeltas(c)
		if d == 0 {
			return
		}
		if traceIsFlat(dx, dy, d, flatteningThreshold) || i == lastIteration {
			t.LineTo(c[4], c[5])
			i--
		} else {
			SubdivideQuad(c, traceGetWindow(curves, i+1), traceGetWindow(curves, i))
			i++
		}
	}
}
TraceQuad generate lines subdividing the curve using a Liner
flattening_threshold helps determines the flattening expectation of the curve
package drawing
import "math"
const (
	CurveRecursionLimit = 32
)
func SubdivideCubic(c, c1, c2 []float64) {
	c1[0], c1[1] = c[0], c[1]
	c2[6], c2[7] = c[6], c[7]
	c1[2] = (c[0] + c[2]) / 2
	c1[3] = (c[1] + c[3]) / 2
	midX := (c[2] + c[4]) / 2
	midY := (c[3] + c[5]) / 2
	c2[4] = (c[4] + c[6]) / 2
	c2[5] = (c[5] + c[7]) / 2
	c1[4] = (c1[2] + midX) / 2
	c1[5] = (c1[3] + midY) / 2
	c2[2] = (midX + c2[4]) / 2
	c2[3] = (midY + c2[5]) / 2
	c1[6] = (c1[4] + c2[2]) / 2
	c1[7] = (c1[5] + c2[3]) / 2
	c2[0], c2[1] = c1[6], c1[7]
}
func TraceCubic(t Liner, cubic []float64, flatteningThreshold float64) {
	var curves [CurveRecursionLimit * 8]float64
	copy(curves[0:8], cubic[0:8])
	i := 0
	var c []float64
	var dx, dy, d2, d3 float64
	for i >= 0 {
		c = curves[i*8:]
		dx = c[6] - c[0]
		dy = c[7] - c[1]
		d2 = math.Abs((c[2]-c[6])*dy - (c[3]-c[7])*dx)
		d3 = math.Abs((c[4]-c[6])*dy - (c[5]-c[7])*dx)
		if (d2+d3)*(d2+d3) < flatteningThreshold*(dx*dx+dy*dy) || i == len(curves)-1 {
			t.LineTo(c[6], c[7])
			i--
		} else {
			SubdivideCubic(c, curves[(i+1)*8:], curves[i*8:])
			i++
		}
	}
}
func SubdivideQuad(c, c1, c2 []float64) {
	c1[0], c1[1] = c[0], c[1]
	c2[4], c2[5] = c[4], c[5]
	c1[2] = (c[0] + c[2]) / 2
	c1[3] = (c[1] + c[3]) / 2
	c2[2] = (c[2] + c[4]) / 2
	c2[3] = (c[3] + c[5]) / 2
	c1[4] = (c1[2] + c2[2]) / 2
	c1[5] = (c1[3] + c2[3]) / 2
	c2[0], c2[1] = c1[4], c1[5]
	return
}
func traceWindowIndices(i int) (startAt, endAt int) {
	startAt = i * 6
	endAt = startAt + 6
	return
}
func traceCalcDeltas(c []float64) (dx, dy, d float64) {
	dx = c[4] - c[0]
	dy = c[5] - c[1]
	d = math.Abs(((c[2]-c[4])*dy - (c[3]-c[5])*dx))
	return
}
func traceIsFlat(dx, dy, d, threshold float64) bool {
	return (d * d) < threshold*(dx*dx+dy*dy)
}
func traceGetWindow(curves []float64, i int) []float64 {
	startAt, endAt := traceWindowIndices(i)
	return curves[startAt:endAt]
}