ein Bild zu JPEG in Go

Question

ich eine Struktur SpriteImage genannt haben Encoding, die wie folgt definiert ist:

func NewSpriteImage(width, height int) SpriteImage { 
    c := color.RGBA{0xff, 0xff, 0xff, 0xff} 
    blankImage := imaging.New(width, height, c) 

    return SpriteImage{ 
     dimentions:  image.Point{X: width, Y: height}, 
     lastImgPosition: image.Point{X: 0, Y: 0}, 
     sprite:   blankImage, 
    } 
} 

Und dann:

type SpriteImage struct { 
    dimentions  image.Point 
    lastImgPosition image.Point 
    sprite   *image.NRGBA 
} 

In meinem Fluss, ich zum ersten Mal eine neue solche Struktur initiieren ich füge Bilder zu diesem SpriteImage etwa so:

func (s *SpriteImage) AddImage(img image.Image) error { 
    imgWidth := img.Bounds().Dx() 
    imgHeight := img.Bounds().Dy() 

    // Make sure new image will fit into the sprite. 
    if imgWidth != s.dimentions.X { 
     return fmt.Errorf("image width %d mismatch sprite width %d", imgWidth, s.dimentions.X) 
    } 

    spriteHeightLeft := s.dimentions.Y - s.lastImgPosition.Y 
    if imgHeight > spriteHeightLeft { 
     return fmt.Errorf("image height %d won't fit into sprite, sprite free space %d ", imgHeight, s.dimentions.Y) 
    } 

    // add image to sprite 
    s.sprite = imaging.Paste(s.sprite, img, s.lastImgPosition) 

    // update next image position within sprite 
    s.lastImgPosition = s.lastImgPosition.Add(image.Point{X: 0, Y: imgHeight}) 

    return nil 
} 

Schließlich möchte ich diese SpriteImage nehmen und kodieren sie als JPEG. Aber es scheint nicht zu funktionieren. Die native JPEG Encode function nimmt ein Bild auf, aber ich habe ein Bild. NRGBA. So verwende ich github.com/disintegration/imaging lib wie so:

func (s SpriteImage) GetBytes() ([]byte, error) { 
    var b bytes.Buffer 
    w := bufio.NewWriter(&b) 

    if s.sprite == nil { 
     return nil, fmt.Errorf("sprite is nil") 
    } 

    if err := imaging.Encode(w, s.sprite, imaging.JPEG); err != nil { 
     return nil, err 
    } 

    return b.Bytes(), nil 
} 

Allerdings ist scheint, dass die zurückgegebenen Bytes sind in der Tat nicht JPEG. Die native Go JPEG-Bibliothek dekodiert diese Bytes nicht in eine Go-Image-Struktur. Wenn ich versuche, dieses Bytes zu Bild zu dekodieren etwa so:

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

Ich erhalte err:

image: unknown format

Irgendwelche Ideen?

Answer 1

Vielleicht zu überprüfen etwas: Die image: unknown format ein häufiger Fehler ist, wenn Sie die image/jpeg lib nicht enthalten und es speziell mit ihm entschlüsseln:

import (
    "image/jpeg" 
    "io" 
) 

...  
    img, err := jpeg.Decode(r) 
    if err != nil { 
    return err 
    } 
... 

Einige versuchen image.Decode zu verwenden, aber Sie müssen noch schließen die image/jpeg lib.

Ich glaube, es mit einem blinden arbeitet umfassen:

import (
    _ "image/jpeg" 
    "image" 
    "io" 
) 

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

Answer 2

Also, es sieht aus wie dies mit dem github.com/disintegration/imaging lib ein Problem sein kann. Ich habe auf der Reposeite ein Problem darüber gepostet.

Wenn ich meine GetBytes() Funktion dies zu ändern, erhalte ich gültige JPEG:

func (s SpriteImage) GetBytes() ([]byte, error) { 
    var b bytes.Buffer 
    w := bufio.NewWriter(&b) 

    if s.sprite == nil { 
     return nil, fmt.Errorf("sprite is nil") 
    } 

    im := s.sprite 
    err := jpeg.Encode(w, im, &jpeg.Options{jpegCompression}) 

    if err != nil { 
     fmt.Println(err) 
    } 

    return b.Bytes(), nil 
}