apply PRs from golang/freetype: golang#70, golang#86; set UseNonZeroWinding = true in rasterizer; return !ok in GlyphAdvance if rune index == 0, consistent with opentype.

Author: Randall C. O'Reilly

CONTRIBUTORS

@@ -27,10 +27,12 @@
 # Please keep the list sorted.
 
 Andrew Gerrand <[email protected]>
+Dmitri Shuralyov <[email protected]>
 Jeff R. Allen <[email protected]> <[email protected]>
 Maksim Kochkin <[email protected]>
 Michael Fogleman <[email protected]>
 Nigel Tao <[email protected]>
+Randall O'Reilly <[email protected]>
 Rémy Oudompheng <[email protected]> <[email protected]>
 Rob Pike <[email protected]>
 Roger Peppe <[email protected]>

freetype.go

@@ -78,7 +78,7 @@ type Context struct {
 // PointToFixed converts the given number of points (as in "a 12 point font")
 // into a 26.6 fixed point number of pixels.
 func (c *Context) PointToFixed(x float64) fixed.Int26_6 {
-	return fixed.Int26_6(x * float64(c.dpi) * (64.0 / 72.0))
+	return fixed.Int26_6(0.5 + (x * c.dpi * 64 / 72))
 }
 
 // drawContour draws the given closed contour with the given offset.
@@ -260,7 +260,7 @@ func (c *Context) DrawString(s string, p fixed.Point26_6) (fixed.Point26_6, erro
 // recalc recalculates scale and bounds values from the font size, screen
 // resolution and font metrics, and invalidates the glyph cache.
 func (c *Context) recalc() {
-	c.scale = fixed.Int26_6(c.fontSize * c.dpi * (64.0 / 72.0))
+	c.scale = fixed.Int26_6(0.5 + (c.fontSize * c.dpi * 64 / 72))
 	if c.f == nil {
 		c.r.SetBounds(0, 0)
 	} else {
@@ -332,10 +332,12 @@ func (c *Context) SetClip(clip image.Rectangle) {
 
 // NewContext creates a new Context.
 func NewContext() *Context {
-	return &Context{
+	c := &Context{
 		r:        raster.NewRasterizer(0, 0),
 		fontSize: 12,
 		dpi:      72,
 		scale:    12 << 6,
 	}
+	c.r.UseNonZeroWinding = true // needed for font rendering
+	return c
 }

freetype_test.go

@@ -12,6 +12,8 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+
+	"golang.org/x/image/math/fixed"
 )
 
 func BenchmarkDrawString(b *testing.B) {
@@ -57,3 +59,26 @@ func BenchmarkDrawString(b *testing.B) {
 	mallocs = ms.Mallocs - mallocs
 	b.Logf("%d iterations, %d mallocs per iteration\n", b.N, int(mallocs)/b.N)
 }
+
+func TestScaling(t *testing.T) {
+	c := NewContext()
+	for _, tc := range [...]struct {
+		in   float64
+		want fixed.Int26_6
+	}{
+		{in: 12, want: fixed.I(12)},
+		{in: 11.992, want: fixed.I(12) - 1},
+		{in: 11.993, want: fixed.I(12)},
+		{in: 12.007, want: fixed.I(12)},
+		{in: 12.008, want: fixed.I(12) + 1},
+		{in: 86.4, want: fixed.Int26_6(86<<6 + 26)}, // Issue https://github.com/golang/freetype/issues/85.
+	} {
+		c.SetFontSize(tc.in)
+		if got, want := c.scale, tc.want; got != want {
+			t.Errorf("scale after SetFontSize(%v) = %v, want %v", tc.in, got, want)
+		}
+		if got, want := c.PointToFixed(tc.in), tc.want; got != want {
+			t.Errorf("PointToFixed(%v) = %v, want %v", tc.in, got, want)
+		}
+	}
+}

truetype/face.go

@@ -139,11 +139,12 @@ func (o *Options) subPixelsY() (value uint32, halfQuantum, mask fixed.Int26_6) {
 //
 // For example, q == 4 leads to a bias of 8 and a mask of 0xfffffff0, or -16,
 // because we want to round fractions of fixed.Int26_6 as:
-//	-  0 to  7 rounds to 0.
-//	-  8 to 23 rounds to 16.
-//	- 24 to 39 rounds to 32.
-//	- 40 to 55 rounds to 48.
-//	- 56 to 63 rounds to 64.
+//   - 0 to  7 rounds to 0.
+//   - 8 to 23 rounds to 16.
+//   - 24 to 39 rounds to 32.
+//   - 40 to 55 rounds to 48.
+//   - 56 to 63 rounds to 64.
+//
 // which means to add 8 and then bitwise-and with -16, in two's complement
 // representation.
 //
@@ -205,6 +206,7 @@ func NewFace(f *Font, opts *Options) IndexableFace {
 		glyphCache: make([]glyphCacheEntry, opts.glyphCacheEntries()),
 		stroke:     fixed.I(opts.Stroke * 2),
 	}
+	a.r.UseNonZeroWinding = true // key for fonts
 	a.subPixelX, a.subPixelBiasX, a.subPixelMaskX = opts.subPixelsX()
 	a.subPixelY, a.subPixelBiasY, a.subPixelMaskY = opts.subPixelsY()
 
@@ -388,13 +390,15 @@ func (a *face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
 	}
 	advance, ok = a.advanceCache[r]
 	if ok {
-		return
+		idx := a.index(r)
+		return advance, (idx != 0)
 	}
-	if err := a.glyphBuf.Load(a.f, a.scale, a.index(r), a.hinting); err != nil {
+	idx := a.index(r)
+	if err := a.glyphBuf.Load(a.f, a.scale, idx, a.hinting); err != nil {
 		return 0, false
 	}
 	a.advanceCache[r] = a.glyphBuf.AdvanceWidth
-	return a.glyphBuf.AdvanceWidth, true
+	return a.glyphBuf.AdvanceWidth, (idx != 0)
 }
 
 // rasterize returns the advance width, integer-pixel offset to render at, and

truetype/truetype.go

@@ -19,7 +19,10 @@
 package truetype
 
 import (
+	"bytes"
 	"fmt"
+	"unicode/utf16"
+	"unicode/utf8"
 
 	"golang.org/x/image/math/fixed"
 )
@@ -429,20 +432,27 @@ func (f *Font) Name(id NameID) string {
 	// Return the ASCII value of the encoded string.
 	// The string is encoded as UTF-16 on non-Apple platformIDs; Apple is platformID 1.
 	src := f.name[offset : offset+length]
-	var dst []byte
 	if platformID != 1 { // UTF-16.
 		if len(src)&1 != 0 {
 			return ""
 		}
-		dst = make([]byte, len(src)/2)
-		for i := range dst {
-			dst[i] = printable(u16(src, 2*i))
-		}
-	} else { // ASCII.
-		dst = make([]byte, len(src))
-		for i, c := range src {
-			dst[i] = printable(uint16(c))
+		lb := len(src) / 2
+		b8buf := make([]byte, 4)
+		u16s := make([]uint16, 1)
+		var buf bytes.Buffer
+		for i := 0; i < lb; i++ {
+			u16s[0] = u16(src, i)
+			r := utf16.Decode(u16s)
+			n := utf8.EncodeRune(b8buf, r[0])
+			buf.Write([]byte(string(b8buf[:n])))
 		}
+		return buf.String()
+	}
+	// ASCII.
+	var dst []byte
+	dst = make([]byte, len(src))
+	for i, c := range src {
+		dst[i] = printable(uint16(c))
 	}
 	return string(dst)
 }