Uzyskaj tablicę pikselową z obrazu golang.Image

Question

Potrzebuję uzyskać tablicę pikseli w postaci []byte, która zostanie przekazana do metody texImage2D z Contex z pakietu /mobile/gl.

Potrzebuje tablicy pikseli, w której wartości rgba każdego piksela są dodawane w kolejności pikseli od lewej do prawej, od góry do dołu. Obecnie mam obraz załadowany z pliku.

a, err := asset.Open("key.jpeg") 
if err != nil { 
    log.Fatal(err) 
} 
defer a.Close() 

img, _, err := image.Decode(a) 
if err != nil { 
    log.Fatal(err) 
} 

szukam czegoś jak img.Pixels()

Answer 1

To, co skończyło się robi. Używam funkcji Draw image/draw innych pakietów, aby napełnić instancji image.RGBA

rect := img.Bounds() 
rgba := image.NewRGBA(rect) 
draw.Draw(rgba, rect, img, rect.Min, draw.Src) 

Teraz rgba.Pix zawiera tablicę chcę i może być stosowany w metodzie TexImage2D.

glctx.TexImage2D(gl.TEXTURE_2D, 0, rect.Max.X-rect.Min.X, rect.Max.Y-rect.Min.Y, gl.RGBA, gl.UNSIGNED_BYTE, rgba.Pix) 

Alternatywnie

Image przypadki zawiera At metody zwracającej Color. Dzięki temu można przechodzić przez każdy piksel i zbierać kolory. Ale konwersja zwróconych wartości rgba z Color może być skomplikowana. Cytowanie dokumentacja:

// RGBA returns the alpha-premultiplied red, green, blue and alpha values 
    // for the color. Each value ranges within [0, 0xffff], but is represented 
    // by a uint32 so that multiplying by a blend factor up to 0xffff will not 
    // overflow. 
    // 
    // An alpha-premultiplied color component c has been scaled by alpha (a), 
    // so has valid values 0 <= c <= a. 

Answer 2

można po prostu użyć img.At(x, y).RGBA() aby uzyskać wartości RBGA dla piksela, po prostu trzeba je podzielić przez 257, aby uzyskać reprezentację 8 bitów. Zaleciłbym zbudowanie własnej dwuwymiarowej tablicy pikseli. Oto możliwe wdrożenie, modyfikować je w zależności od potrzeb:

package main 

import (
    "fmt" 
    "image" 
    "image/png" 
    "os" 
    "io" 
    "net/http" 
) 

func main() { 
    // You can register another format here 
    image.RegisterFormat("png", "png", png.Decode, png.DecodeConfig) 

    file, err := os.Open("./image.png") 

    if err != nil { 
     fmt.Println("Error: File could not be opened") 
     os.Exit(1) 
    } 

    defer file.Close() 

    pixels, err := getPixels(file) 

    if err != nil { 
     fmt.Println("Error: Image could not be decoded") 
     os.Exit(1) 
    } 

    fmt.Println(pixels) 
} 

// Get the bi-dimensional pixel array 
func getPixels(file io.Reader) ([][]Pixel, error) { 
    img, _, err := image.Decode(file) 

    if err != nil { 
     return nil, err 
    } 

    bounds := img.Bounds() 
    width, height := bounds.Max.X, bounds.Max.Y 

    var pixels [][]Pixel 
    for y := 0; y < height; y++ { 
     var row []Pixel 
     for x := 0; x < width; x++ { 
      row = append(row, rgbaToPixel(img.At(x, y).RGBA())) 
     } 
     pixels = append(pixels, row) 
    } 

    return pixels, nil 
} 

// img.At(x, y).RGBA() returns four uint32 values; we want a Pixel 
func rgbaToPixel(r uint32, g uint32, b uint32, a uint32) Pixel { 
    return Pixel{int(r/257), int(g/257), int(b/257), int(a/257)} 
} 

// Pixel struct example 
type Pixel struct { 
    R int 
    G int 
    B int 
    A int 
}