Manipulation d'images Golang : apprenez à lutter contre la décoloration et à organiser les pixels des images

Opération d'image Golang : apprenez à anti-décoloration et à la disposition des pixels des images

Dans le domaine du traitement d'image, l'anti-décoloration et la disposition des pixels sont deux opérations courantes. L'antifading fait référence à la modification de l'inversion des couleurs des pixels d'une image, tandis que le réarrangement des pixels réorganise les pixels d'une image. Dans cet article, nous utiliserons le langage Golang pour apprendre à implémenter ces deux opérations sur les images.

1. Anti-fading

L'anti-fading fait référence à l'inversion de la couleur de chaque pixel de l'image, c'est-à-dire à l'inversion complète des valeurs de luminosité et de couleur. Voici un exemple simple de code anti-fading :

package main

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

func main() {
    // 打开图像文件
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

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

    // 创建新的图像
    bounds := img.Bounds()
    newImg := image.NewRGBA(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)
            oldR, oldG, oldB, _ := oldColor.RGBA()

            // 反褪色操作
            newR := 0xFFFF - oldR
            newG := 0xFFFF - oldG
            newB := 0xFFFF - oldB

            // 创建新的颜色
            newColor := color.RGBA{uint8(newR >> 8), uint8(newG >> 8), uint8(newB >> 8), 0xFF}

            // 设置新的像素值
            newImg.Set(x, y, newColor)
        }
    }

    // 创建输出文件
    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    // 编码并保存图像
    err = png.Encode(outputFile, newImg)
    if err != nil {
        panic(err)
    }
}

Dans cet exemple, nous ouvrons d'abord un fichier image, puis décodons l'image et créons une nouvelle image vierge. Ensuite, nous parcourons chaque pixel de l'image d'origine et effectuons une opération de maintien sur celui-ci, en définissant la nouvelle couleur sur le nouveau pixel de l'image. Enfin, nous encodons et enregistrons la nouvelle image dans le fichier de sortie.

2. Disposition des pixels

La disposition des pixels fait référence à l'opération de réorganisation des pixels dans l'image. Dans Golang, la disposition des pixels est réalisée en modifiant les coordonnées des pixels. Voici un exemple simple de code d'arrangement de pixels :

package main

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

func main() {
    // 打开图像文件
    file, err := os.Open("input.png")
    if err != nil {
        panic(err)
    }
    defer file.Close()

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

    // 创建新的图像
    bounds := img.Bounds()
    newImg := image.NewRGBA(bounds)

    // 遍历每个像素，并进行像素排列
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            // 计算新的像素坐标
            newX := bounds.Max.X - x - 1
            newY := bounds.Max.Y - y - 1

            // 获取原始像素
            oldColor := img.At(x, y)

            // 设置新的像素值
            newImg.Set(newX, newY, oldColor)
        }
    }

    // 创建输出文件
    outputFile, err := os.Create("output.png")
    if err != nil {
        panic(err)
    }
    defer outputFile.Close()

    // 编码并保存图像
    err = png.Encode(outputFile, newImg)
    if err != nil {
        panic(err)
    }
}

Dans cet exemple, nous ouvrons également d'abord un fichier image et décodons l'image, puis créons une nouvelle image vierge. Ensuite, nous parcourons chaque pixel de l’image d’origine et calculons les nouvelles coordonnées de pixels. Enfin, nous copions les valeurs des pixels de l'image originale vers les nouvelles coordonnées de la nouvelle image. Enfin, encodez et enregistrez la nouvelle image.

En étudiant les exemples de codes de ces deux opérations d'image, nous pouvons constater que le traitement d'image dans Golang est très simple et flexible. Ces opérations peuvent non seulement être étendues à des tâches de traitement d'images plus complexes, mais peuvent également être utilisées avec d'autres bibliothèques et outils Golang pour réaliser des fonctions plus intéressantes. J'espère que cet article pourra vous aider à mieux comprendre le traitement d'image et la programmation Golang.

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!