Traitement d'image Golang : découvrez comment ajouter des filigranes et du texte

Traitement d'images Golang : Apprenez à ajouter des filigranes et du texte

Introduction :
À l'ère moderne de la numérisation et des médias sociaux, le traitement d'images est devenu une compétence importante. Que ce soit pour un usage personnel ou pour des opérations professionnelles, l'ajout de filigranes et de texte est un besoin courant. Dans cet article, nous explorerons comment utiliser Golang pour le traitement d'images et apprendrons comment ajouter des filigranes et du texte.

Contexte :
Golang est un langage de programmation open source connu pour sa syntaxe concise, ses performances efficaces et ses puissantes capacités de concurrence. Il est devenu l’un des langages préférés de nombreux développeurs. Dans Golang, il existe de puissantes bibliothèques tierces qui rendent le traitement des images facile et efficace.

Ajouter un filigrane :
L'ajout d'un filigrane est une technique courante pour protéger les droits d'auteur des images personnelles ou commerciales. Voici un exemple qui montre comment ajouter un filigrane à une image à l'aide de Golang :

package main

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

func main() {
    // 打开原始图片
    file, err := os.Open("original.jpg")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    // 创建一个画布
    bounds := img.Bounds()
    canvas := image.NewRGBA(bounds)

    // 绘制原始图片到画布上
    draw.Draw(canvas, bounds, img, image.Point{}, draw.Src)

    // 添加水印
    watermark := image.NewRGBA(image.Rect(0, 0, 100, 50))
    draw.Draw(canvas, image.Rect(bounds.Dx()-100, bounds.Dy()-50, bounds.Dx(), bounds.Dy()), watermark, image.Point{}, draw.Src)

    // 保存处理后的图片
    output, err := os.Create("output.jpg")
    if err != nil {
        panic(err)
    }
    defer output.Close()

    // 编码保存到文件
    jpeg.Encode(output, canvas, nil)
}

Le code ci-dessus ouvre d'abord un fichier image nommé "original.jpg". Il est ensuite décodé en un objet image.Image, un nouveau canevas RGBA est créé et l'image originale est dessinée sur le canevas. Enfin, un filigrane de taille 100x50 a été créé et dessiné dans le coin inférieur droit de la toile. L'image finale générée avec filigrane est enregistrée sous "output.jpg".

Ajouter du texte :
L'ajout de texte est un autre besoin courant de traitement d'image, il peut être utilisé pour ajouter un titre, une description ou d'autres instructions. Voici un exemple qui montre comment ajouter du texte sur une image à l'aide de Golang :

package main

import (
    "image"
    "image/draw"
    "image/jpeg"
    "os"
    "github.com/golang/freetype"
    "github.com/golang/freetype/truetype"
    "golang.org/x/image/font"
)

func main() {
    // 打开原始图片
    file, err := os.Open("original.jpg")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 解码图片
    img, _, err := image.Decode(file)
    if err != nil {
        panic(err)
    }

    // 创建一个画布
    bounds := img.Bounds()
    canvas := image.NewRGBA(bounds)

    // 绘制原始图片到画布上
    draw.Draw(canvas, bounds, img, image.Point{}, draw.Src)

    // 添加文字
    fontBytes, err := os.ReadFile("font.ttf")
    if err != nil {
        panic(err)
    }
    font, err := freetype.ParseFont(fontBytes)
    if err != nil {
        panic(err)
    }

    context := freetype.NewContext()
    context.SetDPI(72)
    context.SetFont(font)
    context.SetFontSize(24)
    context.SetClip(bounds)
    context.SetDst(canvas)
    context.SetSrc(image.Black)

    pt := freetype.Pt(10, 10+int(context.PointToFixed(24)>>6))
    context.DrawString("Hello, Golang!", pt)

    // 保存处理后的图片
    output, err := os.Create("output.jpg")
    if err != nil {
        panic(err)
    }
    defer output.Close()

    // 编码保存到文件
    jpeg.Encode(output, canvas, nil)
}

Le code ci-dessus est similaire à l'exemple d'ajout d'un filigrane, mais nous utilisons la bibliothèque tierce freetype pour ajouter du texte. Tout d’abord, un fichier image nommé « original.jpg » est ouvert puis décodé en un objet image.Image. Ensuite, un nouveau canevas RGBA est créé et l'image originale est dessinée sur le canevas. Ensuite, un fichier de police TrueType est chargé et analysé dans un objet freetype.Font. Création d'un objet freetype.Context et définition des paramètres de dessin tels que la police et la taille de la police. Enfin, la fonction DrawString est appelée pour ajouter du texte au canevas. L'image finale générée est enregistrée sous "output.jpg".

Conclusion :
Golang, en tant que langage de programmation puissant, dispose d'une multitude de bibliothèques et d'outils tiers, rendant le traitement des images simple et efficace. Cet article explique comment utiliser Golang pour ajouter des filigranes et du texte aux images, et fournit des exemples de code correspondants. J'espère que cet article pourra aider les lecteurs à apprendre à utiliser Golang pour le traitement d'images et à jouer un rôle dans des applications pratiques.

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!