package image

Import Path
	image (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 5 packages

Involved Source Files

	    format.go
	    geom.go
	  d image.go
		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
		
			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
		
		# Security Considerations
		
		The image package can be used to parse arbitrarily large images, which can
		cause resource exhaustion on machines which do not have enough memory to
		store them. When operating on arbitrary images, [DecodeConfig] should be called
		before [Decode], so that the program can decide whether the image, as defined
		in the returned header, can be safely decoded with the available resources. A
		call to [Decode] which produces an extremely large image, as defined in the
		header returned by [DecodeConfig], is not considered a security issue,
		regardless of whether the image is itself malformed or not. A call to
		[DecodeConfig] which returns a header which does not match the image returned
		by [Decode] may be considered a security issue, and should be reported per the
		[Go Security Policy](https://go.dev/security/policy).

	    names.go
	    ycbcr.go
Package-Level Type Names (total 20)

	/* sort by: alphabet | popularity */
	 type Alpha (struct)
		Alpha is an in-memory image whose At method returns [color.Alpha] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*Alpha) AlphaAt(x, y int) color.Alpha
			(*Alpha) At(x, y int) color.Color
			(*Alpha) Bounds() Rectangle
			(*Alpha) ColorModel() color.Model
			(*Alpha) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*Alpha) RGBA64At(x, y int) color.RGBA64
			(*Alpha) Set(x, y int, c color.Color)
			(*Alpha) SetAlpha(x, y int, c color.Alpha)
			(*Alpha) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*Alpha : Image
			*Alpha : RGBA64Image
			*Alpha : image/draw.Image
			*Alpha : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewAlpha(r Rectangle) *Alpha

	 type Alpha16 (struct)
		Alpha16 is an in-memory image whose At method returns [color.Alpha16] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*Alpha16) Alpha16At(x, y int) color.Alpha16
			(*Alpha16) At(x, y int) color.Color
			(*Alpha16) Bounds() Rectangle
			(*Alpha16) ColorModel() color.Model
			(*Alpha16) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*Alpha16) RGBA64At(x, y int) color.RGBA64
			(*Alpha16) Set(x, y int, c color.Color)
			(*Alpha16) SetAlpha16(x, y int, c color.Alpha16)
			(*Alpha16) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*Alpha16 : Image
			*Alpha16 : RGBA64Image
			*Alpha16 : image/draw.Image
			*Alpha16 : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewAlpha16(r Rectangle) *Alpha16

	 type CMYK (struct)
		CMYK is an in-memory image whose At method returns [color.CMYK] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*CMYK) At(x, y int) color.Color
			(*CMYK) Bounds() Rectangle
			(*CMYK) CMYKAt(x, y int) color.CMYK
			(*CMYK) ColorModel() color.Model
			(*CMYK) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*CMYK) RGBA64At(x, y int) color.RGBA64
			(*CMYK) Set(x, y int, c color.Color)
			(*CMYK) SetCMYK(x, y int, c color.CMYK)
			(*CMYK) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*CMYK : Image
			*CMYK : RGBA64Image
			*CMYK : image/draw.Image
			*CMYK : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewCMYK(r Rectangle) *CMYK

	 type Config (struct)
		Config holds an image's color model and dimensions.

		Fields (total 3)
			ColorModel color.Model
			Height int
			Width int
		As Outputs Of (at least 4)
			func DecodeConfig(r io.Reader) (Config, string, error)
			func image/gif.DecodeConfig(r io.Reader) (Config, error)
			func image/jpeg.DecodeConfig(r io.Reader) (Config, error)
			func image/png.DecodeConfig(r io.Reader) (Config, error)

	 type Gray (struct)
		Gray is an in-memory image whose At method returns [color.Gray] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*Gray) At(x, y int) color.Color
			(*Gray) Bounds() Rectangle
			(*Gray) ColorModel() color.Model
			(*Gray) GrayAt(x, y int) color.Gray
			(*Gray) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*Gray) RGBA64At(x, y int) color.RGBA64
			(*Gray) Set(x, y int, c color.Color)
			(*Gray) SetGray(x, y int, c color.Gray)
			(*Gray) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*Gray : Image
			*Gray : RGBA64Image
			*Gray : image/draw.Image
			*Gray : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewGray(r Rectangle) *Gray

	 type Gray16 (struct)
		Gray16 is an in-memory image whose At method returns [color.Gray16] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*Gray16) At(x, y int) color.Color
			(*Gray16) Bounds() Rectangle
			(*Gray16) ColorModel() color.Model
			(*Gray16) Gray16At(x, y int) color.Gray16
			(*Gray16) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*Gray16) RGBA64At(x, y int) color.RGBA64
			(*Gray16) Set(x, y int, c color.Color)
			(*Gray16) SetGray16(x, y int, c color.Gray16)
			(*Gray16) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*Gray16 : Image
			*Gray16 : RGBA64Image
			*Gray16 : image/draw.Image
			*Gray16 : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewGray16(r Rectangle) *Gray16

	 type Image (interface)
		Image is a finite rectangular grid of [color.Color] values taken from a color
		model.

		Methods (total 3)
			( Image) At(x, y int) color.Color
				At returns the color of the pixel at (x, y).
				At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
				At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.

			( Image) Bounds() Rectangle
				Bounds returns the domain for which At can return non-zero color.
				The bounds do not necessarily contain the point (0, 0).

			( Image) ColorModel() color.Model
				ColorModel returns the Image's color model.

		Implemented By (at least 18)
			*Alpha
			*Alpha16
			*CMYK
			*Gray
			*Gray16
			*NRGBA
			*NRGBA64
			*NYCbCrA
			*Paletted
			 PalettedImage (interface)
			 Rectangle
			*RGBA
			*RGBA64
			 RGBA64Image (interface)
			*Uniform
			*YCbCr
			 image/draw.Image (interface)
			 image/draw.RGBA64Image (interface)
		As Outputs Of (at least 16)
			func Decode(r io.Reader) (Image, string, error)
			func (*Alpha).SubImage(r Rectangle) Image
			func (*Alpha16).SubImage(r Rectangle) Image
			func (*CMYK).SubImage(r Rectangle) Image
			func (*Gray).SubImage(r Rectangle) Image
			func (*Gray16).SubImage(r Rectangle) Image
			func (*NRGBA).SubImage(r Rectangle) Image
			func (*NRGBA64).SubImage(r Rectangle) Image
			func (*NYCbCrA).SubImage(r Rectangle) Image
			func (*Paletted).SubImage(r Rectangle) Image
			func (*RGBA).SubImage(r Rectangle) Image
			func (*RGBA64).SubImage(r Rectangle) Image
			func (*YCbCr).SubImage(r Rectangle) Image
			func image/gif.Decode(r io.Reader) (Image, error)
			func image/jpeg.Decode(r io.Reader) (Image, error)
			func image/png.Decode(r io.Reader) (Image, error)
		As Inputs Of (at least 10)
			func image/draw.Draw(dst draw.Image, r Rectangle, src Image, sp Point, op draw.Op)
			func image/draw.DrawMask(dst draw.Image, r Rectangle, src Image, sp Point, mask Image, mp Point, op draw.Op)
			func image/draw.DrawMask(dst draw.Image, r Rectangle, src Image, sp Point, mask Image, mp Point, op draw.Op)
			func image/draw.Drawer.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/draw.Op.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/draw.Quantizer.Quantize(p color.Palette, m Image) color.Palette
			func image/gif.Encode(w io.Writer, m Image, o *gif.Options) error
			func image/jpeg.Encode(w io.Writer, m Image, o *jpeg.Options) error
			func image/png.Encode(w io.Writer, m Image) error
			func image/png.(*Encoder).Encode(w io.Writer, m Image) error

	 type NRGBA (struct)
		NRGBA is an in-memory image whose At method returns [color.NRGBA] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*NRGBA) At(x, y int) color.Color
			(*NRGBA) Bounds() Rectangle
			(*NRGBA) ColorModel() color.Model
			(*NRGBA) NRGBAAt(x, y int) color.NRGBA
			(*NRGBA) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*NRGBA) RGBA64At(x, y int) color.RGBA64
			(*NRGBA) Set(x, y int, c color.Color)
			(*NRGBA) SetNRGBA(x, y int, c color.NRGBA)
			(*NRGBA) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*NRGBA : Image
			*NRGBA : RGBA64Image
			*NRGBA : image/draw.Image
			*NRGBA : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewNRGBA(r Rectangle) *NRGBA

	 type NRGBA64 (struct)
		NRGBA64 is an in-memory image whose At method returns [color.NRGBA64] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*NRGBA64) At(x, y int) color.Color
			(*NRGBA64) Bounds() Rectangle
			(*NRGBA64) ColorModel() color.Model
			(*NRGBA64) NRGBA64At(x, y int) color.NRGBA64
			(*NRGBA64) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*NRGBA64) RGBA64At(x, y int) color.RGBA64
			(*NRGBA64) Set(x, y int, c color.Color)
			(*NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64)
			(*NRGBA64) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*NRGBA64 : Image
			*NRGBA64 : RGBA64Image
			*NRGBA64 : image/draw.Image
			*NRGBA64 : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewNRGBA64(r Rectangle) *NRGBA64

	 type NYCbCrA (struct)
		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.

		Fields (total 10)
			A []uint8
			AStride int
			YCbCr YCbCr
			YCbCr.CStride int
			YCbCr.Cb []uint8
			YCbCr.Cr []uint8
			YCbCr.Rect Rectangle
			YCbCr.SubsampleRatio YCbCrSubsampleRatio
			YCbCr.Y []uint8
			YCbCr.YStride int
		Methods (total 11)
			(*NYCbCrA) AOffset(x, y int) int
				AOffset returns the index of the first element of A that corresponds to the
				pixel at (x, y).

			(*NYCbCrA) At(x, y int) color.Color
			(*NYCbCrA) Bounds() Rectangle
			(*NYCbCrA) 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).

			(*NYCbCrA) ColorModel() color.Model
			(*NYCbCrA) NYCbCrAAt(x, y int) color.NYCbCrA
			(*NYCbCrA) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

			(*NYCbCrA) RGBA64At(x, y int) color.RGBA64
			(*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.

			(*NYCbCrA) YCbCrAt(x, y int) color.YCbCr
			(*NYCbCrA) YOffset(x, y int) int
				YOffset returns the index of the first element of Y that corresponds to
				the pixel at (x, y).

		Implements (at least 2)
			*NYCbCrA : Image
			*NYCbCrA : RGBA64Image
		As Outputs Of (at least one exported)
			func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA

	 type Paletted (struct)
		Paletted is an in-memory image of uint8 indices into a given palette.

		Fields (total 4)
			Palette color.Palette
				Palette is the image's palette.

			Pix []uint8
				Pix holds the image's pixels, as palette indices. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*Paletted) At(x, y int) color.Color
			(*Paletted) Bounds() Rectangle
			(*Paletted) ColorIndexAt(x, y int) uint8
			(*Paletted) ColorModel() color.Model
			(*Paletted) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*Paletted) RGBA64At(x, y int) color.RGBA64
			(*Paletted) Set(x, y int, c color.Color)
			(*Paletted) SetColorIndex(x, y int, index uint8)
			(*Paletted) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 5)
			*Paletted : Image
			*Paletted : PalettedImage
			*Paletted : RGBA64Image
			*Paletted : image/draw.Image
			*Paletted : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewPaletted(r Rectangle, p color.Palette) *Paletted

	 type PalettedImage (interface)
		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.

		Methods (total 4)
			( PalettedImage) At(x, y int) color.Color
				At returns the color of the pixel at (x, y).
				At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
				At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.

			( PalettedImage) Bounds() Rectangle
				Bounds returns the domain for which At can return non-zero color.
				The bounds do not necessarily contain the point (0, 0).

			( PalettedImage) ColorIndexAt(x, y int) uint8
				ColorIndexAt returns the palette index of the pixel at (x, y).

			( PalettedImage) ColorModel() color.Model
				ColorModel returns the Image's color model.

		Implemented By (at least one exported)
			*Paletted
		Implements (at least one exported)
			 PalettedImage : Image

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

		Fields (total 2)
			X int
			Y int
		Methods (total 8)
			( Point) Add(q Point) Point
				Add returns the vector p+q.

			( Point) Div(k int) Point
				Div returns the vector p/k.

			( Point) Eq(q Point) bool
				Eq reports whether p and q are equal.

			( Point) In(r Rectangle) bool
				In reports whether p is in r.

			( 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.

			( Point) Mul(k int) Point
				Mul returns the vector p*k.

			( Point) String() string
				String returns a string representation of p like "(3,4)".

			( Point) Sub(q Point) Point
				Sub returns the vector p-q.

		Implements (at least 2)
			 Point : expvar.Var
			 Point : fmt.Stringer
		As Outputs Of (at least 7)
			func Pt(X, Y int) Point
			func Point.Add(q Point) Point
			func Point.Div(k int) Point
			func Point.Mod(r Rectangle) Point
			func Point.Mul(k int) Point
			func Point.Sub(q Point) Point
			func Rectangle.Size() Point
		As Inputs Of (at least 11)
			func Point.Add(q Point) Point
			func Point.Eq(q Point) bool
			func Point.Sub(q Point) Point
			func Rectangle.Add(p Point) Rectangle
			func Rectangle.Sub(p Point) Rectangle
			func image/draw.Draw(dst draw.Image, r Rectangle, src Image, sp Point, op draw.Op)
			func image/draw.DrawMask(dst draw.Image, r Rectangle, src Image, sp Point, mask Image, mp Point, op draw.Op)
			func image/draw.DrawMask(dst draw.Image, r Rectangle, src Image, sp Point, mask Image, mp Point, op draw.Op)
			func image/draw.Drawer.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/draw.Op.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/internal/imageutil.DrawYCbCr(dst *RGBA, r Rectangle, src *YCbCr, sp Point) (ok bool)
		As Types Of (only one)
			  var ZP

	 type Rectangle (struct)
		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.

		Fields (total 2)
			Max Point
			Min Point
		Methods (total 18)
			( Rectangle) Add(p Point) Rectangle
				Add returns the rectangle r translated by p.

			( Rectangle) At(x, y int) color.Color
				At implements the [Image] interface.

			( Rectangle) Bounds() Rectangle
				Bounds implements the [Image] interface.

			( 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.

			( Rectangle) ColorModel() color.Model
				ColorModel implements the [Image] interface.

			( Rectangle) Dx() int
				Dx returns r's width.

			( Rectangle) Dy() int
				Dy returns r's height.

			( Rectangle) Empty() bool
				Empty reports whether the rectangle contains no points.

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

			( Rectangle) In(s Rectangle) bool
				In reports whether every point in r is in s.

			( 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.

			( 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.

			( Rectangle) Overlaps(s Rectangle) bool
				Overlaps reports whether r and s have a non-empty intersection.

			( Rectangle) RGBA64At(x, y int) color.RGBA64
				RGBA64At implements the [RGBA64Image] interface.

			( Rectangle) Size() Point
				Size returns r's width and height.

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

			( Rectangle) Sub(p Point) Rectangle
				Sub returns the rectangle r translated by -p.

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

		Implements (at least 4)
			 Rectangle : Image
			 Rectangle : RGBA64Image
			 Rectangle : expvar.Var
			 Rectangle : fmt.Stringer
		As Outputs Of (at least 25)
			func Rect(x0, y0, x1, y1 int) Rectangle
			func (*Alpha).Bounds() Rectangle
			func (*Alpha16).Bounds() Rectangle
			func (*CMYK).Bounds() Rectangle
			func (*Gray).Bounds() Rectangle
			func (*Gray16).Bounds() Rectangle
			func Image.Bounds() Rectangle
			func (*NRGBA).Bounds() Rectangle
			func (*NRGBA64).Bounds() Rectangle
			func (*Paletted).Bounds() Rectangle
			func PalettedImage.Bounds() Rectangle
			func Rectangle.Add(p Point) Rectangle
			func Rectangle.Bounds() Rectangle
			func Rectangle.Canon() Rectangle
			func Rectangle.Inset(n int) Rectangle
			func Rectangle.Intersect(s Rectangle) Rectangle
			func Rectangle.Sub(p Point) Rectangle
			func Rectangle.Union(s Rectangle) Rectangle
			func (*RGBA).Bounds() Rectangle
			func (*RGBA64).Bounds() Rectangle
			func RGBA64Image.Bounds() Rectangle
			func (*Uniform).Bounds() Rectangle
			func (*YCbCr).Bounds() Rectangle
			func image/draw.Image.Bounds() Rectangle
			func image/draw.RGBA64Image.Bounds() Rectangle
		As Inputs Of (at least 36)
			func NewAlpha(r Rectangle) *Alpha
			func NewAlpha16(r Rectangle) *Alpha16
			func NewCMYK(r Rectangle) *CMYK
			func NewGray(r Rectangle) *Gray
			func NewGray16(r Rectangle) *Gray16
			func NewNRGBA(r Rectangle) *NRGBA
			func NewNRGBA64(r Rectangle) *NRGBA64
			func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA
			func NewPaletted(r Rectangle, p color.Palette) *Paletted
			func NewRGBA(r Rectangle) *RGBA
			func NewRGBA64(r Rectangle) *RGBA64
			func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr
			func (*Alpha).SubImage(r Rectangle) Image
			func (*Alpha16).SubImage(r Rectangle) Image
			func (*CMYK).SubImage(r Rectangle) Image
			func (*Gray).SubImage(r Rectangle) Image
			func (*Gray16).SubImage(r Rectangle) Image
			func (*NRGBA).SubImage(r Rectangle) Image
			func (*NRGBA64).SubImage(r Rectangle) Image
			func (*NYCbCrA).SubImage(r Rectangle) Image
			func (*Paletted).SubImage(r Rectangle) Image
			func Point.In(r Rectangle) bool
			func Point.Mod(r Rectangle) Point
			func Rectangle.Eq(s Rectangle) bool
			func Rectangle.In(s Rectangle) bool
			func Rectangle.Intersect(s Rectangle) Rectangle
			func Rectangle.Overlaps(s Rectangle) bool
			func Rectangle.Union(s Rectangle) Rectangle
			func (*RGBA).SubImage(r Rectangle) Image
			func (*RGBA64).SubImage(r Rectangle) Image
			func (*YCbCr).SubImage(r Rectangle) Image
			func image/draw.Draw(dst draw.Image, r Rectangle, src Image, sp Point, op draw.Op)
			func image/draw.DrawMask(dst draw.Image, r Rectangle, src Image, sp Point, mask Image, mp Point, op draw.Op)
			func image/draw.Drawer.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/draw.Op.Draw(dst draw.Image, r Rectangle, src Image, sp Point)
			func image/internal/imageutil.DrawYCbCr(dst *RGBA, r Rectangle, src *YCbCr, sp Point) (ok bool)
		As Types Of (only one)
			  var ZR

	 type RGBA (struct)
		RGBA is an in-memory image whose At method returns [color.RGBA] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 11)
			(*RGBA) At(x, y int) color.Color
			(*RGBA) Bounds() Rectangle
			(*RGBA) ColorModel() color.Model
			(*RGBA) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*RGBA) RGBA64At(x, y int) color.RGBA64
			(*RGBA) RGBAAt(x, y int) color.RGBA
			(*RGBA) Set(x, y int, c color.Color)
			(*RGBA) SetRGBA(x, y int, c color.RGBA)
			(*RGBA) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*RGBA : Image
			*RGBA : RGBA64Image
			*RGBA : image/draw.Image
			*RGBA : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewRGBA(r Rectangle) *RGBA
		As Inputs Of (at least one exported)
			func image/internal/imageutil.DrawYCbCr(dst *RGBA, r Rectangle, src *YCbCr, sp Point) (ok bool)

	 type RGBA64 (struct)
		RGBA64 is an in-memory image whose At method returns [color.RGBA64] values.

		Fields (total 3)
			Pix []uint8
				Pix holds the image's pixels, in R, G, B, A order. The pixel at
				(x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].

			Rect Rectangle
				Rect is the image's bounds.

			Stride int
				Stride is the Pix stride (in bytes) between vertically adjacent pixels.

		Methods (total 9)
			(*RGBA64) At(x, y int) color.Color
			(*RGBA64) Bounds() Rectangle
			(*RGBA64) ColorModel() color.Model
			(*RGBA64) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

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

			(*RGBA64) RGBA64At(x, y int) color.RGBA64
			(*RGBA64) Set(x, y int, c color.Color)
			(*RGBA64) SetRGBA64(x, y int, c color.RGBA64)
			(*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.

		Implements (at least 4)
			*RGBA64 : Image
			*RGBA64 : RGBA64Image
			*RGBA64 : image/draw.Image
			*RGBA64 : image/draw.RGBA64Image
		As Outputs Of (at least one exported)
			func NewRGBA64(r Rectangle) *RGBA64

	 type RGBA64Image (interface)
		RGBA64Image is an [Image] whose pixels can be converted directly to a
		color.RGBA64.

		Methods (total 4)
			( RGBA64Image) At(x, y int) color.Color
				At returns the color of the pixel at (x, y).
				At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
				At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.

			( RGBA64Image) Bounds() Rectangle
				Bounds returns the domain for which At can return non-zero color.
				The bounds do not necessarily contain the point (0, 0).

			( RGBA64Image) ColorModel() color.Model
				ColorModel returns the Image's color model.

			( RGBA64Image) RGBA64At(x, y int) color.RGBA64
				RGBA64At returns the RGBA64 color of the pixel at (x, y). It is
				equivalent to calling At(x, y).RGBA() and converting the resulting
				32-bit return values to a color.RGBA64, but it can avoid allocations
				from converting concrete color types to the color.Color interface type.

		Implemented By (at least 15)
			*Alpha
			*Alpha16
			*CMYK
			*Gray
			*Gray16
			*NRGBA
			*NRGBA64
			*NYCbCrA
			*Paletted
			 Rectangle
			*RGBA
			*RGBA64
			*Uniform
			*YCbCr
			 image/draw.RGBA64Image (interface)
		Implements (at least one exported)
			 RGBA64Image : Image

	 type Uniform (struct)
		Uniform is an infinite-sized [Image] of uniform color.
		It implements the [color.Color], [color.Model], and [Image] interfaces.

		Fields (only one)
			C color.Color
		Methods (total 7)
			(*Uniform) At(x, y int) color.Color
			(*Uniform) Bounds() Rectangle
			(*Uniform) ColorModel() color.Model
			(*Uniform) Convert(color.Color) color.Color
			(*Uniform) Opaque() bool
				Opaque scans the entire image and reports whether it is fully opaque.

			(*Uniform) RGBA() (r, g, b, a uint32)
			(*Uniform) RGBA64At(x, y int) color.RGBA64
		Implements (at least 4)
			*Uniform : Image
			*Uniform : RGBA64Image
			*Uniform : image/color.Color
			*Uniform : image/color.Model
		As Outputs Of (at least one exported)
			func NewUniform(c color.Color) *Uniform
		As Types Of (total 4)
			  var Black *Uniform
			  var Opaque *Uniform
			  var Transparent *Uniform
			  var White *Uniform

	 type YCbCr (struct)
		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:
		
			For 4:4:4, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/1.
			For 4:2:2, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/2.
			For 4:2:0, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/4.
			For 4:4:0, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/2.
			For 4:1:1, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/4.
			For 4:1:0, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/8.

		Fields (total 7)
			CStride int
			Cb []uint8
			Cr []uint8
			Rect Rectangle
			SubsampleRatio YCbCrSubsampleRatio
			Y []uint8
			YStride int
		Methods (total 9)
			(*YCbCr) At(x, y int) color.Color
			(*YCbCr) Bounds() Rectangle
			(*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).

			(*YCbCr) ColorModel() color.Model
			(*YCbCr) Opaque() bool
			(*YCbCr) RGBA64At(x, y int) color.RGBA64
			(*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.

			(*YCbCr) YCbCrAt(x, y int) color.YCbCr
			(*YCbCr) YOffset(x, y int) int
				YOffset returns the index of the first element of Y that corresponds to
				the pixel at (x, y).

		Implements (at least 2)
			*YCbCr : Image
			*YCbCr : RGBA64Image
		As Outputs Of (at least one exported)
			func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr
		As Inputs Of (at least one exported)
			func image/internal/imageutil.DrawYCbCr(dst *RGBA, r Rectangle, src *YCbCr, sp Point) (ok bool)

	 type YCbCrSubsampleRatio int (basic type)
		YCbCrSubsampleRatio is the chroma subsample ratio used in a YCbCr image.

		Methods (only one)
			( YCbCrSubsampleRatio) String() string
		Implements (at least 2)
			 YCbCrSubsampleRatio : expvar.Var
			 YCbCrSubsampleRatio : fmt.Stringer
		As Inputs Of (at least 2)
			func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA
			func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr
		As Types Of (total 6)
			const YCbCrSubsampleRatio410
			const YCbCrSubsampleRatio411
			const YCbCrSubsampleRatio420
			const YCbCrSubsampleRatio422
			const YCbCrSubsampleRatio440
			const YCbCrSubsampleRatio444


Package-Level Functions (total 18)

	 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.

	 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.

	 func NewAlpha(r Rectangle) *Alpha
		NewAlpha returns a new [Alpha] image with the given bounds.

	 func NewAlpha16(r Rectangle) *Alpha16
		NewAlpha16 returns a new [Alpha16] image with the given bounds.

	 func NewCMYK(r Rectangle) *CMYK
		NewCMYK returns a new CMYK image with the given bounds.

	 func NewGray(r Rectangle) *Gray
		NewGray returns a new [Gray] image with the given bounds.

	 func NewGray16(r Rectangle) *Gray16
		NewGray16 returns a new [Gray16] image with the given bounds.

	 func NewNRGBA(r Rectangle) *NRGBA
		NewNRGBA returns a new [NRGBA] image with the given bounds.

	 func NewNRGBA64(r Rectangle) *NRGBA64
		NewNRGBA64 returns a new [NRGBA64] image with the given bounds.

	 func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA
		NewNYCbCrA returns a new [NYCbCrA] image with the given bounds and subsample
		ratio.

	 func NewPaletted(r Rectangle, p color.Palette) *Paletted
		NewPaletted returns a new [Paletted] image with the given width, height and
		palette.

	 func NewRGBA(r Rectangle) *RGBA
		NewRGBA returns a new [RGBA] image with the given bounds.

	 func NewRGBA64(r Rectangle) *RGBA64
		NewRGBA64 returns a new [RGBA64] image with the given bounds.

	 func NewUniform(c color.Color) *Uniform
		NewUniform returns a new [Uniform] image of the given color.

	 func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr
		NewYCbCr returns a new YCbCr image with the given bounds and subsample
		ratio.

	 func Pt(X, Y int) Point
		Pt is shorthand for [Point]{X, Y}.

	 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 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.


Package-Level Variables (total 7)

	  var Black *Uniform
		Black is an opaque black uniform image.

	  var ErrFormat error
		ErrFormat indicates that decoding encountered an unknown format.

	  var Opaque *Uniform
		Opaque is a fully opaque uniform image.

	  var Transparent *Uniform
		Transparent is a fully transparent uniform image.

	  var White *Uniform
		White is an opaque white uniform image.

	  var ZP Point
		ZP is the zero [Point].
		
		Deprecated: Use a literal [image.Point] instead.

	  var ZR Rectangle
		ZR is the zero [Rectangle].
		
		Deprecated: Use a literal [image.Rectangle] instead.


Package-Level Constants (total 6)

	const YCbCrSubsampleRatio410 YCbCrSubsampleRatio = 5
	const YCbCrSubsampleRatio411 YCbCrSubsampleRatio = 4
	const YCbCrSubsampleRatio420 YCbCrSubsampleRatio = 2
	const YCbCrSubsampleRatio422 YCbCrSubsampleRatio = 1
	const YCbCrSubsampleRatio440 YCbCrSubsampleRatio = 3
	const YCbCrSubsampleRatio444 YCbCrSubsampleRatio = 0

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.