Manipulation d'images Golang : comment modifier les niveaux de gris et ajuster la luminosité des images

Opération d'image Golang : Comment ajuster les niveaux de gris et la luminosité de l'image

Introduction :
Dans le processus de traitement de l'image, il est souvent nécessaire d'effectuer diverses opérations sur l'image, telles que le réglage des niveaux de gris et de la luminosité de l'image. Dans Golang, nous pouvons réaliser ces opérations en utilisant des bibliothèques tierces. Cet article expliquera comment utiliser Golang pour ajuster les niveaux de gris et la luminosité des images, et joindra des exemples de code correspondants.

1. Image en niveaux de gris
L'image en niveaux de gris est le processus de conversion d'une image couleur en une image en niveaux de gris. Dans le processus d'échelle de gris de l'image, nous devons convertir chaque pixel de l'image en valeur d'échelle de gris correspondante via un certain algorithme. Ensuite, nous utiliserons la bibliothèque tierce de Golang go-opencv pour obtenir des niveaux de gris d'image.

Tout d'abord, entrez la commande suivante dans le terminal pour installer la bibliothèque go-opencv :

go get -u github.com/lazywei/go-opencv

Ensuite, nous montrerons un exemple de code montrant comment mettre en niveaux de gris une image :

package main

import (
    "fmt"
    "github.com/lazywei/go-opencv/opencv"
)

func main() {
    imagePath := "test.jpg"
    // 通过go-opencv的LoadImage方法读取图片
    image := opencv.LoadImage(imagePath)
    defer image.Release()

    // 使用go-opencv的CvtColor方法将图片转为灰度图像
    grayImage := opencv.CreateImage(image.Width(), image.Height(), 8, 1)
    opencv.CvtColor(image, grayImage, opencv.CV_BGR2GRAY)

    // 保存灰度图像
    outputPath := "output_gray.jpg"
    opencv.SaveImage(outputPath, grayImage, 0)
    fmt.Printf("Gray image saved to: %s
", outputPath)
}

Le code ci-dessus charge d'abord une image couleur, puis utilise La méthode CvtColor convertit l'image en niveaux de gris. Enfin, enregistrez l'image en niveaux de gris générée dans le chemin de sortie spécifié.

2. Réglage de la luminosité
Le réglage de la luminosité fait référence à la modification du niveau de luminosité global de l'image. Dans Golang, nous pouvons utiliser la bibliothèque tierce github.com/nfnt/resize pour ajuster la luminosité de l'image.

Tout d'abord, entrez la commande suivante dans le terminal pour installer la bibliothèque nfnt/resize :

go get -u github.com/nfnt/resize

Ensuite, nous montrerons un exemple de code sur la façon d'ajuster la luminosité de l'image :

package main

import (
    "fmt"
    "image"
    "image/color"
    "github.com/nfnt/resize"
)

func main() {
    imagePath := "test.jpg"
    // 使用Golang内置的image包加载图片
    img, err := loadImage(imagePath)
    if err != nil {
        fmt.Printf("Failed to load image: %s
", err)
        return
    }

    // 调整图片亮度
    brightness := 50
    brightImage := adjustBrightness(img, brightness)

    // 保存亮度调整后的图片
    outputPath := "output_bright.jpg"
    saveImage(outputPath, brightImage)
    fmt.Printf("Brightness adjusted image saved to: %s
", outputPath)
}

// 加载图片
func loadImage(path string) (image.Image, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()

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

    return img, nil
}

// 调整图片亮度
func adjustBrightness(img image.Image, brightness int) image.Image {
    b := img.Bounds()
    dst := image.NewRGBA(b)

    for y := 0; y < b.Max.Y; y++ {
        for x := 0; x < b.Max.X; x++ {
            oldColor := img.At(x, y)
            r, g, b, _ := oldColor.RGBA()

            newR := uint8(clamp(int(r)+brightness, 0, 0xffff))
            newG := uint8(clamp(int(g)+brightness, 0, 0xffff))
            newB := uint8(clamp(int(b)+brightness, 0, 0xffff))

            newColor := color.RGBA{newR, newG, newB, 0xff}
            dst.Set(x, y, newColor)
        }
    }

    return dst
}

// 保存图片
func saveImage(path string, img image.Image) {
    file, err := os.Create(path)
    if err != nil {
        fmt.Printf("Failed to save image: %s
", err)
        return
    }
    defer file.Close()

    png.Encode(file, img)
}

// 辅助函数，限定数值在指定范围内
func clamp(value, min, max int) int {
    if value < min {
        return min
    }
    if value > max {
        return max
    }
    return value
}

Le code ci-dessus charge d'abord une image couleur, puis, en fonction des données données, ajustez la luminosité de l'image avec les paramètres de luminosité spécifiés et enregistrez l'image ajustée sur le chemin de sortie spécifié.

Résumé :
Cet article explique comment utiliser Golang pour ajuster les niveaux de gris et la luminosité des images. En utilisant des bibliothèques tierces, nous pouvons facilement mettre en œuvre ces opérations de traitement d'images. J'espère que les exemples de code de cet article vous seront utiles pour le traitement d'images dans 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!