From 3ba1c0f728fbb786ef684f38448d95355953abe7 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 30 Aug 2015 22:27:18 +1000 Subject: [PATCH] Rename Point and End slices to Points and Ends. The slice Foos is plural; it refers to multiple elements. The element Foos[i] is the i'th Foo. --- example/truetype/main.go | 4 +- freetype.go | 4 +- truetype/face.go | 4 +- truetype/glyph.go | 118 +++++++++++++++++++------------------- truetype/truetype_test.go | 10 ++-- 5 files changed, 70 insertions(+), 70 deletions(-) diff --git a/example/truetype/main.go b/example/truetype/main.go index af98224..8e5e4b3 100644 --- a/example/truetype/main.go +++ b/example/truetype/main.go @@ -31,14 +31,14 @@ func printGlyph(g *truetype.GlyphBuf) { printBounds(g.Bounds) fmt.Print("Points:\n---\n") e := 0 - for i, p := range g.Point { + for i, p := range g.Points { fmt.Printf("%4d, %4d", p.X, p.Y) if p.Flags&0x01 != 0 { fmt.Print(" on\n") } else { fmt.Print(" off\n") } - if i+1 == int(g.End[e]) { + if i+1 == int(g.Ends[e]) { fmt.Print("---\n") e++ } diff --git a/freetype.go b/freetype.go index 0ae56ad..b5da063 100644 --- a/freetype.go +++ b/freetype.go @@ -182,8 +182,8 @@ func (c *Context) rasterize(glyph truetype.Index, fx, fy fixed.Int26_6) ( // Rasterize the glyph's vectors. c.r.Clear() e0 := 0 - for _, e1 := range c.glyphBuf.End { - c.drawContour(c.glyphBuf.Point[e0:e1], fx, fy) + for _, e1 := range c.glyphBuf.Ends { + c.drawContour(c.glyphBuf.Points[e0:e1], fx, fy) e0 = e1 } a := image.NewAlpha(image.Rect(0, 0, xmax-xmin, ymax-ymin)) diff --git a/truetype/face.go b/truetype/face.go index dc66675..3f2ce2f 100644 --- a/truetype/face.go +++ b/truetype/face.go @@ -345,8 +345,8 @@ func (a *face) rasterize(index Index, fx, fy fixed.Int26_6) (v cacheVal, ok bool pixOffset := a.paintOffset * a.maxw clear(a.masks.Pix[pixOffset : pixOffset+a.maxw*a.maxh]) e0 := 0 - for _, e1 := range a.glyphBuf.End { - a.drawContour(a.glyphBuf.Point[e0:e1], fx, fy) + for _, e1 := range a.glyphBuf.Ends { + a.drawContour(a.glyphBuf.Points[e0:e1], fx, fy) e0 = e1 } a.r.Rasterize(a.p) diff --git a/truetype/glyph.go b/truetype/glyph.go index 411e1b7..5e187ca 100644 --- a/truetype/glyph.go +++ b/truetype/glyph.go @@ -28,16 +28,16 @@ type GlyphBuf struct { AdvanceWidth fixed.Int26_6 // Bounds is the glyph's bounding box. Bounds fixed.Rectangle26_6 - // Point contains all Points from all contours of the glyph. If - // hinting was used to load a glyph then Unhinted contains those - // Points before they were hinted, and InFontUnits contains those - // Points before they were hinted and scaled. - Point, Unhinted, InFontUnits []Point - // End is the point indexes of the end point of each countour. The - // length of End is the number of contours in the glyph. The i'th - // contour consists of points Point[End[i-1]:End[i]], where End[-1] - // is interpreted to mean zero. - End []int + // Points contains all Points from all contours of the glyph. If hinting + // was used to load a glyph then Unhinted contains those Points before they + // were hinted, and InFontUnits contains those Points before they were + // hinted and scaled. + Points, Unhinted, InFontUnits []Point + // Ends is the point indexes of the end point of each contour. The length + // of Ends is the number of contours in the glyph. The i'th contour + // consists of points Points[Ends[i-1]:Ends[i]], where Ends[-1] is + // interpreted to mean zero. + Ends []int font *Font scale fixed.Int26_6 @@ -83,10 +83,10 @@ const ( // contours for this GlyphBuf. scale is the number of 26.6 fixed point units in // 1 em, i is the glyph index, and h is the hinting policy. func (g *GlyphBuf) Load(f *Font, scale fixed.Int26_6, i Index, h font.Hinting) error { - g.Point = g.Point[:0] + g.Points = g.Points[:0] g.Unhinted = g.Unhinted[:0] g.InFontUnits = g.InFontUnits[:0] - g.End = g.End[:0] + g.Ends = g.Ends[:0] g.font = f g.hinting = h g.scale = scale @@ -110,8 +110,8 @@ func (g *GlyphBuf) Load(f *Font, scale fixed.Int26_6, i Index, h font.Hinting) e pp1x = g.phantomPoints[0].X } if pp1x != 0 { - for i := range g.Point { - g.Point[i].X -= pp1x + for i := range g.Points { + g.Points[i].X -= pp1x } } @@ -137,15 +137,15 @@ func (g *GlyphBuf) Load(f *Font, scale fixed.Int26_6, i Index, h font.Hinting) e // themselves. This approach is what C Freetype does. We can't just scale // the nominal bounding box in the glyf data as the hinting process and // phantom point adjustment may move points outside of that box. - if len(g.Point) == 0 { + if len(g.Points) == 0 { g.Bounds = fixed.Rectangle26_6{} } else { - p := g.Point[0] + p := g.Points[0] g.Bounds.Min.X = p.X g.Bounds.Max.X = p.X g.Bounds.Min.Y = p.Y g.Bounds.Max.Y = p.Y - for _, p := range g.Point[1:] { + for _, p := range g.Points[1:] { if g.Bounds.Min.X > p.X { g.Bounds.Min.X = p.X } else if g.Bounds.Max.X < p.X { @@ -206,9 +206,9 @@ func (g *GlyphBuf) load(recursion uint32, i Index, useMyMetrics bool) (err error {X: uhm.AdvanceWidth / 2, Y: boundsYMax + uvm.TopSideBearing - uvm.AdvanceHeight}, } if len(glyf) == 0 { - g.addPhantomsAndScale(len(g.Point), len(g.Point), true, true) - copy(g.phantomPoints[:], g.Point[len(g.Point)-4:]) - g.Point = g.Point[:len(g.Point)-4] + g.addPhantomsAndScale(len(g.Points), len(g.Points), true, true) + copy(g.phantomPoints[:], g.Points[len(g.Points)-4:]) + g.Points = g.Points[:len(g.Points)-4] return nil } @@ -224,18 +224,18 @@ func (g *GlyphBuf) load(recursion uint32, i Index, useMyMetrics bool) (err error return err } } else { - np0, ne0 := len(g.Point), len(g.End) + np0, ne0 := len(g.Points), len(g.Ends) program := g.loadSimple(glyf, ne) g.addPhantomsAndScale(np0, np0, true, true) - pp1x = g.Point[len(g.Point)-4].X + pp1x = g.Points[len(g.Points)-4].X if g.hinting != font.HintingNone { if len(program) != 0 { err := g.hinter.run( program, - g.Point[np0:], + g.Points[np0:], g.Unhinted[np0:], g.InFontUnits[np0:], - g.End[ne0:], + g.Ends[ne0:], ) if err != nil { return err @@ -246,15 +246,15 @@ func (g *GlyphBuf) load(recursion uint32, i Index, useMyMetrics bool) (err error g.Unhinted = g.Unhinted[:len(g.Unhinted)-4] } if useMyMetrics { - copy(g.phantomPoints[:], g.Point[len(g.Point)-4:]) + copy(g.phantomPoints[:], g.Points[len(g.Points)-4:]) } - g.Point = g.Point[:len(g.Point)-4] + g.Points = g.Points[:len(g.Points)-4] if np0 != 0 { - // The hinting program expects the []End values to be indexed relative - // to the inner glyph, not the outer glyph, so we delay adding np0 until - // after the hinting program (if any) has run. - for i := ne0; i < len(g.End); i++ { - g.End[i] += np0 + // The hinting program expects the []Ends values to be indexed + // relative to the inner glyph, not the outer glyph, so we delay + // adding np0 until after the hinting program (if any) has run. + for i := ne0; i < len(g.Ends); i++ { + g.Ends[i] += np0 } } } @@ -272,7 +272,7 @@ const loadOffset = 10 func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { offset := loadOffset for i := 0; i < ne; i++ { - g.End = append(g.End, 1+int(u16(glyf, offset))) + g.Ends = append(g.Ends, 1+int(u16(glyf, offset))) offset += 2 } @@ -282,20 +282,20 @@ func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { program = glyf[offset : offset+instrLen] offset += instrLen - np0 := len(g.Point) - np1 := np0 + int(g.End[len(g.End)-1]) + np0 := len(g.Points) + np1 := np0 + int(g.Ends[len(g.Ends)-1]) // Decode the flags. for i := np0; i < np1; { c := uint32(glyf[offset]) offset++ - g.Point = append(g.Point, Point{Flags: c}) + g.Points = append(g.Points, Point{Flags: c}) i++ if c&flagRepeat != 0 { count := glyf[offset] offset++ for ; count > 0; count-- { - g.Point = append(g.Point, Point{Flags: c}) + g.Points = append(g.Points, Point{Flags: c}) i++ } } @@ -304,7 +304,7 @@ func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { // Decode the co-ordinates. var x int16 for i := np0; i < np1; i++ { - f := g.Point[i].Flags + f := g.Points[i].Flags if f&flagXShortVector != 0 { dx := int16(glyf[offset]) offset++ @@ -317,11 +317,11 @@ func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { x += int16(u16(glyf, offset)) offset += 2 } - g.Point[i].X = fixed.Int26_6(x) + g.Points[i].X = fixed.Int26_6(x) } var y int16 for i := np0; i < np1; i++ { - f := g.Point[i].Flags + f := g.Points[i].Flags if f&flagYShortVector != 0 { dy := int16(glyf[offset]) offset++ @@ -334,7 +334,7 @@ func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) { y += int16(u16(glyf, offset)) offset += 2 } - g.Point[i].Y = fixed.Int26_6(y) + g.Points[i].Y = fixed.Int26_6(y) } return program @@ -358,7 +358,7 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, flagUseMyMetrics flagOverlapCompound ) - np0, ne0 := len(g.Point), len(g.End) + np0, ne0 := len(g.Points), len(g.Ends) offset := loadOffset for { flags := u16(glyf, offset) @@ -396,7 +396,7 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, } } savedPP := g.phantomPoints - np0 := len(g.Point) + np0 := len(g.Points) componentUMM := useMyMetrics && (flags&flagUseMyMetrics != 0) if err := g.load(recursion+1, component, componentUMM); err != nil { return err @@ -405,8 +405,8 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, g.phantomPoints = savedPP } if hasTransform { - for j := np0; j < len(g.Point); j++ { - p := &g.Point[j] + for j := np0; j < len(g.Points); j++ { + p := &g.Points[j] newX := 0 + fixed.Int26_6((int64(p.X)*int64(transform[0])+1<<13)>>14) + fixed.Int26_6((int64(p.Y)*int64(transform[2])+1<<13)>>14) @@ -422,8 +422,8 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, dx = (dx + 32) &^ 63 dy = (dy + 32) &^ 63 } - for j := np0; j < len(g.Point); j++ { - p := &g.Point[j] + for j := np0; j < len(g.Points); j++ { + p := &g.Points[j] p.X += dx p.Y += dy } @@ -439,9 +439,9 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, offset += 2 } - g.addPhantomsAndScale(np0, len(g.Point), false, instrLen > 0) - points, ends := g.Point[np0:], g.End[ne0:] - g.Point = g.Point[:len(g.Point)-4] + g.addPhantomsAndScale(np0, len(g.Points), false, instrLen > 0) + points, ends := g.Points[np0:], g.Ends[ne0:] + g.Points = g.Points[:len(g.Points)-4] for j := range points { points[j].Flags &^= flagTouchedX | flagTouchedY } @@ -480,13 +480,13 @@ func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index, func (g *GlyphBuf) addPhantomsAndScale(np0, np1 int, simple, adjust bool) { // Add the four phantom points. - g.Point = append(g.Point, g.phantomPoints[:]...) + g.Points = append(g.Points, g.phantomPoints[:]...) // Scale the points. if simple && g.hinting != font.HintingNone { - g.InFontUnits = append(g.InFontUnits, g.Point[np1:]...) + g.InFontUnits = append(g.InFontUnits, g.Points[np1:]...) } - for i := np1; i < len(g.Point); i++ { - p := &g.Point[i] + for i := np1; i < len(g.Points); i++ { + p := &g.Points[i] p.X = g.font.scale(g.scale * p.X) p.Y = g.font.scale(g.scale * p.Y) } @@ -499,19 +499,19 @@ func (g *GlyphBuf) addPhantomsAndScale(np0, np1 int, simple, adjust bool) { // we update the compatibility tests to C Freetype 2.5.3. // See http://git.savannah.gnu.org/cgit/freetype/freetype2.git/commit/?id=05c786d990390a7ca18e62962641dac740bacb06 if adjust { - pp1x := g.Point[len(g.Point)-4].X + pp1x := g.Points[len(g.Points)-4].X if dx := ((pp1x + 32) &^ 63) - pp1x; dx != 0 { - for i := np0; i < len(g.Point); i++ { - g.Point[i].X += dx + for i := np0; i < len(g.Points); i++ { + g.Points[i].X += dx } } } if simple { - g.Unhinted = append(g.Unhinted, g.Point[np1:]...) + g.Unhinted = append(g.Unhinted, g.Points[np1:]...) } // Round the 2nd and 4th phantom point to the grid. - p := &g.Point[len(g.Point)-3] + p := &g.Points[len(g.Points)-3] p.X = (p.X + 32) &^ 63 - p = &g.Point[len(g.Point)-1] + p = &g.Points[len(g.Points)-1] p.Y = (p.Y + 32) &^ 63 } diff --git a/truetype/truetype_test.go b/truetype/truetype_test.go index b7cc0ad..8299acf 100644 --- a/truetype/truetype_test.go +++ b/truetype/truetype_test.go @@ -83,12 +83,12 @@ func TestParse(t *testing.T) { } g0 := &GlyphBuf{ Bounds: g.Bounds, - Point: g.Point, - End: g.End, + Points: g.Points, + Ends: g.Ends, } g1 := &GlyphBuf{ Bounds: mkBounds(19, 0, 1342, 1480), - Point: []Point{ + Points: []Point{ {19, 0, 51}, {581, 1480, 1}, {789, 1480, 51}, @@ -101,7 +101,7 @@ func TestParse(t *testing.T) { {904, 566, 33}, {667, 1200, 3}, }, - End: []int{8, 11}, + Ends: []int{8, 11}, } if got, want := fmt.Sprint(g0), fmt.Sprint(g1); got != want { t.Errorf("GlyphBuf:\ngot %v\nwant %v", got, want) @@ -341,7 +341,7 @@ func testScaling(t *testing.T, h font.Hinting) { got := scalingTestData{ advanceWidth: glyphBuf.AdvanceWidth, bounds: glyphBuf.Bounds, - points: glyphBuf.Point, + points: glyphBuf.Points, } if got.advanceWidth != want.advanceWidth {