para - insertar imagen html url

¿Cómo agregar una etiqueta de texto simple a una imagen en Ir?

Question

image.RGBA , coordenadas y una línea de texto, ¿cómo agrego una etiqueta simple con cualquier fuente fija fija? Por ejemplo, Face7x13 de font/basicfont .

package main

import (
    "image"
    "image/color"
    "image/png"
    "os"
)

func main() {
    img := image.NewRGBA(image.Rect(0, 0, 320, 240))
    x, y := 100, 100
    addLabel(img, x, y, "Test123")
    png.Encode(os.Stdout, img)
}

func addLabel(img *image.RGBA, x, y int, label string) {
     col := color.Black
     // now what?
}

La alineación no importa realmente, pero es mejor si pudiera escribir la etiqueta sobre una línea que comienza en las coordenadas.

Y me gustaría evitar las dependencias cargables externas como las fuentes.

Answer 1

Aquí está el código de ejemplo que usa gg library, donde ya tenemos src.jpg o cualquier imagen y escribimos texto sobre él. Puede ajustar el tamaño del lienzo como corresponde. Déjame saber si no funciona.

package main

import (
    "github.com/fogleman/gg"
    "log"
)

func main() {
    const S = 1024
    im, err := gg.LoadImage("src.jpg")
    if err != nil {
        log.Fatal(err)
    }

    dc := gg.NewContext(S, S)
    dc.SetRGB(1, 1, 1)
    dc.Clear()
    dc.SetRGB(0, 0, 0)
    if err := dc.LoadFontFace("/Library/Fonts/Arial.ttf", 96); err != nil {
        panic(err)
    }
    dc.DrawStringAnchored("Hello, world!", S/2, S/2, 0.5, 0.5)

    dc.DrawRoundedRectangle(0, 0, 512, 512, 0)
    dc.DrawImage(im, 0, 0)
    dc.DrawStringAnchored("Hello, world!", S/2, S/2, 0.5, 0.5)
    dc.Clip()
    dc.SavePNG("out.png")
}

Answer 2

El paquete golang.org/x/image/font simplemente define interfaces para las fuentes y el dibujo de texto en las imágenes.

Puede usar la implementación Go del rasterizador de fuentes github.com/golang/freetype : github.com/golang/freetype .

El tipo de clave es freetype.Context , tiene todos los métodos que necesita.

Para ver un ejemplo completo, echa un vistazo a este archivo: example/freetype/main.go Este ejemplo carga un archivo de fuente, crea y configura freetype.Context , dibuja texto en la imagen y guarda la imagen resultante en el archivo.

Supongamos que ya tiene el archivo de fuente cargado y un contexto de c configurado (vea el ejemplo de cómo hacerlo). Entonces su función addLabel() podría verse así:

func addLabel(img *image.RGBA, x, y int, label string) {
    c.SetDst(img)
    size := 12.0 // font size in pixels
    pt := freetype.Pt(x, y+int(c.PointToFixed(size)>>6))

    if _, err := c.DrawString(label, pt); err != nil {
        // handle error
    }
}

Si no desea molestarse con el paquete freetype y los archivos de fuentes externos, el paquete font/basicfont contiene una fuente básica llamada Face7x13 cuyos datos gráficos son completamente independientes. Así es como puedes usar eso:

import (
    "golang.org/x/image/font"
    "golang.org/x/image/font/basicfont"
    "golang.org/x/image/math/fixed"
    "image"
    "image/color"
)

func addLabel(img *image.RGBA, x, y int, label string) {
    col := color.RGBA{200, 100, 0, 255}
    point := fixed.Point26_6{fixed.Int26_6(x * 64), fixed.Int26_6(y * 64)}

    d := &font.Drawer{
        Dst:  img,
        Src:  image.NewUniform(col),
        Face: basicfont.Face7x13,
        Dot:  point,
    }
    d.DrawString(label)
}

Así es como se puede addLabel() esta función addLabel() : el siguiente código crea una nueva imagen, dibuja el texto "Hello Go" y la guarda en un archivo llamado hello-go.png :

func main() {
    img := image.NewRGBA(image.Rect(0, 0, 300, 100))
    addLabel(img, 20, 30, "Hello Go")

    f, err := os.Create("hello-go.png")
    if err != nil {
        panic(err)
    }
    defer f.Close()
    if err := png.Encode(f, img); err != nil {
        panic(err)
    }
}

Tenga en cuenta que el código anterior también requiere la importación del paquete "image/png" .

También tenga en cuenta que la coordenada y dada será la línea inferior del texto. Por lo tanto, si desea dibujar una línea en la esquina superior izquierda, debe usar x = 0 e y = 13 (13 es la altura de esta fuente Face7x13 ). Si lo desea, puede construir esto en la función addLabel() restando 13 de la coordenada y , de modo que la coordenada y pasada sea la coordenada superior en la que se dibujará el texto.

También hay una fuente autocontenida adicional en el paquete golang.org/x/image/font/inconsolata con estilo regular y en negrita. Para usarlos, solo necesita especificar una Face diferente en addLabel() :

import "golang.org/x/image/font/inconsolata"

        // To use regular Inconsolata font family:
        Face: inconsolata.Regular8x16,

        // To use bold Inconsolata font family:
        Face: inconsolata.Bold8x16,