golang changer la police

Golang est un langage de programmation populaire idéal pour créer des applications et des services Web. Pendant le développement, nous devons parfois modifier la police du texte pour obtenir de meilleurs effets de lecture ou de conception. Alors comment changer la police dans Golang ? Découvrons ensemble ci-dessous.

Vous vous souvenez que lorsque nous apprenions le traitement d'images Golang, nous utilisions les packages image et draw ? Ces deux packages nous aident à traiter et manipuler des images. Dans ces deux packages, il existe un type très important appelé font, qui définit le format de la police et la collection de tous les glyphes disponibles. Par conséquent, pour changer la police, nous devons l’implémenter via le package de polices.

Tout d'abord, nous devons choisir une nouvelle police, qui peut être obtenue à partir d'un fichier local ou sur Internet. Le code pour charger un fichier de police dans un fichier local est le suivant :

import (
    "fmt"
    "golang.org/x/image/font"
    "golang.org/x/image/font/opentype"
    "io/ioutil"
    "os"
)

func LoadFont(path string, size float64) (font.Face, error) {
    fontBytes, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, err
    }
    font, err := opentype.Parse(fontBytes)
    if err != nil {
        return nil, err
    }
    return opentype.NewFace(font, &opentype.FaceOptions{
        Size:    size,
        DPI:     72,
        Hinting: font.HintingFull,
    }), nil
}

func main() {
    fontFace, err := LoadFont("path/to/font.ttf", 16)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error loading font: %v
", err)
        return
    }
    // Use fontFace to draw text
}

Dans le code ci-dessus, nous utilisons la bibliothèque opentype pour charger un fichier de police à partir d'un fichier local et spécifier la taille de la police pour celui-ci. Créez ensuite une nouvelle police à l'aide de la méthode NewFace(), qui nécessite un objet de police et des paramètres d'options de police. Enfin, nous pouvons utiliser l’objet font renvoyé fontFace pour dessiner du texte.

Si nous souhaitons utiliser des polices provenant d'Internet, nous pouvons utiliser l'API Google Fonts. Il suffit de fournir le nom de la police requise et l'API renverra un fichier CSS contenant le fichier de police. Par exemple, si nous voulons utiliser la police "Roboto" dans Google Fonts, il suffit d'utiliser le code suivant :

import (
    "fmt"
    "github.com/golang/freetype/truetype"
    "golang.org/x/image/font"
    "golang.org/x/image/font/gofont/goregular"
    "net/http"
    "os"
)

func LoadGoogleFont(fontName string, size float64) (font.Face, error) {
    resp, err := http.Get(fmt.Sprintf("https://fonts.googleapis.com/css?family=%s", fontName))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    truetypeFont, err := truetype.Parse(goregular.TTF)
    if err != nil {
        return nil, err
    }

    face := truetype.NewFace(truetypeFont, &truetype.Options{
        Size:    size,
        DPI:     72,
        Hinting: font.HintingFull,
    })

    return face, nil
}

func main() {
    fontFace, err := LoadGoogleFont("Roboto", 16)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error loading font: %v
", err)
        return
    }
    // Use fontFace to draw text
}

Dans le code ci-dessus, nous utilisons la méthode http.Get() pour obtenir le fichier CSS dans Google Polices. Ensuite, en utilisant la police par défaut de la bibliothèque goregular, créez un objet de police truetype et utilisez la méthode NewFace() pour créer une nouvelle police. Enfin, nous pouvons utiliser l’objet font renvoyé fontFace pour dessiner du texte.

Une fois que nous avons obtenu l'objet font fontFace dont nous avons besoin, nous pouvons utiliser le package draw pour dessiner du texte sur l'image, comme indiqué ci-dessous :

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

func DrawText(img *image.RGBA, x, y int, text string, fontFace font.Face) {
    drawer := &font.Drawer{
        Dst:  img,
        Src:  image.NewUniform(color.Black),
        Face: fontFace,
    }
    drawer.DrawString(text, fixed.P(x, y))
}

func main() {
    fontFace, err := LoadFont("path/to/font.ttf", 16)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error loading font: %v
", err)
        return
    }

    // Create a new image
    img := image.NewRGBA(image.Rect(0, 0, 200, 200))

    // Draw some text
    DrawText(img, 10, 10, "Hello, world!", fontFace)
}

Dans le code ci-dessus, nous créons d'abord un nouvel objet image img, puis A DrawText () est définie, qui dessine le texte dans l'img en utilisant l'objet police fontFace et les coordonnées données. Enfin, nous pouvons appeler la fonction DrawText() dans la fonction main() pour répondre à nos besoins.

Dans cet article, nous avons expliqué comment modifier les polices dans Golang, obtenir des polices à partir de fichiers locaux ou d'Internet et dessiner du texte sur des images. En appliquant ces techniques, nous pouvons facilement ajouter de meilleurs effets visuels à nos applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!