Golang：如何将image.image转换为uint16

I am trying to use the go-skeltrack library with some depth images I have (Not using freenect). For that I need to modify the provided example by replacing the kinect images by my own. For that I have to read an image and convert it later to an []uint16 variable. The code which I tried is:

file, err := os.Open("./images/4.png")
if err != nil {
    fmt.Println("4.png file not found!")
    os.Exit(1)
}
defer file.Close()

fileInfo, _ := file.Stat()
var size int64 = fileInfo.Size()
bytes := make([]byte, size)

// read file into bytes 
buffer := bufio.NewReader(file)
_, err = buffer.Read(bytes)  

integerImage := binary.BigEndian.Uint16(bytes)

onDepthFrame(integerImage)

Where onDepthFrame is a function which has the form

func onDepthFrame(depth []uint16).

But I am getting the following error while compiling:

./skeltrackOfflineImage.go:155: cannot use integerImage (type uint16) as type []uint16 in argument to onDepthFrame

Which of course refers to the fact that I generated a single integer instead of an array. I am quite confused about the way that Go data types conversion works. Please help!

Thanks in advance for your help. Luis

binary.BigEndian.Uint16 converts two bytes (in a slice) to a 16-bit value using big endian byte order. If you want to convert bytes to a slice of uint16, you should use binary.Read:

// This reads 10 uint16s from file.
slice := make([]uint16, 10)
err := binary.Read(file, binary.BigEndian, slice)

It sounds like you're looking to get raw pixels. If that's the case, I don't recommend reading the file as binary directly. It means you would need to parse the file format yourself since image files contain more information than just the raw pixel values. There are already tools in the image package to deal with that.

This code should get you on the right track. It reads RGBA values, so it ends up with a 1D array of uint8's of length width * height * 4, since there are four values per pixel.

https://play.golang.org/p/WUgHQ3pRla

import (
    "bufio"
    "fmt"
    "image"
    "os"

    // for decoding png files
    _ "image/png"
)

// RGBA attempts to load an image from file and return the raw RGBA pixel values.
func RGBA(path string) ([]uint8, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }

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

    switch trueim := img.(type) {
    case *image.RGBA:
        return trueim.Pix, nil
    case *image.NRGBA:
        return trueim.Pix, nil
    }
    return nil, fmt.Errorf("unhandled image format")
}

I'm not entirely sure where the uint16 values you need should come from, but presumably it's data per pixel, so the code should be very similar to this except the switch on trueim should likely check for something other than image.RGBA. Take a look at the other image types in https://golang.org/pkg/image