Comment convertir des images en effets noir et blanc et demi-teintes à l'aide de Golang

Comment convertir des images en effets noir et blanc et demi-teintes à l'aide de Golang

Avec le développement continu de la technologie, le traitement d'image est devenu un domaine de plus en plus important. En traitement d'image, la conversion d'images couleur en effets noir et blanc ou en demi-teintes est une opération courante. Cet article explique comment utiliser le langage de programmation Golang pour convertir des images en effets noir et blanc et demi-teintes.

Tout d’abord, nous devons importer les packages nécessaires. Dans Golang, vous pouvez utiliser les packages image et image/couleur pour effectuer des opérations de traitement d’image. Le code est le suivant :

package main

import (
    "image"
    "image/color"
    "image/jpeg"
    "log"
    "os"
)

Ensuite, nous pouvons définir une fonction pour lire le fichier image. Le code est le suivant :

func loadImage(filename string) (image.Image, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    img, err := jpeg.Decode(file)
    if err != nil {
        return nil, err
    }

    return img, nil
}

Ensuite, on peut définir une fonction pour convertir l'image couleur en effet noir et blanc. Ceci peut être réalisé en traitant chaque pixel de l’image. Le code est le suivant :

func toGrayscale(img image.Image) *image.Gray {
    bounds := img.Bounds()
    gray := image.NewGray(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            oldColor := img.At(x, y)
            grayColor := color.GrayModel.Convert(oldColor)
            gray.Set(x, y, grayColor)
        }
    }

    return gray
}

Ensuite, nous pouvons définir une fonction pour convertir l'image couleur en un effet de demi-teintes. L'effet de demi-teinte peut être obtenu en traitant chaque pixel de l'image et en le convertissant en un ensemble limité de valeurs de couleur. Le code est le suivant :

func toHalftone(img image.Image) *image.Gray16 {
    bounds := img.Bounds()
    halftone := image.NewGray16(bounds)

    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            oldColor := img.At(x, y)
            halftoneColor := color.Gray16Model.Convert(oldColor)
            halftone.Set(x, y, halftoneColor)
        }
    }

    return halftone
}

Enfin, on peut définir une fonction pour sauvegarder l'image convertie. Le code est le suivant :

func saveImage(img image.Image, filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    err = jpeg.Encode(file, img, nil)
    if err != nil {
        return err
    }

    return nil
}

Maintenant, nous pouvons écrire une fonction principale pour appeler la fonction ci-dessus et la tester. Le code est le suivant :

func main() {
    // 读取图片文件
    img, err := loadImage("input.jpg")
    if err != nil {
        log.Fatal(err)
    }

    // 转换为黑白效果
    gray := toGrayscale(img)
    err = saveImage(gray, "output_gray.jpg")
    if err != nil {
        log.Fatal(err)
    }

    // 转换为半色调效果
    halftone := toHalftone(img)
    err = saveImage(halftone, "output_halftone.jpg")
    if err != nil {
        log.Fatal(err)
    }

    log.Println("图片转换完成")
}

En exécutant le code ci-dessus, nous pouvons convertir le fichier image d'entrée en effets noir et blanc et demi-teintes, et l'enregistrer sous les fichiers output_gray.jpg et output_halftone.jpg.

Ce qui précède explique comment utiliser Golang pour convertir des images en effets noir et blanc et demi-teintes. Avec ces exemples de code simples, nous pouvons facilement implémenter des fonctions de traitement d'image dans Golang. J'espère que cet article vous sera utile !

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!