Question

我需要以[]byte的形式获取一个像素数组，以便从Contex包中传递给/mobile/gl的texImage2D方法。

它需要一个像素阵列，其中每个像素的rgba值按照从左到右，从上到下的像素顺序附加。目前我有一个从文件加载的图像。

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)
}

我正在寻找像img.Pixels()

这样的东西

Answer 1

您可以简单地使用img.At(x, y).RGBA()来获取像素的RBGA值，您只需将它们除以257即可获得8位表示。我建议你建立自己的二维像素数组。这是一个可能的实现，根据需要进行修改：

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
}

Answer 2

这就是我最终要做的事情。我使用image/draw包的绘图功能来重新填充image.RGBA实例

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

现在rgba.Pix包含我想要的数组，可以在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)

<强>替代地

Image个实例包含一个返回Color的At方法。因此可以循环每个像素并收集颜色。但是从Color转换返回的rgba值可能很复杂。引用文档：

    // 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 3

在我的测试中，Pix方法显示的速度比At快〜4倍，但仍然需要太长时间...

这是我的测试脚本，不确定height / width的顺序，但这对我有用：

// test_image_time.go
package main

import (
    "os"
    "fmt"
    "image"
    _ "image/jpeg"
    "golang.org/x/image/draw"
    "time"
)

func main() {
    img_path:= "/path/to/image/.jpg"
    aa := time.Now()
    reader, _ := os.Open(img_path)
    m, _, _ := image.Decode(reader)
    bounds := m.Bounds()
    fmt.Println("Bounds: ", bounds.Min.Y, bounds.Max.Y, bounds.Min.X, bounds.Max.X)
    bb := time.Now()
    fmt.Println("Read file time: ", float64(bb.Nanosecond() - aa.Nanosecond()) / 1e9)

    aa = time.Now()
    _ = image_2_array_at(m)
    bb = time.Now()
    fmt.Println("At Time: ", float64(bb.Nanosecond() - aa.Nanosecond()) / 1e9)

    aa = time.Now()
    _ = image_2_array_pix(m)
    bb = time.Now()
    fmt.Println("Pix Time: ", float64(bb.Nanosecond() - aa.Nanosecond()) / 1e9)
}

func image_2_array_at(src image.Image) [][][3]float32 {
    bounds := src.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y
    iaa := make([][][3]float32, height)

    for y := 0; y < height; y++ {
        row := make([][3]float32, width)
        for x := 0; x < width; x++ {
            r, g, b, _ := src.At(x, y).RGBA()
            // A color's RGBA method returns values in the range [0, 65535].
            // Shifting by 8 reduces this to the range [0, 255].
            row[x] = [3]float32{float32(r>>8), float32(g>>8), float32(b>>8)}
        }
        iaa[y] = row
    }

    return iaa
}

func image_2_array_pix(src image.Image) [][][3]float32 {
    bounds := src.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y
    iaa := make([][][3]float32, height)
    src_rgba := image.NewRGBA(src.Bounds())
    draw.Copy(src_rgba, image.Point{}, src, src.Bounds(), draw.Src, nil)

    for y := 0; y < height; y++ {
        row := make([][3]float32, width)
        for x := 0; x < width; x++ {
            idx_s := (y * width + x) * 4
            pix := src_rgba.Pix[idx_s : idx_s + 4]
            row[x] = [3]float32{float32(pix[0]), float32(pix[1]), float32(pix[2])}
        }
        iaa[y] = row
    }

    return iaa
}

运行

$ go run test_image_time.go
Bounds:  0 976 0 1920
Read file time:  0.025212067
At Time:  0.069091218
Pix Time:  0.0165787

从golang image.Image获取像素数组

3 个答案: