version: 1.10

package image

import "image"

Overview

Package image implements a basic 2-D image library.

The fundamental interface is called Image. An Image contains colors, which are
described in the image/color package.

Values of the Image interface are created either by calling functions such as
NewRGBA and NewPaletted, or by calling Decode on an io.Reader containing image
data in a format such as GIF, JPEG or PNG. Decoding any particular image format
requires the prior registration of a decoder function. Registration is typically
automatic as a side effect of initializing that format’s package so that, to
decode a PNG image, it suffices to have

  1. import _ "image/png"

in a program’s main package. The _ means to import a package purely for its
initialization side effects.

See “The Go image package” for more details:
https://golang.org/doc/articles/image_package.html


Example:

  1. // This example demonstrates decoding a JPEG image and examining its pixels.
  2. package image_test
  4. import (
  5.     "encoding/base64"
  6.     "fmt"
  7.     "image"
  8.     "log"
  9.     "strings"
  11.     // Package image/jpeg is not used explicitly in the code below,
  12.     // but is imported for its initialization side-effect, which allows
  13.     // image.Decode to understand JPEG formatted images. Uncomment these
  14.     // two lines to also understand GIF and PNG images:
  15.     // _ "image/gif"
  16.     // _ "image/png"
  17.     _ "image/jpeg"
  18. )
  20. func Example() {
  21.     // Decode the JPEG data. If reading from file, create a reader with
  22.     //
  23.     // reader, err := os.Open("testdata/video-001.q50.420.jpeg")
  24.     // if err != nil {
  25.     //     log.Fatal(err)
  26.     // }
  27.     // defer reader.Close()
  28.     reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
  29.     m, _, err := image.Decode(reader)
  30.     if err != nil {
  31.         log.Fatal(err)
  32.     }
  33.     bounds := m.Bounds()
  35.     // Calculate a 16-bin histogram for m's red, green, blue and alpha components.
  36.     //
  37.     // An image's bounds do not necessarily start at (0, 0), so the two loops start
  38.     // at bounds.Min.Y and bounds.Min.X. Looping over Y first and X second is more
  39.     // likely to result in better memory access patterns than X first and Y second.
  40.     var histogram [16][4]int
  41.     for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
  42.         for x := bounds.Min.X; x < bounds.Max.X; x++ {
  43.             r, g, b, a := m.At(x, y).RGBA()
  44.             // A color's RGBA method returns values in the range [0, 65535].
  45.             // Shifting by 12 reduces this to the range [0, 15].
  46.             histogram[r>>12][0]++
  47.             histogram[g>>12][1]++
  48.             histogram[b>>12][2]++
  49.             histogram[a>>12][3]++
  50.         }
  51.     }
  53.     // Print the results.
  54.     fmt.Printf("%-14s %6s %6s %6s %6s\n", "bin", "red", "green", "blue", "alpha")
  55.     for i, x := range histogram {
  56.         fmt.Printf("0x%04x-0x%04x: %6d %6d %6d %6d\n", i<<12, (i+1)<<12-1, x[0], x[1], x[2], x[3])
  57.     }
  58.     // Output:
  59.     // bin               red  green   blue  alpha
  60.     // 0x0000-0x0fff:    364    790   7242      0
  61.     // 0x1000-0x1fff:    645   2967   1039      0
  62.     // 0x2000-0x2fff:   1072   2299    979      0
  63.     // 0x3000-0x3fff:    820   2266    980      0
  64.     // 0x4000-0x4fff:    537   1305    541      0
  65.     // 0x5000-0x5fff:    319    962    261      0
  66.     // 0x6000-0x6fff:    322    375    177      0
  67.     // 0x7000-0x7fff:    601    279    214      0
  68.     // 0x8000-0x8fff:   3478    227    273      0
  69.     // 0x9000-0x9fff:   2260    234    329      0
  70.     // 0xa000-0xafff:    921    282    373      0
  71.     // 0xb000-0xbfff:    321    335    397      0
  72.     // 0xc000-0xcfff:    229    388    298      0
  73.     // 0xd000-0xdfff:    260    414    277      0
  74.     // 0xe000-0xefff:    516    428    298      0
  75.     // 0xf000-0xffff:   2785   1899   1772  15450
  76. }
  78. const data = `
  79. /9j/4AAQSkZJRgABAQIAHAAcAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdA
  80. SFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2Nj
  81. Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCABnAJYDASIAAhEBAxEB/8QA
  82. HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh
  83. MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW
  84. V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
  85. x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF
  86. BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV
  87. YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE
  88. hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
  89. 8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDlwKMD0pwzSiuK57QzGDxS7D6in8Y5ximnAPUfSlcq4m3ilUYp
  90. 2OKXHvRcVxnTtS7c07HNFK4DQPakC4PNOA+tOx70XAjK/So5gBGP94fzqfvUVx/qxx/EP51UXqRP4WSE
  91. cmgjilP3jSEZqS0IO/NGDnpUiocDg/McDjvV6HTPOdVWYgsM5KcfzzQ2JySM2jp6VYu7SWzmMUwG4cgj
  92. kMPUVBjjtTGtRu0Zopw+lFFxhinrGzuqqMsxAA9yaXFSRv5cqSEcIwYj6GpuZ30O30fSLKzhUpbpNMv3
  93. 5XGTn29BV28jt7pPLuIVljPBBFVreYx+VbqAjycgt3x14zRcNOxGyVFHQkIc/wA61exyKLbuzjdZ046d
  94. ftEuTEw3Rk9SPT8P8Kpbea3tchbyVae4JkjbbGpGdwOM89Af6ViFTWUtGdcXoM2+woK1JtpNtTcoZt+l
  95. Jt7ZqTbRtouFyPFRXI/c9D94fzqzioLsfuD/ALw/nVReqIn8LJCOTSY+tSMOTmkIpXLRu+F0t5pJxPHG
  96. wjjUAuBjJJz1+laD6Pai+WaK9SBX6puzn6ZP+NV/Dkdtc6ZNbyAFwxLAHDYPv6VoQ21nPNEEiQGEFRtk
  97. Gf0NaWTOeW7Of8QwGG4MRZnEbYXPJwRnOR0zWNXW+KrqBLUWi5EjbWCgcAA9c/gRXKYqZaGlK/LqMH0F
  98. FLtHvRSNiYD2pSDTgpp6p0ywUHoTULXYxcktzrdCf7Xo8LP/AKyEmMNjJ46dfbFWJ5TDGNwB9lFUvDV9
  99. YrbfYGbyrjcWG88S57g+vtV26ZIvMlumKwwjLZ6V0WfU54yTvYwtbubea2WNWbzg4bYQeBgj8OtYeKhj
  100. u4y2HQxqxOD1xzxmrWAQCCGB6EGsaikndmsJxeiYzBo280/Z7UbayuaXGY5oIp+2lx9KLjIsVDeD/Rj/
  101. ALy/zq1t96r3y4tT/vL/ADq4P3kRP4WSleTSFKkkKoCW4GaqNcMxIjXj1pxjKT0FKrGC1Nrw3vGrKkYz
  102. 5kTAr6455/HH510UdwPtRgWCbzF5+YYUf4Vwun39xpmoR3qASMmQUJwGU9Rnt/8AWrpbrxhb8/ZdOmaQ
  103. gAGZwFH5ZJrpVKVlY5ZYhN6kXiu2eO/ikZlIljAAB5yM549OawSOOlPuLqe+umuLqTfM4OSOAo7ADsKh
  104. hl/cRsTuJHPv7mlKi3sVTxNtGP20VJhThgSQaK52mnZnUqsWrpkyeUrr5pABOAPU1AGaXUCWJISHGPfP
  105. P8qL7BiKnsMg46H3qrbzupbj5mPTPTpXVSglG551SpzSsXJ4/MBUgYIxyKpySyGBYJriV1D7kRpCVH4V
  106. bSeNJ4xchni3DeqnBI+td7F4b0mKIRjT45VbktJlzk455+n6VtYzv2PNwFZWBHBGKVJDGVC54/nXQeMN
  107. NttLNkba1jgWVWDmM8bhg4/nzXLSSbXVj6fyNKUdNRp21RtIRJGrjuM0u3FQ2DbodvcEkfQmrW2vLqLl
  108. k0ejCXNFMj2/jQV9qkxSYNRcsZiq2oI32N2CkhWXJxwOe9XMcVt6hoPn6dFaW0wgRpNzvKDlz6+/0rai
  109. ryv2Jm9LHJai+ZRGCBjnr71ErdAxAY9B611t1Y2cunbbaOQ3FvKZI3UqGlZMbiWwfcfhV231iwvLSM3U
  110. lt5Uq52TuZG+hGMA12xXJGxxzjzybOQtNOvb5j9ktZJhnBIHyg+5PFX38JayqK/2eLJIBUTgkDA9q7ex
  111. itrSHFpGsUbndhRgc+g7VNIyfZJAoJZUbb3I46CtFJMylBo8sdWhmYMuCnylc9wef5VUT7+1chc5NS7h
  112. sUZO5RtIPUH3pkBDOxxxmqM9TQtn+WilhHfHaik43KTG3Z4IyPyrNVjGCsZ+dmwv6V3cXhSG8sYpJLud
  113. JJIwxChdoJGcYx/Wkg8DafA4knvLiQr/ALqj+VQpKw3FtnFFfvbiSMgZJ6/jXp2n3d9cQRBTFsKD96EP
  114. oOxPU/8A68VVtbbRtMVntbePKDLTSHJH/Aj/AEqHTvE66rq72VugMMcbSGTnL4wMAfjT5n0HyW3L+s6b
  115. baxaJBdzN+7bcrxkAhun0rz3VNCv7e7lgigknWI43xLu6jjIHTjtXqfkpPGVYsBkghTikgsYIN/lhgXb
  116. cxLkknp/ShczQ7xtY8vtEmhkj8yGRBuCnehUcnHcVtmwfJ/fQ8e7f/E12txZW91C0U6b42xlST2OR/Ko
  117. Bo1gM/uW55/1jf41nOipu7LhV5FZHIGzI6zwj/vr/Ck+yr3uYf8Ax7/CutbQdMb71tn/ALaN/jSf8I/p
  118. X/PoP++2/wAan6rAr6wzkWt0II+1Rc/7Lf4Vd1eeCSKBbdZDdShYoiZNoyfY10P/AAj2lf8APmP++2/x
  119. oPh/SjKspsozIuNrZORjp3qo0FHYPb3OZt7ae3SzjuItsiRSAgnccl/UA+3Q1yNjKLR4ZZYY5VD7tkv3
  120. WwO/+e1evPp9nI257aJm6bioz1z1+tY+s6Hplnot9PbWMMcqwOFcLyOO1bJWMZSTOPHi+9w3mosrlyd2
  121. 9lCj02g9P/1e9a3hzxAbl2ikZRcdQueHHt7j864Y8Z4I4oRzG6urFWU5BHBB7HNJxTFGbR6he6Vpmtgm
  122. eLy5zwZI/lb8fX8azIvBUUTHdfSFP4QsYB/HNZ+k+KEnRY75hHOvAk6K/v7H9K6yyvlnQBmDZ6GsnzR0
  123. N0oy1RzOtaN/Y1tHNFO06u+zYy4I4Jzx9KKveJblXuordSGES5b6n/62PzorKVdp2LjQTVyWz8UWEWlq
  124. jSgyxfJt6EgdDzWTdeLIZGO7zHI/hVajGmWWP+PWL8qwlAIURrhpMAHHJA71pRcZrToZzcoEuo6heakA
  125. GHk245CZ6/X1qPTLq40q+W5t2QybSpDAkEEc55/zilk5k2r91eKhLDzWz2rpsczbbuemeD76fUNG865I
  126. MiysmQMZAAwa3a5j4ftu0ByP+fh/5CulkLLG7INzhSVHqe1Fh3uOoqn9qQQxyhndmHIxwOmSR2xQ13KD
  127. KoiBZOV9JBnt707MVy5RWdNdy7wRGf3bfMinnO1jg+vY03WXLaJO3mhQ20b0zwpYf0qlG7S7icrJs08U
  128. VwumgC+YiQyeVtZH567hzj8aSL949oGhE/2v5pJCDkksQwBHC4/+vXQ8LZ2uYxxCavY7us/xCcaBfn0h
  129. b+VP0bnSrb94ZMJgOecj1rl/GfidUE2k2gy5+SeQjgA/wj3rlas2jdao48qrjLAGkSKPk4Gc1WMj92I+
  130. lIJnU8OfxPWo5inBokmtQTmM4OOh71b0q6vbFmWCbaxHyqQGAP0PT8KhSTzVyo5ocSKA5VfTOTmqsmRd
  131. pl99XjPzThzK3zOeOSeveirNmkgg/fIpYsTkYORxRXmzlTjJqx6EVUcU7mhkKCzdAK59QI9zYxtG1fYU
  132. UVtgtmY4nZEa8Ak9aqFv3rfSiiu1nMeifDv/AJF+T/r4f+QrqqKKQwzQenNFFMCOKFIgNuThdoJ5OPSk
  133. ubeK6t3gnXdG4wwziiii/UTKMOg6dbzJLFE4dSCP3rEdeOM8805tDsGMvySgSsS6rM6gk9eAcUUVftZt
  134. 3uyVGNthuq3Eei6DK8H7sRR7YuMgHtXkc8rzTNLM26RyWY+p70UVnLY0iEsUipG7rhZBlDkc1HgYoorM
  135. 0HwyBXGeRjmrcUhMg2ghezd//rUUVcTKW5s2jZtY/QDaOKKKK8ip8bPRj8KP/9k=
  136. `

Index

Examples

Package files

format.go geom.go image.go names.go ycbcr.go

Variables

  1. var (
  2.     // Black is an opaque black uniform image.
  3.     Black = NewUniform(color.Black)
  4.     // White is an opaque white uniform image.
  5.     White = NewUniform(color.White)
  6.     // Transparent is a fully transparent uniform image.
  7.     Transparent = NewUniform(color.Transparent)
  8.     // Opaque is a fully opaque uniform image.
  9.     Opaque = NewUniform(color.Opaque)
  10. )
  1. var ErrFormat = errors.New("image: unknown format")

ErrFormat indicates that decoding encountered an unknown format.

func RegisterFormat

  1. func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error))

RegisterFormat registers an image format for use by Decode. Name is the name of
the format, like “jpeg” or “png”. Magic is the magic prefix that identifies the
format’s encoding. The magic string can contain “?” wildcards that each match
any one byte. Decode is the function that decodes the encoded image.
DecodeConfig is the function that decodes just its configuration.

type Alpha

  1. type Alpha struct {
  2.     // Pix holds the image's pixels, as alpha values. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

Alpha is an in-memory image whose At method returns color.Alpha values.

func NewAlpha

  1. func NewAlpha(r Rectangle) *Alpha

NewAlpha returns a new Alpha image with the given bounds.

func (*Alpha) AlphaAt

  1. func (p *Alpha) AlphaAt(x, y int) color.Alpha

func (*Alpha) At

  1. func (p *Alpha) At(x, y int) color.Color

func (*Alpha) Bounds

  1. func (p *Alpha) Bounds() Rectangle

func (*Alpha) ColorModel

  1. func (p *Alpha) ColorModel() color.Model

func (*Alpha) Opaque

  1. func (p *Alpha) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Alpha) PixOffset

  1. func (p *Alpha) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*Alpha) Set

  1. func (p *Alpha) Set(x, y int, c color.Color)

func (*Alpha) SetAlpha

  1. func (p *Alpha) SetAlpha(x, y int, c color.Alpha)

func (*Alpha) SubImage

  1. func (p *Alpha) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Alpha16

  1. type Alpha16 struct {
  2.     // Pix holds the image's pixels, as alpha values in big-endian format. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

Alpha16 is an in-memory image whose At method returns color.Alpha16 values.

func NewAlpha16

  1. func NewAlpha16(r Rectangle) *Alpha16

NewAlpha16 returns a new Alpha16 image with the given bounds.

func (*Alpha16) Alpha16At

  1. func (p *Alpha16) Alpha16At(x, y int) color.Alpha16

func (*Alpha16) At

  1. func (p *Alpha16) At(x, y int) color.Color

func (*Alpha16) Bounds

  1. func (p *Alpha16) Bounds() Rectangle

func (*Alpha16) ColorModel

  1. func (p *Alpha16) ColorModel() color.Model

func (*Alpha16) Opaque

  1. func (p *Alpha16) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Alpha16) PixOffset

  1. func (p *Alpha16) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*Alpha16) Set

  1. func (p *Alpha16) Set(x, y int, c color.Color)

func (*Alpha16) SetAlpha16

  1. func (p *Alpha16) SetAlpha16(x, y int, c color.Alpha16)

func (*Alpha16) SubImage

  1. func (p *Alpha16) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type CMYK

  1. type CMYK struct {
  2.     // Pix holds the image's pixels, in C, M, Y, K order. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

CMYK is an in-memory image whose At method returns color.CMYK values.

func NewCMYK

  1. func NewCMYK(r Rectangle) *CMYK

NewCMYK returns a new CMYK image with the given bounds.

func (*CMYK) At

  1. func (p *CMYK) At(x, y int) color.Color

func (*CMYK) Bounds

  1. func (p *CMYK) Bounds() Rectangle

func (*CMYK) CMYKAt

  1. func (p *CMYK) CMYKAt(x, y int) color.CMYK

func (*CMYK) ColorModel

  1. func (p *CMYK) ColorModel() color.Model

func (*CMYK) Opaque

  1. func (p *CMYK) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*CMYK) PixOffset

  1. func (p *CMYK) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*CMYK) Set

  1. func (p *CMYK) Set(x, y int, c color.Color)

func (*CMYK) SetCMYK

  1. func (p *CMYK) SetCMYK(x, y int, c color.CMYK)

func (*CMYK) SubImage

  1. func (p *CMYK) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Config

  1. type Config struct {
  2.     ColorModel    color.Model
  3.     Width, Height int
  4. }

Config holds an image’s color model and dimensions.

func DecodeConfig

  1. func DecodeConfig(r io.Reader) (Config, string, error)

DecodeConfig decodes the color model and dimensions of an image that has been
encoded in a registered format. The string returned is the format name used
during format registration. Format registration is typically done by an init
function in the codec-specific package.

type Gray

  1. type Gray struct {
  2.     // Pix holds the image's pixels, as gray values. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

Gray is an in-memory image whose At method returns color.Gray values.

func NewGray

  1. func NewGray(r Rectangle) *Gray

NewGray returns a new Gray image with the given bounds.

func (*Gray) At

  1. func (p *Gray) At(x, y int) color.Color

func (*Gray) Bounds

  1. func (p *Gray) Bounds() Rectangle

func (*Gray) ColorModel

  1. func (p *Gray) ColorModel() color.Model

func (*Gray) GrayAt

  1. func (p *Gray) GrayAt(x, y int) color.Gray

func (*Gray) Opaque

  1. func (p *Gray) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Gray) PixOffset

  1. func (p *Gray) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*Gray) Set

  1. func (p *Gray) Set(x, y int, c color.Color)

func (*Gray) SetGray

  1. func (p *Gray) SetGray(x, y int, c color.Gray)

func (*Gray) SubImage

  1. func (p *Gray) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Gray16

  1. type Gray16 struct {
  2.     // Pix holds the image's pixels, as gray values in big-endian format. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

Gray16 is an in-memory image whose At method returns color.Gray16 values.

func NewGray16

  1. func NewGray16(r Rectangle) *Gray16

NewGray16 returns a new Gray16 image with the given bounds.

func (*Gray16) At

  1. func (p *Gray16) At(x, y int) color.Color

func (*Gray16) Bounds

  1. func (p *Gray16) Bounds() Rectangle

func (*Gray16) ColorModel

  1. func (p *Gray16) ColorModel() color.Model

func (*Gray16) Gray16At

  1. func (p *Gray16) Gray16At(x, y int) color.Gray16

func (*Gray16) Opaque

  1. func (p *Gray16) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Gray16) PixOffset

  1. func (p *Gray16) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*Gray16) Set

  1. func (p *Gray16) Set(x, y int, c color.Color)

func (*Gray16) SetGray16

  1. func (p *Gray16) SetGray16(x, y int, c color.Gray16)

func (*Gray16) SubImage

  1. func (p *Gray16) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Image

  1. type Image interface {
  2.     // ColorModel returns the Image's color model.
  3.     ColorModel() color.Model
  4.     // Bounds returns the domain for which At can return non-zero color.
  5.     // The bounds do not necessarily contain the point (0, 0).
  6.     Bounds() Rectangle
  7.     // At returns the color of the pixel at (x, y).
  8.     // At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
  9.     // At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.
  10.     At(x, y int) color.Color
  11. }

Image is a finite rectangular grid of color.Color values taken from a color
model.

func Decode

  1. func Decode(r io.Reader) (Image, string, error)

Decode decodes an image that has been encoded in a registered format. The string
returned is the format name used during format registration. Format registration
is typically done by an init function in the codec- specific package.

type NRGBA

  1. type NRGBA struct {
  2.     // Pix holds the image's pixels, in R, G, B, A order. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

NRGBA is an in-memory image whose At method returns color.NRGBA values.

func NewNRGBA

  1. func NewNRGBA(r Rectangle) *NRGBA

NewNRGBA returns a new NRGBA image with the given bounds.

func (*NRGBA) At

  1. func (p *NRGBA) At(x, y int) color.Color

func (*NRGBA) Bounds

  1. func (p *NRGBA) Bounds() Rectangle

func (*NRGBA) ColorModel

  1. func (p *NRGBA) ColorModel() color.Model

func (*NRGBA) NRGBAAt

  1. func (p *NRGBA) NRGBAAt(x, y int) color.NRGBA

func (*NRGBA) Opaque

  1. func (p *NRGBA) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*NRGBA) PixOffset

  1. func (p *NRGBA) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*NRGBA) Set

  1. func (p *NRGBA) Set(x, y int, c color.Color)

func (*NRGBA) SetNRGBA

  1. func (p *NRGBA) SetNRGBA(x, y int, c color.NRGBA)

func (*NRGBA) SubImage

  1. func (p *NRGBA) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type NRGBA64

  1. type NRGBA64 struct {
  2.     // Pix holds the image's pixels, in R, G, B, A order and big-endian format. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

NRGBA64 is an in-memory image whose At method returns color.NRGBA64 values.

func NewNRGBA64

  1. func NewNRGBA64(r Rectangle) *NRGBA64

NewNRGBA64 returns a new NRGBA64 image with the given bounds.

func (*NRGBA64) At

  1. func (p *NRGBA64) At(x, y int) color.Color

func (*NRGBA64) Bounds

  1. func (p *NRGBA64) Bounds() Rectangle

func (*NRGBA64) ColorModel

  1. func (p *NRGBA64) ColorModel() color.Model

func (*NRGBA64) NRGBA64At

  1. func (p *NRGBA64) NRGBA64At(x, y int) color.NRGBA64

func (*NRGBA64) Opaque

  1. func (p *NRGBA64) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*NRGBA64) PixOffset

  1. func (p *NRGBA64) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*NRGBA64) Set

  1. func (p *NRGBA64) Set(x, y int, c color.Color)

func (*NRGBA64) SetNRGBA64

  1. func (p *NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64)

func (*NRGBA64) SubImage

  1. func (p *NRGBA64) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type NYCbCrA

  1. type NYCbCrA struct {
  2.     YCbCr
  3.     A       []uint8
  4.     AStride int
  5. }

NYCbCrA is an in-memory image of non-alpha-premultiplied Y’CbCr-with-alpha
colors. A and AStride are analogous to the Y and YStride fields of the embedded
YCbCr.

func NewNYCbCrA

  1. func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA

NewNYCbCrA returns a new NYCbCrA image with the given bounds and subsample
ratio.

func (*NYCbCrA) AOffset

  1. func (p *NYCbCrA) AOffset(x, y int) int

AOffset returns the index of the first element of A that corresponds to the
pixel at (x, y).

func (*NYCbCrA) At

  1. func (p *NYCbCrA) At(x, y int) color.Color

func (*NYCbCrA) ColorModel

  1. func (p *NYCbCrA) ColorModel() color.Model

func (*NYCbCrA) NYCbCrAAt

  1. func (p *NYCbCrA) NYCbCrAAt(x, y int) color.NYCbCrA

func (*NYCbCrA) Opaque

  1. func (p *NYCbCrA) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*NYCbCrA) SubImage

  1. func (p *NYCbCrA) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Paletted

  1. type Paletted struct {
  2.     // Pix holds the image's pixels, as palette indices. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9.     // Palette is the image's palette.
  10.     Palette color.Palette
  11. }

Paletted is an in-memory image of uint8 indices into a given palette.

func NewPaletted

  1. func NewPaletted(r Rectangle, p color.Palette) *Paletted

NewPaletted returns a new Paletted image with the given width, height and
palette.

func (*Paletted) At

  1. func (p *Paletted) At(x, y int) color.Color

func (*Paletted) Bounds

  1. func (p *Paletted) Bounds() Rectangle

func (*Paletted) ColorIndexAt

  1. func (p *Paletted) ColorIndexAt(x, y int) uint8

func (*Paletted) ColorModel

  1. func (p *Paletted) ColorModel() color.Model

func (*Paletted) Opaque

  1. func (p *Paletted) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Paletted) PixOffset

  1. func (p *Paletted) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*Paletted) Set

  1. func (p *Paletted) Set(x, y int, c color.Color)

func (*Paletted) SetColorIndex

  1. func (p *Paletted) SetColorIndex(x, y int, index uint8)

func (*Paletted) SubImage

  1. func (p *Paletted) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type PalettedImage

  1. type PalettedImage interface {
  2.     // ColorIndexAt returns the palette index of the pixel at (x, y).
  3.     ColorIndexAt(x, y int) uint8
  4.     Image
  5. }

PalettedImage is an image whose colors may come from a limited palette. If m is
a PalettedImage and m.ColorModel() returns a color.Palette p, then m.At(x, y)
should be equivalent to p[m.ColorIndexAt(x, y)]. If m’s color model is not a
color.Palette, then ColorIndexAt’s behavior is undefined.

type Point

  1. type Point struct {
  2.     X, Y int
  3. }

A Point is an X, Y coordinate pair. The axes increase right and down.

  1. var ZP Point

ZP is the zero Point.

func Pt

  1. func Pt(X, Y int) Point

Pt is shorthand for Point{X, Y}.

func (Point) Add

  1. func (p Point) Add(q Point) Point

Add returns the vector p+q.

func (Point) Div

  1. func (p Point) Div(k int) Point

Div returns the vector p/k.

func (Point) Eq

  1. func (p Point) Eq(q Point) bool

Eq reports whether p and q are equal.

func (Point) In

  1. func (p Point) In(r Rectangle) bool

In reports whether p is in r.

func (Point) Mod

  1. func (p Point) Mod(r Rectangle) Point

Mod returns the point q in r such that p.X-q.X is a multiple of r’s width and
p.Y-q.Y is a multiple of r’s height.

func (Point) Mul

  1. func (p Point) Mul(k int) Point

Mul returns the vector p*k.

func (Point) String

  1. func (p Point) String() string

String returns a string representation of p like “(3,4)”.

func (Point) Sub

  1. func (p Point) Sub(q Point) Point

Sub returns the vector p-q.

type RGBA

  1. type RGBA struct {
  2.     // Pix holds the image's pixels, in R, G, B, A order. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

RGBA is an in-memory image whose At method returns color.RGBA values.

func NewRGBA

  1. func NewRGBA(r Rectangle) *RGBA

NewRGBA returns a new RGBA image with the given bounds.

func (*RGBA) At

  1. func (p *RGBA) At(x, y int) color.Color

func (*RGBA) Bounds

  1. func (p *RGBA) Bounds() Rectangle

func (*RGBA) ColorModel

  1. func (p *RGBA) ColorModel() color.Model

func (*RGBA) Opaque

  1. func (p *RGBA) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*RGBA) PixOffset

  1. func (p *RGBA) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*RGBA) RGBAAt

  1. func (p *RGBA) RGBAAt(x, y int) color.RGBA

func (*RGBA) Set

  1. func (p *RGBA) Set(x, y int, c color.Color)

func (*RGBA) SetRGBA

  1. func (p *RGBA) SetRGBA(x, y int, c color.RGBA)

func (*RGBA) SubImage

  1. func (p *RGBA) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type RGBA64

  1. type RGBA64 struct {
  2.     // Pix holds the image's pixels, in R, G, B, A order and big-endian format. The pixel at
  3.     // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8].
  4.     Pix []uint8
  5.     // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
  6.     Stride int
  7.     // Rect is the image's bounds.
  8.     Rect Rectangle
  9. }

RGBA64 is an in-memory image whose At method returns color.RGBA64 values.

func NewRGBA64

  1. func NewRGBA64(r Rectangle) *RGBA64

NewRGBA64 returns a new RGBA64 image with the given bounds.

func (*RGBA64) At

  1. func (p *RGBA64) At(x, y int) color.Color

func (*RGBA64) Bounds

  1. func (p *RGBA64) Bounds() Rectangle

func (*RGBA64) ColorModel

  1. func (p *RGBA64) ColorModel() color.Model

func (*RGBA64) Opaque

  1. func (p *RGBA64) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*RGBA64) PixOffset

  1. func (p *RGBA64) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the
pixel at (x, y).

func (*RGBA64) RGBA64At

  1. func (p *RGBA64) RGBA64At(x, y int) color.RGBA64

func (*RGBA64) Set

  1. func (p *RGBA64) Set(x, y int, c color.Color)

func (*RGBA64) SetRGBA64

  1. func (p *RGBA64) SetRGBA64(x, y int, c color.RGBA64)

func (*RGBA64) SubImage

  1. func (p *RGBA64) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

type Rectangle

  1. type Rectangle struct {
  2.     Min, Max Point
  3. }

A Rectangle contains the points with Min.X <= X < Max.X, Min.Y <= Y < Max.Y. It
is well-formed if Min.X <= Max.X and likewise for Y. Points are always
well-formed. A rectangle’s methods always return well-formed outputs for
well-formed inputs.

A Rectangle is also an Image whose bounds are the rectangle itself. At returns
color.Opaque for points in the rectangle and color.Transparent otherwise.

  1. var ZR Rectangle

ZR is the zero Rectangle.

func Rect

  1. func Rect(x0, y0, x1, y1 int) Rectangle

Rect is shorthand for Rectangle{Pt(x0, y0), Pt(x1, y1)}. The returned rectangle
has minimum and maximum coordinates swapped if necessary so that it is
well-formed.

func (Rectangle) Add

  1. func (r Rectangle) Add(p Point) Rectangle

Add returns the rectangle r translated by p.

func (Rectangle) At

  1. func (r Rectangle) At(x, y int) color.Color

At implements the Image interface.

func (Rectangle) Bounds

  1. func (r Rectangle) Bounds() Rectangle

Bounds implements the Image interface.

func (Rectangle) Canon

  1. func (r Rectangle) Canon() Rectangle

Canon returns the canonical version of r. The returned rectangle has minimum and
maximum coordinates swapped if necessary so that it is well-formed.

func (Rectangle) ColorModel

  1. func (r Rectangle) ColorModel() color.Model

ColorModel implements the Image interface.

func (Rectangle) Dx

  1. func (r Rectangle) Dx() int

Dx returns r’s width.

func (Rectangle) Dy

  1. func (r Rectangle) Dy() int

Dy returns r’s height.

func (Rectangle) Empty

  1. func (r Rectangle) Empty() bool

Empty reports whether the rectangle contains no points.

func (Rectangle) Eq

  1. func (r Rectangle) Eq(s Rectangle) bool

Eq reports whether r and s contain the same set of points. All empty rectangles
are considered equal.

func (Rectangle) In

  1. func (r Rectangle) In(s Rectangle) bool

In reports whether every point in r is in s.

func (Rectangle) Inset

  1. func (r Rectangle) Inset(n int) Rectangle

Inset returns the rectangle r inset by n, which may be negative. If either of
r’s dimensions is less than 2*n then an empty rectangle near the center of r
will be returned.

func (Rectangle) Intersect

  1. func (r Rectangle) Intersect(s Rectangle) Rectangle

Intersect returns the largest rectangle contained by both r and s. If the two
rectangles do not overlap then the zero rectangle will be returned.

func (Rectangle) Overlaps

  1. func (r Rectangle) Overlaps(s Rectangle) bool

Overlaps reports whether r and s have a non-empty intersection.

func (Rectangle) Size

  1. func (r Rectangle) Size() Point

Size returns r’s width and height.

func (Rectangle) String

  1. func (r Rectangle) String() string

String returns a string representation of r like “(3,4)-(6,5)”.

func (Rectangle) Sub

  1. func (r Rectangle) Sub(p Point) Rectangle

Sub returns the rectangle r translated by -p.

func (Rectangle) Union

  1. func (r Rectangle) Union(s Rectangle) Rectangle

Union returns the smallest rectangle that contains both r and s.

type Uniform

  1. type Uniform struct {
  2.     C color.Color
  3. }

Uniform is an infinite-sized Image of uniform color. It implements the
color.Color, color.Model, and Image interfaces.

func NewUniform

  1. func NewUniform(c color.Color) *Uniform

func (*Uniform) At

  1. func (c *Uniform) At(x, y int) color.Color

func (*Uniform) Bounds

  1. func (c *Uniform) Bounds() Rectangle

func (*Uniform) ColorModel

  1. func (c *Uniform) ColorModel() color.Model

func (*Uniform) Convert

  1. func (c *Uniform) Convert(color.Color) color.Color

func (*Uniform) Opaque

  1. func (c *Uniform) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Uniform) RGBA

  1. func (c *Uniform) RGBA() (r, g, b, a uint32)

type YCbCr

  1. type YCbCr struct {
  2.     Y, Cb, Cr      []uint8
  3.     YStride        int
  4.     CStride        int
  5.     SubsampleRatio YCbCrSubsampleRatio
  6.     Rect           Rectangle
  7. }

YCbCr is an in-memory image of Y’CbCr colors. There is one Y sample per pixel,
but each Cb and Cr sample can span one or more pixels. YStride is the Y slice
index delta between vertically adjacent pixels. CStride is the Cb and Cr slice
index delta between vertically adjacent pixels that map to separate chroma
samples. It is not an absolute requirement, but YStride and len(Y) are typically
multiples of 8, and:

  1. For 4:4:4, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/1.
  2. For 4:2:2, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/2.
  3. For 4:2:0, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/4.
  4. For 4:4:0, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/2.
  5. For 4:1:1, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/4.
  6. For 4:1:0, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/8.

func NewYCbCr

  1. func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr

NewYCbCr returns a new YCbCr image with the given bounds and subsample ratio.

func (*YCbCr) At

  1. func (p *YCbCr) At(x, y int) color.Color

func (*YCbCr) Bounds

  1. func (p *YCbCr) Bounds() Rectangle

func (*YCbCr) COffset

  1. func (p *YCbCr) COffset(x, y int) int

COffset returns the index of the first element of Cb or Cr that corresponds to
the pixel at (x, y).

func (*YCbCr) ColorModel

  1. func (p *YCbCr) ColorModel() color.Model

func (*YCbCr) Opaque

  1. func (p *YCbCr) Opaque() bool

func (*YCbCr) SubImage

  1. func (p *YCbCr) SubImage(r Rectangle) Image

SubImage returns an image representing the portion of the image p visible
through r. The returned value shares pixels with the original image.

func (*YCbCr) YCbCrAt

  1. func (p *YCbCr) YCbCrAt(x, y int) color.YCbCr

func (*YCbCr) YOffset

  1. func (p *YCbCr) YOffset(x, y int) int

YOffset returns the index of the first element of Y that corresponds to the
pixel at (x, y).

type YCbCrSubsampleRatio

  1. type YCbCrSubsampleRatio int

YCbCrSubsampleRatio is the chroma subsample ratio used in a YCbCr image.

  1. const (
  2.     YCbCrSubsampleRatio444 YCbCrSubsampleRatio = iota
  3.     YCbCrSubsampleRatio422
  4.     YCbCrSubsampleRatio420
  5.     YCbCrSubsampleRatio440
  6.     YCbCrSubsampleRatio411
  7.     YCbCrSubsampleRatio410
  8. )

func (YCbCrSubsampleRatio) String

  1. func (s YCbCrSubsampleRatio) String() string

Subdirectories