Comment convertir des pixels d'image en un tableau d'octets dans Golang pour la création de textures OpenGL ?

Acquisition de données de pixels à partir d'une image dans un tableau d'octets pour les contextes Golang

Problème :

Pour créer des textures à l'aide du Méthode texImage2D dans le package /mobile/gl, l'accès aux valeurs des pixels est requis. La tâche consiste à convertir les valeurs de pixels d'une image en un tableau d'octets, où les valeurs RGBA sont disposées consécutivement de gauche à droite, de haut en bas.

Solution :

Malheureusement, img.Pixels() n'est pas une méthode facilement disponible pour extraire les données brutes des pixels. Cependant, la solution réside dans l'itération sur les pixels de l'image et l'extraction de leurs composants RGBA. Les étapes suivantes décrivent l'approche :

1. Charger l'image : chargez l'image à partir d'un fichier ou d'une URL à l'aide de image.Decode(). Cela renverra un objet image.Image.
2. Itérer à travers les pixels : utilisez des boucles pour parcourir les pixels de l'image, en accédant à leurs valeurs RGBA respectives à l'aide de img.At(x, y). RGBA().
3. Convertir RGBA en octets : Pour obtenir la représentation 8 bits, divisez les valeurs RGBA par 257.
4. Créer un tableau d'octets : Concaténez les représentations d'octets des valeurs RGBA dans un tableau d'un seul octet.

Voici un exemple d'implémentation qui démontre le processus :

package main

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

func main() {
    // Open the image file
    file, err := os.Open("./image.png")
    if err != nil {
        fmt.Println("Error: Unable to open the image file.")
        return
    }
    defer file.Close()

    // Decode the image
    img, _, err := image.Decode(file)
    if err != nil {
        fmt.Println("Error: Unable to decode the image.")
        return
    }

    // Get the pixel array
    pixelArray, err := GetPixelArray(img)
    if err != nil {
        fmt.Println("Error: Unable to get the pixel array.")
        return
    }

    fmt.Println("Pixel array:")
    fmt.Println(pixelArray)
}

// GetPixelArray converts an image to a byte array containing the RGBA values of its pixels.
func GetPixelArray(img image.Image) ([]byte, error) {
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y

    // Create a byte array to store the pixel values
    pixelArray := make([]byte, 0, width*height*4)

    // Iterate over the pixels and add their RGBA values to the byte array
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, a := img.At(x, y).RGBA()

            pixelArray = append(pixelArray, byte(r/257))
            pixelArray = append(pixelArray, byte(g/257))
            pixelArray = append(pixelArray, byte(b/257))
            pixelArray = append(pixelArray, byte(a/257))
        }
    }

    return pixelArray, nil
}

Cette approche vous fournira un tableau d'octets contenant les données brutes de pixels dans le format souhaité à utiliser avec texImage2D.

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!