in hint.go line 671:

curDist := dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.dv)

as per the specifications:
https://developer.apple.com/fonts/TrueType-Reference-Manual/RM05/Chap5.html#IP

I think the distance should be computed using the projection vector and not the 
dual vector.  (h.gs.pv instead of h.gs.dv)

correct line:
curDist := dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.pv)

The equivalent code in Freetype is:
distance = CUR_Func_project( CUR.zp1.cur + point,
                                 CUR.zp0.cur + CUR.GS.rp0 );

Where CUR_Func_project use the projection vector:
return TT_DotFix14( (FT_UInt32)dx, (FT_UInt32)dy,
                        CUR.GS.projVector.x,
                        CUR.GS.projVector.y );

I would like to be able to get at the font name(s) stored in the truetype in 
the font file. 

// A MonochromePainter wraps another Painter, quantizing each Span's alpha to
// be either fully opaque or fully transparent.

package main

import (
    "github.com/jung-kurt/gofpdf"
    "github.com/golang/freetype"
    "image"
    "fmt"
    "os"
    "bytes"
    "image/jpeg"
    "io/ioutil"
    "image/draw"
)

func main() {
    pwd, err := os.Getwd()
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    dataFont, err := ioutil.ReadFile(pwd + "/font/luxisr.ttf")
    if err != nil {
        fmt.Printf("%v",err)
    }
    f, err := freetype.ParseFont(dataFont)
    if err != nil {
        fmt.Printf("%v",err)
    }
    dst := image.NewRGBA(image.Rect(0, 0, 800, 600))
    draw.Draw(dst, dst.Bounds(), image.White, image.ZP, draw.Src)
    c := freetype.NewContext()
    c.SetDst(dst)
    c.SetClip(dst.Bounds())
    c.SetSrc(image.Black)
    c.SetFont(f)
    c.DrawString("русский текст", freetype.Pt(0, 16))
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()
    buf := new(bytes.Buffer)
    err = jpeg.Encode(buf, dst, nil)

    if err != nil {
        fmt.Printf("%v",err)
    }

    reader := bytes.NewReader(buf.Bytes())
    textName := "text1"
    pdf.RegisterImageReader(textName, "jpg", reader)
    pdf.Image(textName, 15, 15, 0, 0, false, "jpg", 0, "")
    pdf.OutputFileAndClose("test.pdf")
}

I have no idea how to submit patches, so forgive me if this is an inappropriate 
venue.

Attached is a patch fixing TTC parsing.
The constant 12 was hardcoded instead of using `offset`.

Tested on a TTC v2.0 file, I don't have a v1.0 file to test on but based on 
what I understand of the file format I don't think there should be any issues 
with that.

the line 1346 - 1347 looks weird 
1346 n := f26dot6(h.stack[top])

This may be pedantic, but "n" in this case is a counter used for the loop at 
line 1350: "for ; n > 0; n--"
It is in no way a 26.6 fixed point value so why cast it to f26dot6 ?
------
line 1347  if top < 2*int(h.gs.loop) { 
This may be a copy/paste error, I don't see how the gs.loop value has anything 
to do with deltaP or deltaC.
I'm assuming you want:
line 1347  if top < 2*n { 

What steps will reproduce the problem?
1. Use a non-image.Uniform image in SetSrc.
2. Call freetype.DrawString

What is the expected output? What do you see instead?
I'd expect that the src passed to c.SetSrc gets composited with the destination 
with the two images aligned.

Instead, for each glyph, a region (0, 0) to (w, h) gets used from src, where w, 
h are the dimensions of the glyph, with the result that the actual colors taken 
from src depending on the height of the rendered glyph and adjacent glyphs are 
inconsistently colored.

What version of the product are you using? On what operating system?
Lion on mac, but I'm sure that's irrelevant.


Please provide any additional information below.

In: http://code.google.com/p/freetype-go/source/browse/freetype/freetype.go#212
I think image.ZP should be dr.Min, or possibly adjusted to align src.Min and 
dst.Min.
The comment would need fixing too to specify the meaning of the SetSrc value.

Attached is a variant of one of the example files that exhibits the problem. 
I've tried to make the colors as nasty as possible to make the problem visible. 
I've also attached a png with the output.

cm@ubuntu:~/go/src/pkg/github.com/chsc/gogl$ sudo /home/cm/go/bin/go get 
code.google.com/p/freetype-go/freetype
package code.google.com/p/freetype-go/freetype
    imports fmt: unrecognized import path "fmt"
package code.google.com/p/freetype-go/freetype
    imports image: unrecognized import path "image"
package code.google.com/p/freetype-go/freetype
    imports image/color: unrecognized import path "image/color"
package code.google.com/p/freetype-go/freetype
    imports image/draw: unrecognized import path "image/draw"
package code.google.com/p/freetype-go/freetype
    imports math: unrecognized import path "math"
package code.google.com/p/freetype-go/freetype
    imports runtime: unrecognized import path "runtime"
package code.google.com/p/freetype-go/freetype
    imports strconv: unrecognized import path "strconv"
package code.google.com/p/freetype-go/freetype
    imports errors: unrecognized import path "errors"

From a Go synced/built from "release" branch:

$ goinstall freetype-go.googlecode.com/hg/freetype
/bin/bash: === cd 
/home/shutej/go/src/pkg/freetype-go.googlecode.com/hg/freetype/raster; bash 
gomake -f- install
6g  -o _go_.6 geom.go paint.go raster.go stroke.go 
paint.go:65: cannot convert c (type image.AlphaColor) to type int
paint.go:66: cannot use uint8((v * 255 + (255 - v) * a) / 255) (type uint8) as 
type image.AlphaColor in assignment
paint.go:105: cannot use color (type uint8) as type image.AlphaColor in 
assignment
paint.go:150: cannot convert r.Image.Pix[i + 0] (type image.RGBAColor) to type 
uint32
paint.go:151: cannot convert r.Image.Pix[i + 1] (type image.RGBAColor) to type 
uint32
paint.go:152: cannot convert r.Image.Pix[i + 2] (type image.RGBAColor) to type 
uint32
paint.go:153: cannot convert r.Image.Pix[i + 3] (type image.RGBAColor) to type 
uint32
paint.go:155: cannot use uint8((dr * a + r.cr * ma) / m >> 8) (type uint8) as 
type image.RGBAColor in assignment
paint.go:156: cannot use uint8((dg * a + r.cg * ma) / m >> 8) (type uint8) as 
type image.RGBAColor in assignment
paint.go:157: cannot use uint8((db * a + r.cb * ma) / m >> 8) (type uint8) as 
type image.RGBAColor in assignment
paint.go:157: too many errors
make: *** [_go_.6] Error 1
--- exit status 2
goinstall: installing: running bash: exit status 2

These are needed to figure out line height and the height for the background of 
highlighted text. Font.Bounds().YMin and YMax don't work; they are too large. 
Instead we need ascent and descent from the hhea table.

Freetype-go generates artifacts close to start and end path points,
output differs from Freetype-C.

Font is automatically converted from C to Q by FontForge, no problems detected.
Rearanged canonical start point to leftmost on the contour produces expected 
output.

bin, err := ioutil.ReadFile("DroidSans.ttf")
if err != nil {
    log.Fatal(err)
}
f, err := truetype.Parse(bin)
if err != nil {
    log.Fatal(err)
}

fc := truetype.NewFace(f, &truetype.Options{
    Size:    240,
    DPI:     72,
    Hinting: font.HintingNone,
})

fmt.Printf("metrics %+v\n", fc.Metrics())
// Output: metrics {Height:240:00 Ascent:222:50 Descent:56:39}
fmt.Printf("ascent+descent %v\n", fc.Metrics().Ascent+fc.Metrics().Descent)
// Output: ascent+descent 279:25

With freetype-go, is there a way to compute the text extents (width and height) 
of a string given a particular font and size *before* rendering the text?

I've looked around in the source code, and it *appears* that the right 
information is there, but I can't quite seem to figure out how to do it.

As of right now, if I want an image that "snugly" fits some string, I do the 
following:

Over estimate the extents by multiplying the pixel size of one em unit by the 
length of the string. I get the width/height this way (assuming one line of 
text).

I allocate an image with a rectangle of two points: (0, 0) and (width, height).

After rendering the text to the image using DrawText, I use the point returned 
from DrawText to take a sub-image of the initial image. (I convert this point 
to a (x, y) position by simply dividing the X and Y of the point by 256. It 
seems to work OK, but I have no idea if this is correct.)

--------------

And one last question: would the extents include the entire bounding box of the 
string? The (x,y) position returned by DrawText doesn't seem to cover the parts 
of the text the dip below the text's base line. Like the tail in the 'y'. My 
solution has just been to pad the 'y' with a few pixels, but I know this is not 
optimal since it will break if the font size changes too much.

(My apologies if my terminology is off. I don't have much experience in font 
rendering.)

I would happily submit a patch if I was nudged in the right direction :-)

Thanks!

$ dep ensure -add firebase.google.com/go
The following errors occurred while deducing packages:
  * "code.google.com/p/freetype-go/freetype/raster": unable to deduce repository and source type for "code.google.com/p/freetype-go/freetype/raster": unable to read metadata: go-import metadata not found

validateParams: could not deduce external imports' project roots

$ dep version
dep:
 version     : v0.4.1
 build date  : 2018-01-27
 git hash    : 37d9ea0
 go version  : go1.9.3
 go compiler : gc
 platform    : darwin/amd64

pt := freetype.Pt(0,440 + int(f.PointToFixed(26)) >> 8) 

aguai@Sherlock:example/freetype>>$ cat main.go                                       =03-06 00:31=
// Copyright 2010 The Freetype-Go Authors. All rights reserved.
// Use of this source code is governed by your choice of either the
// FreeType License or the GNU General Public License version 2 (or
// any later version), both of which can be found in the LICENSE file.

// +build ignore
//
// This build tag means that "go install github.com/golang/freetype/..."
// doesn't install this example program. Use "go run main.go" to run it.

package main

import (
    "bufio"
    "flag"
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "image/png"
    "io/ioutil"
    "log"
    "os"

    "github.com/golang/freetype"
    "golang.org/x/image/font"
)

var (
    dpi      = flag.Float64("dpi", 72, "screen resolution in Dots Per Inch")
    fontfile = flag.String("fontfile", "./HanaMinA.ttf", "filename of the ttf font")
    hinting  = flag.String("hinting", "none", "none | full")
    size     = flag.Float64("size", 48, "font size in points")
    spacing  = flag.Float64("spacing", 1.5, "line spacing (e.g. 2 means double spaced)")
    wonb     = flag.Bool("whiteonblack", false, "white text on a black background")
)

var text = []string{
    "руссий текст",
        "𝄝𝄞𝄟𝄠𝄡𝄢𝄣𝄤𝄥 ",
    "亂入啊亂入",
    "One, two! One, two! and through and through"
}

func main() {
    flag.Parse()

    // Read the font data.
    fontBytes, err := ioutil.ReadFile(*fontfile)
    if err != nil {
        log.Println(err)
        return
    }
    f, err := freetype.ParseFont(fontBytes)
    if err != nil {
        log.Println(err)
        return
    }

    // Initialize the context.
    fg, bg := image.Black, image.White
    ruler := color.RGBA{0xdd, 0xdd, 0xdd, 0xff}
    if *wonb {
        fg, bg = image.White, image.Black
        ruler = color.RGBA{0x22, 0x22, 0x22, 0xff}
    }
    rgba := image.NewRGBA(image.Rect(0, 0, 1600, 1000))
    draw.Draw(rgba, rgba.Bounds(), bg, image.ZP, draw.Src)
    c := freetype.NewContext()
    c.SetDPI(*dpi)
    c.SetFont(f)
    c.SetFontSize(*size)
    c.SetClip(rgba.Bounds())
    c.SetDst(rgba)
    c.SetSrc(fg)
    switch *hinting {
    default:
        c.SetHinting(font.HintingNone)
    case "full":
        c.SetHinting(font.HintingFull)
    }

    // Draw the guidelines.
    for i := 0; i < 200; i++ {
        rgba.Set(10, 10+i, ruler)
        rgba.Set(10+i, 10, ruler)
    }

    // Draw the text.
    pt := freetype.Pt(10, 10+int(c.PointToFixed(*size)>>6))
    for _, s := range text {
        _, err = c.DrawString(s, pt)
        if err != nil {
            log.Println(err)
            return
        }
        pt.Y += c.PointToFixed(*size * *spacing)
    }

    // Save that RGBA image to disk.
    outFile, err := os.Create("out.png")
    if err != nil {
        log.Println(err)
        os.Exit(1)
    }
    defer outFile.Close()
    b := bufio.NewWriter(outFile)
    err = png.Encode(b, rgba)
    if err != nil {
        log.Println(err)
        os.Exit(1)
    }
    err = b.Flush()
    if err != nil {
        log.Println(err)
        os.Exit(1)
    }
    fmt.Println("Wrote out.png OK.")
}

When p.X is less than zero, the position of first letter of s is incorrect!

It seems that the truetype package cannot load the OpenSans font.

The font is compatible with other TTF viewers/editors.. so I wonder why I 
receive this error (from freetype.ParseFont() function):

freetype: invalid TrueType format: bad kern table length

Download font at www.opensans.com, I used the OpenSans-Regular.ttf font, but it 
seems all the OpenSans fonts do not parse properly.

Best regards,
Stephen

It is currently not possible to get the bounding box of a specific glyph, and 
thus one can't figure out all the metrics one might need. Please add something 
like func (f *Font) Bounds(scale int32, i Index) Bounds.

The attached archive contains 42 unique crashers for the package. The test 
inputs were passed through the following program:
http://play.golang.org/p/qxzq2QBtYx
The headers of crashes are provided below. Each one of them is unique, i.e. 
crash with a unique panic message and/or at different stack. I physically can't 
file separate issue for each individual crash. Some of the inputs are valid 
TTFs files taken elsewhere.

panic: runtime error: invalid memory address or nil pointer dereference
panic: truetype: hinting: division by zero
panic: truetype: hinting: nested FDEF
panic: runtime error: index out of range
panic: runtime error: index out of range
panic: truetype: hinting: point out of range
panic: truetype: hinting: invalid data
panic: truetype: hinting: undefined function
panic: runtime error: index out of range
panic: truetype: hinting: unimplemented twilight point adjustment
panic: truetype: hinting: unbalanced FDEF
panic: truetype: hinting: call stack underflow
panic: runtime error: index out of range
panic: truetype: hinting: stack underflow
panic: runtime error: invalid memory address or nil pointer dereference
panic: truetype: hinting: insufficient data
panic: runtime error: index out of range
panic: truetype: hinting: unrecognized instruction
panic: freetype: unsupported TrueType feature: negative number of contours
panic: runtime error: index out of range
panic: truetype: hinting: stack overflow
panic: runtime error: index out of range
panic: truetype: hinting: unbalanced IF or ELSE
panic: runtime error: slice bounds out of range
panic: runtime error: index out of range
panic: freetype: unsupported TrueType feature: compound glyph transform vector
panic: runtime error: index out of range
panic: runtime error: slice bounds out of range
panic: truetype: hinting: too many instructions
panic: runtime error: invalid memory address or nil pointer dereference
panic: runtime error: integer divide by zero
panic: truetype: hinting: contour out of range
panic: truetype: hinting: unsupported IDEF instruction
panic: runtime error: integer divide by zero
panic: runtime error: integer divide by zero
panic: hinting: unimplemented SHC instruction
panic: runtime error: slice bounds out of range
panic: runtime error: integer divide by zero
panic: runtime error: index out of range
panic: runtime error: index out of range
panic: runtime error: index out of range
panic: runtime error: index out of range

Hi, I'm currently packaging Go and several modules including this one. Is there 
any reason to have that much AUTHORS / LICENSE / README files? I'd prefer to 
have only those on the top-level. 

Furthermore, the aes and twofish subdirs dont' have working Makefiles, so 
they're currently ignore for package builds. Plans to fix?

ruler := color.RGBA{0xdd, 0xdd, 0xdd, 0xff}
	if *wonb {
		fg, bg = image.White, image.Black
		ruler = color.RGBA{0x22, 0x22, 0x22, 0xff}
	}

//... and then later

	// Draw the guidelines.
	for i := 0; i < 200; i++ {
		rgba.Set(10, 10+i, ruler)
		rgba.Set(10+i, 10, ruler)
	}

I have created a composite image using a background single-color png image and 
a text overlay using freetype-go. However, as you can see from the attached 
image file, some of the color below the image is coming out blurred. Can anyone 
tell me what I am doing wrong? Below is the code I am using to create the image.

func getImage(c *context, imageText string) (*image.RGBA, error) {
    colors := []string{"blue", "green", "orange", "red"}

    flag.Parse()
    //read the image file
    reader, err := os.Open("poll_image_" + colors[rand.Intn(len(colors))] + ".png")
    if err != nil {
        return nil, err
    }
    src, _, err := image.Decode(reader)
    if err != nil {
        return nil, err
    }
    b := src.Bounds()
    rgba := image.NewRGBA(image.Rect(0, 0, *imagewidth, *imageheight))
    draw.Draw(rgba, rgba.Bounds(), src, b.Min, draw.Src)
    // Read the font data.
    fontBytes, err := ioutil.ReadFile(*fontfile)
    if err != nil {
        return nil, err
    }
    font, err := freetype.ParseFont(fontBytes)
    if err != nil {
        return nil, err
    }
    // Initialize the context.
    fg := image.White
    ftc := freetype.NewContext()
    ftc.SetHinting(freetype.NoHinting)
    ftc.SetDPI(*dpi)
    ftc.SetFont(font)
    ftc.SetClip(rgba.Bounds())
    ftc.SetDst(rgba)
    ftc.SetSrc(fg)

    // Draw the text.
    sz := *fontsize
    pt := freetype.Pt(*imageleftmargin, *imagetopmargin+int(ftc.PointToFix32(sz)>>8))
    ftc.SetFontSize(sz)
    lines := getImageTextLines(imageText)
    for _, line := range lines {
        _, err = ftc.DrawString(line, pt)
        if err != nil {
            return nil, err
        }
        pt.Y += ftc.PointToFix32(sz * *linespacing)
    }
    return rgba, nil
}

When stroking polyline with a path, lines are not joined very well 
(see the Attached screenshot, line width is 20) 

I think this is a bug.
below you can see a short extract of the code(gc mean graphic context) that 
stroke a rectangle
func (gc *GC) StrokeRect(line [4]float) { 
        gc.path.Start(toPoint(line[0], line[1])) 
        gc.path.Add1(toPoint(line[2], line[1])) 
        gc.path.Add1(toPoint(line[2], line[3])) 
        gc.path.Add1(toPoint(line[0], line[3])) 
        gc.path.Add1(toPoint(line[0], line[1])) 
        raster.Stroke(gc.rasterizer, gc.path, raster.Fix32(gc.lineWidth*256), nil, nil) 
        b := gc.image.Bounds() 
        mask := image.NewAlpha(b.Dx(), b.Dy()) 
        painter := raster.NewAlphaOverPainter(mask) 
        gc.rasterizer.Rasterize(painter) 
        strokeColor := image.NewColorImage(gc.strokeColor) 
        draw.DrawMask(gc.image, gc.image.Bounds(), strokeColor, image.ZP, mask, image.ZP, draw.Over) 
        gc.rasterizer.Clear() 
        gc.path.Clear() 
} 

func toPoint(x, y float) raster.Point { 
        return raster.Point{raster.Fix32(int(x * 256)), raster.Fix32(int(y * 256))} 
} 

goinstall cannot find the image/draw package with the latest release of Go. It 
appears the package is actually @ /go/src/pkg/exp/draw