fixed dependencies

vendor/gonum.org/v1/plot/font/doc.go

@@ -0,0 +1,6 @@
+// Copyright ©2021 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 font provides types to describe and select text font faces.
+package font // import "gonum.org/v1/plot/font"

vendor/gonum.org/v1/plot/font/font.go

@@ -0,0 +1,335 @@
+// Copyright ©2021 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 font
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/opentype"
+	"golang.org/x/image/font/sfnt"
+	"golang.org/x/image/math/fixed"
+)
+
+// DefaultCache is the global cache for fonts.
+var DefaultCache *Cache = NewCache(nil)
+
+// Font represents a font face.
+type Font struct {
+	// Typeface identifies the Font.
+	Typeface Typeface
+
+	// TODO(sbinet): Gio@v0.2.0 has dropped font.Font.Variant
+	// we should probably follow suit.
+
+	// Variant is the variant of a font, such as "Mono" or "Smallcaps".
+	Variant Variant
+
+	// Style is the style of a font, such as Regular or Italic.
+	Style font.Style
+
+	// Weight is the weight of a font, such as Normal or Bold.
+	Weight font.Weight
+
+	// Size is the size of the font.
+	Size Length
+}
+
+// Name returns a fully qualified name for the given font.
+func (f *Font) Name() string {
+	v := f.Variant
+	w := weightName(f.Weight)
+	s := styleName(f.Style)
+
+	switch f.Style {
+	case font.StyleNormal:
+		s = ""
+		if f.Weight == font.WeightNormal {
+			w = "Regular"
+		}
+	default:
+		if f.Weight == font.WeightNormal {
+			w = ""
+		}
+	}
+
+	return fmt.Sprintf("%s%s-%s%s", f.Typeface, v, w, s)
+}
+
+// From returns a copy of the provided font with its size set.
+func From(fnt Font, size Length) Font {
+	o := fnt
+	o.Size = size
+	return o
+}
+
+// Typeface identifies a particular typeface design.
+// The empty string denotes the default typeface.
+type Typeface string
+
+// Variant denotes a typeface variant, such as "Mono", "Smallcaps" or "Math".
+type Variant string
+
+// Extents contains font metric information.
+type Extents struct {
+	// Ascent is the distance that the text
+	// extends above the baseline.
+	Ascent Length
+
+	// Descent is the distance that the text
+	// extends below the baseline. The descent
+	// is given as a positive value.
+	Descent Length
+
+	// Height is the distance from the lowest
+	// descending point to the highest ascending
+	// point.
+	Height Length
+}
+
+// Face holds a font descriptor and the associated font face.
+type Face struct {
+	Font Font
+	Face *opentype.Font
+}
+
+// Name returns a fully qualified name for the given font.
+func (f *Face) Name() string {
+	return f.Font.Name()
+}
+
+// FontFace returns the opentype font face for the requested
+// dots-per-inch resolution.
+func (f *Face) FontFace(dpi float64) font.Face {
+	face, err := opentype.NewFace(f.Face, &opentype.FaceOptions{
+		Size: f.Font.Size.Points(),
+		DPI:  dpi,
+	})
+	if err != nil {
+		panic(err)
+	}
+	return face
+}
+
+// default hinting for OpenType fonts
+const defaultHinting = font.HintingNone
+
+// Extents returns the FontExtents for a font.
+func (f *Face) Extents() Extents {
+	var (
+		// TODO(sbinet): re-use a Font-level sfnt.Buffer instead?
+		buf  sfnt.Buffer
+		ppem = fixed.Int26_6(f.Face.UnitsPerEm())
+	)
+
+	met, err := f.Face.Metrics(&buf, ppem, defaultHinting)
+	if err != nil {
+		panic(fmt.Errorf("could not extract font extents: %v", err))
+	}
+	scale := f.Font.Size / Points(float64(ppem))
+	return Extents{
+		Ascent:  Points(float64(met.Ascent)) * scale,
+		Descent: Points(float64(met.Descent)) * scale,
+		Height:  Points(float64(met.Height)) * scale,
+	}
+}
+
+// Width returns width of a string when drawn using the font.
+func (f *Face) Width(s string) Length {
+	var (
+		pixelsPerEm = fixed.Int26_6(f.Face.UnitsPerEm())
+
+		// scale converts sfnt.Unit to float64
+		scale = f.Font.Size / Points(float64(pixelsPerEm))
+
+		width     = 0
+		hasPrev   = false
+		buf       sfnt.Buffer
+		prev, idx sfnt.GlyphIndex
+		hinting   = defaultHinting
+	)
+	for _, rune := range s {
+		var err error
+		idx, err = f.Face.GlyphIndex(&buf, rune)
+		if err != nil {
+			panic(fmt.Errorf("could not get glyph index: %v", err))
+		}
+		if hasPrev {
+			kern, err := f.Face.Kern(&buf, prev, idx, pixelsPerEm, hinting)
+			switch {
+			case err == nil:
+				width += int(kern)
+			case errors.Is(err, sfnt.ErrNotFound):
+				// no-op
+			default:
+				panic(fmt.Errorf("could not get kerning: %v", err))
+			}
+		}
+		adv, err := f.Face.GlyphAdvance(&buf, idx, pixelsPerEm, hinting)
+		if err != nil {
+			panic(fmt.Errorf("could not retrieve glyph's advance: %v", err))
+		}
+		width += int(adv)
+		prev, hasPrev = idx, true
+	}
+	return Points(float64(width)) * scale
+}
+
+// Collection is a collection of fonts, regrouped under a common typeface.
+type Collection []Face
+
+// Cache collects font faces.
+type Cache struct {
+	mu    sync.RWMutex
+	def   Typeface
+	faces map[Font]*opentype.Font
+}
+
+// We make Cache implement dummy GobDecoder and GobEncoder interfaces
+// to allow plot.Plot (or any other type holding a Cache) to be (de)serialized
+// with encoding/gob.
+// As Cache holds opentype.Font, the reflect-based gob (de)serialization can not
+// work: gob isn't happy with opentype.Font having no exported field:
+//
+//   error: gob: type font.Cache has no exported fields
+//
+// FIXME(sbinet): perhaps encode/decode Cache.def typeface?
+
+func (c *Cache) GobEncode() ([]byte, error) { return nil, nil }
+func (c *Cache) GobDecode([]byte) error {
+	if c.faces == nil {
+		c.faces = make(map[Font]*opentype.Font)
+	}
+	return nil
+}
+
+// NewCache creates a new cache of fonts from the provided collection of
+// font Faces.
+// The first font Face in the collection is set to be the default one.
+func NewCache(coll Collection) *Cache {
+	cache := &Cache{
+		faces: make(map[Font]*opentype.Font, len(coll)),
+	}
+	cache.Add(coll)
+	return cache
+}
+
+// Add adds a whole collection of font Faces to the font cache.
+// If the cache is empty, the first font Face in the collection is set
+// to be the default one.
+func (c *Cache) Add(coll Collection) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.faces == nil {
+		c.faces = make(map[Font]*opentype.Font, len(coll))
+	}
+	for i, f := range coll {
+		if i == 0 && c.def == "" {
+			c.def = f.Font.Typeface
+		}
+		fnt := f.Font
+		fnt.Size = 0 // store all font descriptors with the same size.
+		c.faces[fnt] = f.Face
+	}
+}
+
+// Lookup returns the font Face corresponding to the provided Font descriptor,
+// with the provided font size set.
+//
+// If no matching font Face could be found, the one corresponding to
+// the default typeface is selected and returned.
+func (c *Cache) Lookup(fnt Font, size Length) Face {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	if len(c.faces) == 0 {
+		return Face{}
+	}
+
+	face := c.lookup(fnt)
+	if face == nil {
+		fnt.Typeface = c.def
+		face = c.lookup(fnt)
+	}
+
+	ff := Face{
+		Font: fnt,
+		Face: face,
+	}
+	ff.Font.Size = size
+	return ff
+}
+
+// Has returns whether the cache contains the exact font descriptor.
+func (c *Cache) Has(fnt Font) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	face := c.lookup(fnt)
+	return face != nil
+}
+
+func (c *Cache) lookup(key Font) *opentype.Font {
+	key.Size = 0
+
+	tf := c.faces[key]
+	if tf == nil {
+		key := key
+		key.Weight = font.WeightNormal
+		tf = c.faces[key]
+	}
+	if tf == nil {
+		key := key
+		key.Style = font.StyleNormal
+		tf = c.faces[key]
+	}
+	if tf == nil {
+		key := key
+		key.Style = font.StyleNormal
+		key.Weight = font.WeightNormal
+		tf = c.faces[key]
+	}
+
+	return tf
+}
+
+func weightName(w font.Weight) string {
+	switch w {
+	case font.WeightThin:
+		return "Thin"
+	case font.WeightExtraLight:
+		return "ExtraLight"
+	case font.WeightLight:
+		return "Light"
+	case font.WeightNormal:
+		return "Regular"
+	case font.WeightMedium:
+		return "Medium"
+	case font.WeightSemiBold:
+		return "SemiBold"
+	case font.WeightBold:
+		return "Bold"
+	case font.WeightExtraBold:
+		return "ExtraBold"
+	case font.WeightBlack:
+		return "Black"
+	}
+	return fmt.Sprintf("weight(%d)", w)
+}
+
+func styleName(sty font.Style) string {
+	switch sty {
+	case font.StyleNormal:
+		return "Normal"
+	case font.StyleItalic:
+		return "Italic"
+	case font.StyleOblique:
+		return "Oblique"
+	}
+	return fmt.Sprintf("style(%d)", sty)
+}

vendor/gonum.org/v1/plot/font/len.go

@@ -0,0 +1,69 @@
+// Copyright ©2021 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 font
+
+import (
+	"strconv"
+	"strings"
+)
+
+// Length is a unit-independent representation of length.
+// Internally, the length is stored in postscript points.
+type Length float64
+
+// Dots returns the length in dots for the given resolution.
+func (l Length) Dots(dpi float64) float64 {
+	return float64(l) / Inch.Points() * dpi
+}
+
+// Points returns the length in postscript points.
+func (l Length) Points() float64 {
+	return float64(l)
+}
+
+// Common lengths.
+const (
+	Inch       Length = 72
+	Centimeter        = Inch / 2.54
+	Millimeter        = Centimeter / 10
+)
+
+// Points returns a length for the given number of points.
+func Points(pt float64) Length {
+	return Length(pt)
+}
+
+// ParseLength parses a Length string.
+// A Length string is a possible signed floating number with a unit.
+// e.g. "42cm" "2.4in" "66pt"
+// If no unit was given, ParseLength assumes it was (postscript) points.
+// Currently valid units are:
+//
+//   - mm (millimeter)
+//   - cm (centimeter)
+//   - in (inch)
+//   - pt (point)
+func ParseLength(value string) (Length, error) {
+	var unit Length = 1
+	switch {
+	case strings.HasSuffix(value, "in"):
+		value = value[:len(value)-len("in")]
+		unit = Inch
+	case strings.HasSuffix(value, "cm"):
+		value = value[:len(value)-len("cm")]
+		unit = Centimeter
+	case strings.HasSuffix(value, "mm"):
+		value = value[:len(value)-len("mm")]
+		unit = Millimeter
+	case strings.HasSuffix(value, "pt"):
+		value = value[:len(value)-len("pt")]
+		unit = 1
+	}
+	v, err := strconv.ParseFloat(value, 64)
+	if err != nil {
+		return 0, err
+	}
+	return Length(v) * unit, nil
+}

vendor/gonum.org/v1/plot/font/liberation/liberation.go

@@ -0,0 +1,97 @@
+// Copyright ©2021 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 liberation exports the Liberation fonts as a font.Collection.
+package liberation // import "gonum.org/v1/plot/font/liberation"
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/go-fonts/liberation/liberationmonobold"
+	"github.com/go-fonts/liberation/liberationmonobolditalic"
+	"github.com/go-fonts/liberation/liberationmonoitalic"
+	"github.com/go-fonts/liberation/liberationmonoregular"
+	"github.com/go-fonts/liberation/liberationsansbold"
+	"github.com/go-fonts/liberation/liberationsansbolditalic"
+	"github.com/go-fonts/liberation/liberationsansitalic"
+	"github.com/go-fonts/liberation/liberationsansregular"
+	"github.com/go-fonts/liberation/liberationserifbold"
+	"github.com/go-fonts/liberation/liberationserifbolditalic"
+	"github.com/go-fonts/liberation/liberationserifitalic"
+	"github.com/go-fonts/liberation/liberationserifregular"
+	stdfnt "golang.org/x/image/font"
+	"golang.org/x/image/font/opentype"
+
+	"gonum.org/v1/plot/font"
+)
+
+var (
+	once       sync.Once
+	collection font.Collection
+)
+
+func Collection() font.Collection {
+	once.Do(func() {
+		addColl(font.Font{}, liberationserifregular.TTF)
+		addColl(font.Font{Style: stdfnt.StyleItalic}, liberationserifitalic.TTF)
+		addColl(font.Font{Weight: stdfnt.WeightBold}, liberationserifbold.TTF)
+		addColl(font.Font{
+			Style:  stdfnt.StyleItalic,
+			Weight: stdfnt.WeightBold,
+		}, liberationserifbolditalic.TTF)
+
+		// mono variant
+		addColl(font.Font{Variant: "Mono"}, liberationmonoregular.TTF)
+		addColl(font.Font{
+			Variant: "Mono",
+			Style:   stdfnt.StyleItalic,
+		}, liberationmonoitalic.TTF)
+		addColl(font.Font{
+			Variant: "Mono",
+			Weight:  stdfnt.WeightBold,
+		}, liberationmonobold.TTF)
+		addColl(font.Font{
+			Variant: "Mono",
+			Style:   stdfnt.StyleItalic,
+			Weight:  stdfnt.WeightBold,
+		}, liberationmonobolditalic.TTF)
+
+		// sans-serif variant
+		addColl(font.Font{Variant: "Sans"}, liberationsansregular.TTF)
+		addColl(font.Font{
+			Variant: "Sans",
+			Style:   stdfnt.StyleItalic,
+		}, liberationsansitalic.TTF)
+		addColl(font.Font{
+			Variant: "Sans",
+			Weight:  stdfnt.WeightBold,
+		}, liberationsansbold.TTF)
+		addColl(font.Font{
+			Variant: "Sans",
+			Style:   stdfnt.StyleItalic,
+			Weight:  stdfnt.WeightBold,
+		}, liberationsansbolditalic.TTF)
+
+		n := len(collection)
+		collection = collection[:n:n]
+	})
+
+	return collection
+}
+
+func addColl(fnt font.Font, ttf []byte) {
+	face, err := opentype.Parse(ttf)
+	if err != nil {
+		panic(fmt.Errorf("vg: could not parse font: %+v", err))
+	}
+	fnt.Typeface = "Liberation"
+	if fnt.Variant == "" {
+		fnt.Variant = "Serif"
+	}
+	collection = append(collection, font.Face{
+		Font: fnt,
+		Face: face,
+	})
+}