fixed dependencies

2024-10-24 15:46:01 +08:00
parent d16a5bd9c0
commit 1161e8d054
2005 changed files with 690883 additions and 0 deletions
--- a/vendor/gonum.org/v1/plot/vg/vgpdf/vgpdf.go
+++ b/vendor/gonum.org/v1/plot/vg/vgpdf/vgpdf.go
@@ -0,0 +1,490 @@
+// Copyright ©2015 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package vgpdf implements the vg.Canvas interface
+// using gofpdf (github.com/phpdave11/gofpdf).
+package vgpdf // import "gonum.org/v1/plot/vg/vgpdf"
+
+import (
+	"bufio"
+	"bytes"
+	_ "embed"
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"io"
+	"log"
+	"math"
+	"os"
+	"path/filepath"
+	"sync"
+
+	pdf "github.com/go-pdf/fpdf"
+	stdfnt "golang.org/x/image/font"
+
+	"gonum.org/v1/plot/font"
+	"gonum.org/v1/plot/vg"
+	"gonum.org/v1/plot/vg/draw"
+)
+
+// codePageEncoding holds informations about the characters encoding of TrueType
+// font files, needed by gofpdf to embed fonts in a PDF document.
+// We use cp1252 (code page 1252, Windows Western) to encode characters.
+// See:
+//   - https://en.wikipedia.org/wiki/Windows-1252
+//
+// TODO: provide a Canvas-level func option to embed fonts with a user provided
+// code page schema?
+//
+//go:embed cp1252.map
+var codePageEncoding []byte
+
+func init() {
+	draw.RegisterFormat("pdf", func(w, h vg.Length) vg.CanvasWriterTo {
+		return New(w, h)
+	})
+}
+
+// DPI is the nominal resolution of drawing in PDF.
+const DPI = 72
+
+// Canvas implements the vg.Canvas interface,
+// drawing to a PDF.
+type Canvas struct {
+	doc  *pdf.Fpdf
+	w, h vg.Length
+
+	dpi       int
+	numImages int
+	stack     []context
+	fonts     map[font.Font]struct{}
+
+	// Switch to embed fonts in PDF file.
+	// The default is to embed fonts.
+	// This makes the PDF file more portable but also larger.
+	embed bool
+}
+
+type context struct {
+	fill  color.Color
+	line  color.Color
+	width vg.Length
+}
+
+// New creates a new PDF Canvas.
+func New(w, h vg.Length) *Canvas {
+	cfg := pdf.InitType{
+		UnitStr: "pt",
+		Size:    pdf.SizeType{Wd: w.Points(), Ht: h.Points()},
+	}
+	c := &Canvas{
+		doc:   pdf.NewCustom(&cfg),
+		w:     w,
+		h:     h,
+		dpi:   DPI,
+		stack: make([]context, 1),
+		fonts: make(map[font.Font]struct{}),
+		embed: true,
+	}
+	c.NextPage()
+	vg.Initialize(c)
+	return c
+}
+
+// EmbedFonts specifies whether the resulting PDF canvas should
+// embed the fonts or not.
+// EmbedFonts returns the previous value before modification.
+func (c *Canvas) EmbedFonts(v bool) bool {
+	prev := c.embed
+	c.embed = v
+	return prev
+}
+
+func (c *Canvas) DPI() float64 {
+	return float64(c.dpi)
+}
+
+func (c *Canvas) context() *context {
+	return &c.stack[len(c.stack)-1]
+}
+
+func (c *Canvas) Size() (w, h vg.Length) {
+	return c.w, c.h
+}
+
+func (c *Canvas) SetLineWidth(w vg.Length) {
+	c.context().width = w
+	lw := c.unit(w)
+	c.doc.SetLineWidth(lw)
+}
+
+func (c *Canvas) SetLineDash(dashes []vg.Length, offs vg.Length) {
+	ds := make([]float64, len(dashes))
+	for i, d := range dashes {
+		ds[i] = c.unit(d)
+	}
+	c.doc.SetDashPattern(ds, c.unit(offs))
+}
+
+func (c *Canvas) SetColor(clr color.Color) {
+	if clr == nil {
+		clr = color.Black
+	}
+	c.context().line = clr
+	c.context().fill = clr
+	r, g, b, a := rgba(clr)
+	c.doc.SetFillColor(r, g, b)
+	c.doc.SetDrawColor(r, g, b)
+	c.doc.SetTextColor(r, g, b)
+	c.doc.SetAlpha(a, "Normal")
+}
+
+func (c *Canvas) Rotate(r float64) {
+	c.doc.TransformRotate(-r*180/math.Pi, 0, 0)
+}
+
+func (c *Canvas) Translate(pt vg.Point) {
+	xp, yp := c.pdfPoint(pt)
+	c.doc.TransformTranslate(xp, yp)
+}
+
+func (c *Canvas) Scale(x float64, y float64) {
+	c.doc.TransformScale(x*100, y*100, 0, 0)
+}
+
+func (c *Canvas) Push() {
+	c.stack = append(c.stack, *c.context())
+	c.doc.TransformBegin()
+}
+
+func (c *Canvas) Pop() {
+	c.doc.TransformEnd()
+	c.stack = c.stack[:len(c.stack)-1]
+}
+
+func (c *Canvas) Stroke(p vg.Path) {
+	if c.context().width > 0 {
+		c.pdfPath(p, "D")
+	}
+}
+
+func (c *Canvas) Fill(p vg.Path) {
+	c.pdfPath(p, "F")
+}
+
+func (c *Canvas) FillString(fnt font.Face, pt vg.Point, str string) {
+	if fnt.Font.Size == 0 {
+		return
+	}
+
+	c.font(fnt, pt)
+	style := ""
+	if fnt.Font.Weight == stdfnt.WeightBold {
+		style += "B"
+	}
+	if fnt.Font.Style == stdfnt.StyleItalic {
+		style += "I"
+	}
+	c.doc.SetFont(fnt.Name(), style, c.unit(fnt.Font.Size))
+
+	c.Push()
+	defer c.Pop()
+	c.Translate(pt)
+	// go-fpdf uses the top left corner as origin.
+	c.Scale(1, -1)
+	left, top, right, bottom := c.sbounds(fnt, str)
+	w := right - left
+	h := bottom - top
+	margin := c.doc.GetCellMargin()
+
+	c.doc.MoveTo(-left-margin, top)
+	c.doc.CellFormat(w, h, str, "", 0, "BL", false, 0, "")
+}
+
+func (c *Canvas) sbounds(fnt font.Face, txt string) (left, top, right, bottom float64) {
+	_, h := c.doc.GetFontSize()
+	style := ""
+	if fnt.Font.Weight == stdfnt.WeightBold {
+		style += "B"
+	}
+	if fnt.Font.Style == stdfnt.StyleItalic {
+		style += "I"
+	}
+	d := c.doc.GetFontDesc(fnt.Name(), style)
+	if d.Ascent == 0 {
+		// not defined (standard font?), use average of 81%
+		top = 0.81 * h
+	} else {
+		top = -float64(d.Ascent) * h / float64(d.Ascent-d.Descent)
+	}
+	return 0, top, c.doc.GetStringWidth(txt), top + h
+}
+
+// DrawImage implements the vg.Canvas.DrawImage method.
+func (c *Canvas) DrawImage(rect vg.Rectangle, img image.Image) {
+	opts := pdf.ImageOptions{ImageType: "png", ReadDpi: true}
+	name := c.imageName()
+
+	buf := new(bytes.Buffer)
+	err := png.Encode(buf, img)
+	if err != nil {
+		log.Panicf("error encoding image to PNG: %v", err)
+	}
+	c.doc.RegisterImageOptionsReader(name, opts, buf)
+
+	xp, yp := c.pdfPoint(rect.Min)
+	wp, hp := c.pdfPoint(rect.Size())
+
+	c.doc.ImageOptions(name, xp, yp, wp, hp, false, opts, 0, "")
+}
+
+// font registers a font and a size with the PDF canvas.
+func (c *Canvas) font(fnt font.Face, pt vg.Point) {
+	if _, ok := c.fonts[fnt.Font]; ok {
+		return
+	}
+	name := fnt.Name()
+	key := fontKey{font: fnt, embed: c.embed}
+	raw := new(bytes.Buffer)
+	_, err := fnt.Face.WriteSourceTo(nil, raw)
+	if err != nil {
+		log.Panicf("vgpdf: could not generate font %q data for PDF: %+v", name, err)
+	}
+
+	zdata, jdata, err := getFont(key, raw.Bytes(), codePageEncoding)
+	if err != nil {
+		log.Panicf("vgpdf: could not generate font data for PDF: %v", err)
+	}
+
+	c.fonts[fnt.Font] = struct{}{}
+	c.doc.AddFontFromBytes(name, "", jdata, zdata)
+}
+
+// pdfPath processes a vg.Path and applies it to the canvas.
+func (c *Canvas) pdfPath(path vg.Path, style string) {
+	var (
+		xp float64
+		yp float64
+	)
+	for _, comp := range path {
+		switch comp.Type {
+		case vg.MoveComp:
+			xp, yp = c.pdfPoint(comp.Pos)
+			c.doc.MoveTo(xp, yp)
+		case vg.LineComp:
+			c.doc.LineTo(c.pdfPoint(comp.Pos))
+		case vg.ArcComp:
+			c.arc(comp, style)
+		case vg.CurveComp:
+			px, py := c.pdfPoint(comp.Pos)
+			switch len(comp.Control) {
+			case 1:
+				cx, cy := c.pdfPoint(comp.Control[0])
+				c.doc.CurveTo(cx, cy, px, py)
+			case 2:
+				cx, cy := c.pdfPoint(comp.Control[0])
+				dx, dy := c.pdfPoint(comp.Control[1])
+				c.doc.CurveBezierCubicTo(cx, cy, dx, dy, px, py)
+			default:
+				panic("vgpdf: invalid number of control points")
+			}
+		case vg.CloseComp:
+			c.doc.LineTo(xp, yp)
+			c.doc.ClosePath()
+		default:
+			panic(fmt.Sprintf("Unknown path component type: %d\n", comp.Type))
+		}
+	}
+	c.doc.DrawPath(style)
+}
+
+func (c *Canvas) arc(comp vg.PathComp, style string) {
+	x0 := comp.Pos.X + comp.Radius*vg.Length(math.Cos(comp.Start))
+	y0 := comp.Pos.Y + comp.Radius*vg.Length(math.Sin(comp.Start))
+	c.doc.LineTo(c.pdfPointXY(x0, y0))
+	r := c.unit(comp.Radius)
+	const deg = 180 / math.Pi
+	angle := comp.Angle * deg
+	beg := comp.Start * deg
+	end := beg + angle
+	x := c.unit(comp.Pos.X)
+	y := c.unit(comp.Pos.Y)
+	c.doc.Arc(x, y, r, r, angle, beg, end, style)
+	x1 := comp.Pos.X + comp.Radius*vg.Length(math.Cos(comp.Start+comp.Angle))
+	y1 := comp.Pos.Y + comp.Radius*vg.Length(math.Sin(comp.Start+comp.Angle))
+	c.doc.MoveTo(c.pdfPointXY(x1, y1))
+}
+
+func (c *Canvas) pdfPointXY(x, y vg.Length) (float64, float64) {
+	return c.unit(x), c.unit(y)
+}
+
+func (c *Canvas) pdfPoint(pt vg.Point) (float64, float64) {
+	return c.unit(pt.X), c.unit(pt.Y)
+}
+
+// unit returns a fpdf.Unit, converted from a vg.Length.
+func (c *Canvas) unit(l vg.Length) float64 {
+	return l.Dots(c.DPI())
+}
+
+// imageName generates a unique image name for this PDF canvas
+func (c *Canvas) imageName() string {
+	c.numImages++
+	return fmt.Sprintf("image_%03d.png", c.numImages)
+}
+
+// WriterCounter implements the io.Writer interface, and counts
+// the total number of bytes written.
+type writerCounter struct {
+	io.Writer
+	n int64
+}
+
+func (w *writerCounter) Write(p []byte) (int, error) {
+	n, err := w.Writer.Write(p)
+	w.n += int64(n)
+	return n, err
+}
+
+// WriteTo writes the Canvas to an io.Writer.
+// After calling Write, the canvas is closed
+// and may no longer be used for drawing.
+func (c *Canvas) WriteTo(w io.Writer) (int64, error) {
+	c.Pop()
+	c.doc.Close()
+	wc := writerCounter{Writer: w}
+	b := bufio.NewWriter(&wc)
+	if err := c.doc.Output(b); err != nil {
+		return wc.n, err
+	}
+	err := b.Flush()
+	return wc.n, err
+}
+
+// rgba converts a Go color into a gofpdf 3-tuple int + 1 float64
+func rgba(c color.Color) (int, int, int, float64) {
+	if c == nil {
+		c = color.Black
+	}
+	r, g, b, a := c.RGBA()
+	return int(r >> 8), int(g >> 8), int(b >> 8), float64(a) / math.MaxUint16
+}
+
+type fontsCache struct {
+	sync.RWMutex
+	cache map[fontKey]fontVal
+}
+
+// fontKey represents a PDF font request.
+// fontKey needs to know whether the font will be embedded or not,
+// as gofpdf.MakeFont will generate different informations.
+type fontKey struct {
+	font  font.Face
+	embed bool
+}
+
+type fontVal struct {
+	z, j []byte
+}
+
+func (c *fontsCache) get(key fontKey) (fontVal, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	v, ok := c.cache[key]
+	return v, ok
+}
+
+func (c *fontsCache) add(k fontKey, v fontVal) {
+	c.Lock()
+	defer c.Unlock()
+	c.cache[k] = v
+}
+
+var pdfFonts = &fontsCache{
+	cache: make(map[fontKey]fontVal),
+}
+
+func getFont(key fontKey, font, encoding []byte) (z, j []byte, err error) {
+	if v, ok := pdfFonts.get(key); ok {
+		return v.z, v.j, nil
+	}
+
+	v, err := makeFont(key, font, encoding)
+	if err != nil {
+		return nil, nil, err
+	}
+	return v.z, v.j, nil
+}
+
+func makeFont(key fontKey, font, encoding []byte) (val fontVal, err error) {
+	tmpdir, err := os.MkdirTemp("", "gofpdf-makefont-")
+	if err != nil {
+		return val, err
+	}
+	defer os.RemoveAll(tmpdir)
+
+	indir := filepath.Join(tmpdir, "input")
+	err = os.Mkdir(indir, 0755)
+	if err != nil {
+		return val, err
+	}
+
+	outdir := filepath.Join(tmpdir, "output")
+	err = os.Mkdir(outdir, 0755)
+	if err != nil {
+		return val, err
+	}
+
+	fname := filepath.Join(indir, "font.ttf")
+	encname := filepath.Join(indir, "cp1252.map")
+
+	err = os.WriteFile(fname, font, 0644)
+	if err != nil {
+		return val, err
+	}
+
+	err = os.WriteFile(encname, encoding, 0644)
+	if err != nil {
+		return val, err
+	}
+
+	err = pdf.MakeFont(fname, encname, outdir, io.Discard, key.embed)
+	if err != nil {
+		return val, err
+	}
+
+	if key.embed {
+		z, err := os.ReadFile(filepath.Join(outdir, "font.z"))
+		if err != nil {
+			return val, err
+		}
+		val.z = z
+	}
+
+	j, err := os.ReadFile(filepath.Join(outdir, "font.json"))
+	if err != nil {
+		return val, err
+	}
+	val.j = j
+
+	pdfFonts.add(key, val)
+
+	return val, nil
+}
+
+// NextPage creates a new page in the final PDF document.
+// The new page is the new current page.
+// Modifications applied to the canvas will only be applied to that new page.
+func (c *Canvas) NextPage() {
+	if c.doc.PageNo() > 0 {
+		c.Pop()
+	}
+	c.doc.SetMargins(0, 0, 0)
+	c.doc.AddPage()
+	c.Push()
+	c.Translate(vg.Point{X: 0, Y: c.h})
+	c.Scale(1, -1)
+}