Convertir []tranche de pixel float64 en une image

Question

J'essaie de redimensionner et de convertir une image en une tranche de float64 en niveaux de gris (pour pouvoir faire des transformations sur les float) et ensuite en une image, mais je ne sais pas comment convertir un []float64 en RGB ou en quelque chose que je puisse transformer en image.

Jusqu'à présent, j'ai

// colorToGrayScaleFloat64 reduces rgb
// to a grayscale approximation.
func colorToGrayScaleFloat64(c color.Color) float64 {
    r, g, b, _ := c.RGBA()
    return 0.299*float64(r) +
        0.587*float64(g) +
        0.114*float64(b)
}

func getFloatPixels(filePath string) {
    size := 32
    f, err := os.Open(filePath)
    if err != nil {
    log.Fatalf("FAILED TO OPEN FILE: %s", err.Error())
    }
    defer f.Close()

    image, _, err := image.Decode(f)
    if err != nil {
        log.Fatalf("FAILED TO DECODE FILE: %s", err.Error())
    }

    // Resize image to 32X32
    im := imaging.Resize(image, size, size, imaging.Lanczos)

    // Convert image to grayscale float array
    vals := make([]float64, size*size)
    for i := 0; i < size; i++ {
        for j := 0; j < size; j++ {
            vals[size*i+j] = colorToGrayScaleFloat64(im.At(i, j))
        }
    }

    fmt.Printf("pixel vals %+v\n", vals)
}

Ce qui produit la sortie :

pixel vals [40315.076 48372.797 48812.780999999995 47005.557 ... 25129.973999999995 24719.287999999997]

Comment convertir ce pixel []float64 en image ?

Answer 1

En fait, vous avez la luminosité du pixel gris et vous voulez avoir une valeur de color.Color qui la représente.

C'est très simple : il existe un color.Gray et une plus grande précision color.Gray16 qui modèlent la couleur avec sa luminosité, il suffit donc de créer une valeur de celles-ci. Ils implémentent color.Color Vous pouvez donc les utiliser pour définir les pixels d'une image.

col := color.Gray{uint8(lum / 256)}

Notez également que votre colorToGrayScaleFloat64() est déjà présente dans la librairie standard. Il existe plusieurs convertisseurs dans la bibliothèque image/color en tant qu'implémentation de color.Model . Utiliser le color.GrayModel o color.Gray16Model pour convertir un color.Color à une valeur de type color.Gray o color.Gray16 qui stockent directement la luminosité de la couleur grise.

Par exemple :

gray := color.Gray16Model.Convert(img.At(x, y))
lum := float64(gray.(color.Gray16).Y)

Le tester :

c := color.RGBA{111, 111, 111, 255}
fmt.Println("original:", c)

gray := color.Gray16Model.Convert(c)
lum := float64(gray.(color.Gray16).Y)
fmt.Println("lum:", lum)

col := color.Gray{uint8(lum / 256)}

r, g, b, a := col.RGBA()
a >>= 8
fmt.Println("lum to col:", r/a, g/a, b/a, a)
fmt.Println()

Cela produira un résultat (essayez-le sur l'écran Go Playground ) :

original: {111 111 111 255}
lum: 28527
lum to col: 111 111 111 255

Notez également que si vous souhaitez créer une image pleine de pixels gris, vous pouvez utiliser la fonction image.Gray y image.Gray16 Ainsi, lorsque l'on dessine ces couleurs sur eux, aucune conversion de couleur n'est nécessaire. Ils ont également des Gray.SetGray() y Gray16.SetGray16() qui prennent directement les couleurs de ces types.

Voir à ce sujet :

Conversion d'une image RGBA en niveaux de gris Golang