🥮 mooncakes.io
    Sign in

    image

    MoonBit image: simple image representation.

    image
    color
    moonbit
    Download zip
    Author
    Version
    0.17.18
    License
    Apache-2.0
    Repository
    Last updated
    yesterday
    Downloads
    8K

    Dependencies

    #gmlewis/image

    check

    This is a simple image representation based on Go's implementation: https://cs.opensource.google/go/go/+/refs/tags/go1.23.3:src/image/image.go which has the copyright notice:

    // Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

    #Status

    The code has been updated to support compiler:

    $ moon version --all
moon 0.1.20261016 (1af328f 2026-10-16) ~/.moon/bin/moon
moonc v0.10.16+b1a0e846e (2026-10-16) ~/.moon/bin/moonc
moonrun 0.1.20261016 (1af328f 2026-10-16) ~/.moon/bin/moonrun

    Image

    source
    pub(open) trait Image {
      fn color_model(Self) -> &
    Model
      fn bounds(Self) -> Rectangle
      fn at(Self, Int, Int) -> &
    Color
      fn opaque_(Self) -> Bool
      fn set(Self, Int, Int, &
    Color    ) -> Unit
      fn sub_image(Self, Rectangle) -> &Image
      fn as_ycbcr(Self) -> YCbCr?
      fn raw_data(Self) -> 
    Slice    [Byte]
      fn get_bytes_per_pixel(Self) -> Int
      fn get_stride(Self) -> Int
      fn pix_offset(Self, Int, Int) -> Int
      fn color_index_at(Self, Int, Int) -> Byte
    }

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

    RGBA64Image

    source
    pub(open) trait RGBA64Image {
      fn rgba64_at(Self, Int, Int) -> 
    RGBA64
      fn color_model(Self) -> &
    Model
      fn bounds(Self) -> Rectangle
      fn at(Self, Int, Int) -> &
    Color
    }

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

    SizeError

    source
    type SizeError derive(Eq)

    impl Show for SizeError

    SizeError::equal

    source
    fn SizeError::equal(SizeError, SizeError) -> Bool

    SizeError::to_string

    source
    fn SizeError::to_string(self : SizeError) -> String

    Alpha

    source
    pub(all) struct Alpha {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    Alpha is an in-memory image whose At method returns [color.Alpha] values.
    impl Image for Alpha

    Alpha::alpha_at

    source
    fn Alpha::alpha_at(self : Alpha, x : Int, y : Int) -> 
    Alpha

    Alpha::as_ycbcr

    source
    fn Alpha::as_ycbcr(_self : Alpha) -> YCbCr?

    Alpha::at

    source
    fn Alpha::at(self : Alpha, x : Int, y : Int) -> &
    Color

    Alpha::bounds

    source
    fn Alpha::bounds(self : Alpha) -> Rectangle

    Alpha::color_index_at

    source
    fn Alpha::color_index_at(_self : Alpha, _x : Int, _y : Int) -> Byte

    Alpha::color_model

    source
    fn Alpha::color_model(_self : Alpha) -> &
    Model

    Alpha::get

    source
    #alias("_[_]")
    fn Alpha::get(self : Alpha, p : Point) -> &
    Color

    Alpha::get_bytes_per_pixel

    source
    fn Alpha::get_bytes_per_pixel(_self : Alpha) -> Int

    Alpha::get_stride

    source
    fn Alpha::get_stride(self : Alpha) -> Int

    Alpha::new

    source
    fn Alpha::new(r : Rectangle) -> Alpha raise SizeError

    Alpha::new returns a new [Alpha] image with the given bounds.

    Alpha::new_empty

    source
    fn Alpha::new_empty() -> Alpha

    Alpha::opaque_

    source
    fn Alpha::opaque_(self : Alpha) -> Bool

    Alpha::pix_offset

    source
    fn Alpha::pix_offset(self : Alpha, x : Int, y : Int) -> Int

    Alpha::raw_data

    source
    fn Alpha::raw_data(self : Alpha) -> 
    Slice    [Byte]

    Alpha::rgba64_at

    source
    fn Alpha::rgba64_at(self : Alpha, x : Int, y : Int) -> 
    RGBA64

    Alpha::set

    source
    fn Alpha::set(self : Alpha, x : Int, y : Int, c : &
    Color    ) -> Unit

    Alpha::set_alpha

    source
    fn Alpha::set_alpha(self : Alpha, x : Int, y : Int, c : 
    Alpha    ) -> Unit

    Alpha::set_point

    source
    #alias("_[_]=_")
    fn Alpha::set_point(self : Alpha, p : Point, c : &
    Color    ) -> Unit

    Alpha::set_rgba64

    source
    fn Alpha::set_rgba64(self : Alpha, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    Alpha::sub_image

    source
    fn Alpha::sub_image(self : Alpha, r : Rectangle) -> &Image

    Alpha16

    source
    pub(all) struct Alpha16 {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    Alpha16 is an in-memory image whose At method returns [color.Alpha16] values.
    impl Image for Alpha16

    Alpha16::alpha16_at

    source
    fn Alpha16::alpha16_at(self : Alpha16, x : Int, y : Int) -> 
    Alpha16

    Alpha16::as_ycbcr

    source
    fn Alpha16::as_ycbcr(_self : Alpha16) -> YCbCr?

    Alpha16::at

    source
    fn Alpha16::at(self : Alpha16, x : Int, y : Int) -> &
    Color

    Alpha16::bounds

    source
    fn Alpha16::bounds(self : Alpha16) -> Rectangle

    Alpha16::color_index_at

    source
    fn Alpha16::color_index_at(_self : Alpha16, _x : Int, _y : Int) -> Byte

    Alpha16::color_model

    source
    fn Alpha16::color_model(_self : Alpha16) -> &
    Model

    Alpha16::get

    source
    #alias("_[_]")
    fn Alpha16::get(self : Alpha16, p : Point) -> &
    Color

    Alpha16::get_bytes_per_pixel

    source
    fn Alpha16::get_bytes_per_pixel(_self : Alpha16) -> Int

    Alpha16::get_stride

    source
    fn Alpha16::get_stride(self : Alpha16) -> Int

    Alpha16::new

    source
    fn Alpha16::new(r : Rectangle) -> Alpha16 raise SizeError

    Alpha16::new returns a new [Alpha16] image with the given bounds.

    Alpha16::new_empty

    source
    fn Alpha16::new_empty() -> Alpha16

    Alpha16::opaque_

    source
    fn Alpha16::opaque_(self : Alpha16) -> Bool

    Alpha16::pix_offset

    source
    fn Alpha16::pix_offset(self : Alpha16, x : Int, y : Int) -> Int

    Alpha16::raw_data

    source
    fn Alpha16::raw_data(self : Alpha16) -> 
    Slice    [Byte]

    Alpha16::rgba64_at

    source
    fn Alpha16::rgba64_at(self : Alpha16, x : Int, y : Int) -> 
    RGBA64

    Alpha16::set

    source
    fn Alpha16::set(self : Alpha16, x : Int, y : Int, c : &
    Color    ) -> Unit

    Alpha16::set_alpha16

    source
    fn Alpha16::set_alpha16(self : Alpha16, x : Int, y : Int, c : 
    Alpha16    ) -> Unit

    Alpha16::set_point

    source
    #alias("_[_]=_")
    fn Alpha16::set_point(self : Alpha16, p : Point, c : &
    Color    ) -> Unit

    Alpha16::set_rgba64

    source
    fn Alpha16::set_rgba64(self : Alpha16, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    Alpha16::sub_image

    source
    fn Alpha16::sub_image(self : Alpha16, r : Rectangle) -> &Image

    CMYK

    source
    pub(all) struct CMYK {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    CMYK is an in-memory image whose At method returns [color.CMYK] values.
    impl Image for CMYK

    CMYK::as_ycbcr

    source
    fn CMYK::as_ycbcr(_self : CMYK) -> YCbCr?

    CMYK::at

    source
    fn CMYK::at(self : CMYK, x : Int, y : Int) -> &
    Color

    CMYK::bounds

    source
    fn CMYK::bounds(self : CMYK) -> Rectangle

    CMYK::cmyk_at

    source
    fn CMYK::cmyk_at(self : CMYK, x : Int, y : Int) -> 
    CMYK

    CMYK::color_index_at

    source
    fn CMYK::color_index_at(_self : CMYK, _x : Int, _y : Int) -> Byte

    CMYK::color_model

    source
    fn CMYK::color_model(_self : CMYK) -> &
    Model

    CMYK::get

    source
    #alias("_[_]")
    fn CMYK::get(self : CMYK, p : Point) -> &
    Color

    CMYK::get_bytes_per_pixel

    source
    fn CMYK::get_bytes_per_pixel(_self : CMYK) -> Int

    CMYK::get_stride

    source
    fn CMYK::get_stride(self : CMYK) -> Int

    CMYK::new

    source
    fn CMYK::new(r : Rectangle) -> CMYK raise SizeError

    CMYK::new returns a new CMYK image with the given bounds.

    CMYK::new_empty

    source
    fn CMYK::new_empty() -> CMYK

    CMYK::opaque_

    source
    fn CMYK::opaque_(_self : CMYK) -> Bool

    CMYK::pix_offset

    source
    fn CMYK::pix_offset(self : CMYK, x : Int, y : Int) -> Int

    CMYK::raw_data

    source
    fn CMYK::raw_data(self : CMYK) -> 
    Slice    [Byte]

    CMYK::rgba64_at

    source
    fn CMYK::rgba64_at(self : CMYK, x : Int, y : Int) -> 
    RGBA64

    CMYK::set

    source
    fn CMYK::set(self : CMYK, x : Int, y : Int, c : &
    Color    ) -> Unit

    CMYK::set_cmyk

    source
    fn CMYK::set_cmyk(self : CMYK, x : Int, y : Int, c : 
    CMYK    ) -> Unit

    CMYK::set_rgba64

    source
    fn CMYK::set_rgba64(self : CMYK, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    CMYK::sub_image

    source
    fn CMYK::sub_image(self : CMYK, r : Rectangle) -> &Image

    Config

    source
    pub(all) struct Config {
      color_model : &
    Model
      width : Int
      height : Int
    }

    Config holds an image's color model and dimensions.

    Config::new_empty

    source
    fn Config::new_empty() -> Config

    Gray

    source
    pub(all) struct Gray {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    Gray is an in-memory image whose At method returns [color.Gray] values.
    impl Image for Gray

    Gray::as_ycbcr

    source
    fn Gray::as_ycbcr(_self : Gray) -> YCbCr?

    Gray::at

    source
    fn Gray::at(self : Gray, x : Int, y : Int) -> &
    Color

    Gray::bounds

    source
    fn Gray::bounds(self : Gray) -> Rectangle

    Gray::color_index_at

    source
    fn Gray::color_index_at(_self : Gray, _x : Int, _y : Int) -> Byte

    Gray::color_model

    source
    fn Gray::color_model(_self : Gray) -> &
    Model

    Gray::get

    source
    #alias("_[_]")
    fn Gray::get(self : Gray, p : Point) -> &
    Color

    Gray::get_bytes_per_pixel

    source
    fn Gray::get_bytes_per_pixel(_self : Gray) -> Int

    Gray::get_stride

    source
    fn Gray::get_stride(self : Gray) -> Int

    Gray::gray_at

    source
    fn Gray::gray_at(self : Gray, x : Int, y : Int) -> 
    Gray

    Gray::new

    source
    fn Gray::new(r : Rectangle) -> Gray raise SizeError

    Gray::new returns a new [Gray] image with the given bounds.

    Gray::new_empty

    source
    fn Gray::new_empty() -> Gray

    Gray::opaque_

    source
    fn Gray::opaque_(_self : Gray) -> Bool

    Gray::pix_offset

    source
    fn Gray::pix_offset(self : Gray, x : Int, y : Int) -> Int

    Gray::raw_data

    source
    fn Gray::raw_data(self : Gray) -> 
    Slice    [Byte]

    Gray::rgba64_at

    source
    fn Gray::rgba64_at(self : Gray, x : Int, y : Int) -> 
    RGBA64

    Gray::set

    source
    fn Gray::set(self : Gray, x : Int, y : Int, c : &
    Color    ) -> Unit

    Gray::set_gray

    source
    fn Gray::set_gray(self : Gray, x : Int, y : Int, c : 
    Gray    ) -> Unit

    Gray::set_point

    source
    #alias("_[_]=_")
    fn Gray::set_point(self : Gray, p : Point, c : &
    Color    ) -> Unit

    Gray::set_rgba64

    source
    fn Gray::set_rgba64(self : Gray, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    Gray::sub_image

    source
    fn Gray::sub_image(self : Gray, r : Rectangle) -> &Image

    Gray16

    source
    pub(all) struct Gray16 {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    Gray16 is an in-memory image whose At method returns [color.Gray16] values.
    impl Image for Gray16

    Gray16::as_ycbcr

    source
    fn Gray16::as_ycbcr(_self : Gray16) -> YCbCr?

    Gray16::at

    source
    fn Gray16::at(self : Gray16, x : Int, y : Int) -> &
    Color

    Gray16::bounds

    source
    fn Gray16::bounds(self : Gray16) -> Rectangle

    Gray16::color_index_at

    source
    fn Gray16::color_index_at(_self : Gray16, _x : Int, _y : Int) -> Byte

    Gray16::color_model

    source
    fn Gray16::color_model(_self : Gray16) -> &
    Model

    Gray16::get

    source
    #alias("_[_]")
    fn Gray16::get(self : Gray16, p : Point) -> &
    Color

    Gray16::get_bytes_per_pixel

    source
    fn Gray16::get_bytes_per_pixel(_self : Gray16) -> Int

    Gray16::get_stride

    source
    fn Gray16::get_stride(self : Gray16) -> Int

    Gray16::gray16_at

    source
    fn Gray16::gray16_at(self : Gray16, x : Int, y : Int) -> 
    Gray16

    Gray16::new

    source
    fn Gray16::new(r : Rectangle) -> Gray16 raise SizeError

    Gray16::new returns a new [Gray16] image with the given bounds.

    Gray16::new_empty

    source
    fn Gray16::new_empty() -> Gray16

    Gray16::opaque_

    source
    fn Gray16::opaque_(_self : Gray16) -> Bool

    Gray16::pix_offset

    source
    fn Gray16::pix_offset(self : Gray16, x : Int, y : Int) -> Int

    Gray16::raw_data

    source
    fn Gray16::raw_data(self : Gray16) -> 
    Slice    [Byte]

    Gray16::rgba64_at

    source
    fn Gray16::rgba64_at(self : Gray16, x : Int, y : Int) -> 
    RGBA64

    Gray16::set

    source
    fn Gray16::set(self : Gray16, x : Int, y : Int, c : &
    Color    ) -> Unit

    Gray16::set_gray16

    source
    fn Gray16::set_gray16(self : Gray16, x : Int, y : Int, c : 
    Gray16    ) -> Unit

    Gray16::set_point

    source
    #alias("_[_]=_")
    fn Gray16::set_point(self : Gray16, p : Point, c : &
    Color    ) -> Unit

    Gray16::set_rgba64

    source
    fn Gray16::set_rgba64(self : Gray16, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    Gray16::sub_image

    source
    fn Gray16::sub_image(self : Gray16, r : Rectangle) -> &Image

    NRGBA

    source
    pub(all) struct NRGBA {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    NRGBA is an in-memory image whose At method returns [color.NRGBA] values.
    impl Image for NRGBA

    NRGBA::as_ycbcr

    source
    fn NRGBA::as_ycbcr(_self : NRGBA) -> YCbCr?

    NRGBA::at

    source
    fn NRGBA::at(self : NRGBA, x : Int, y : Int) -> &
    Color

    NRGBA::bounds

    source
    fn NRGBA::bounds(self : NRGBA) -> Rectangle

    NRGBA::color_index_at

    source
    fn NRGBA::color_index_at(_self : NRGBA, _x : Int, _y : Int) -> Byte

    NRGBA::color_model

    source
    fn NRGBA::color_model(_self : NRGBA) -> &
    Model

    NRGBA::get

    source
    #alias("_[_]")
    fn NRGBA::get(self : NRGBA, p : Point) -> &
    Color

    NRGBA::get_bytes_per_pixel

    source
    fn NRGBA::get_bytes_per_pixel(_self : NRGBA) -> Int

    NRGBA::get_stride

    source
    fn NRGBA::get_stride(self : NRGBA) -> Int

    NRGBA::new

    source
    fn NRGBA::new(r : Rectangle) -> NRGBA raise SizeError

    NRGBA::new returns a new [NRGBA] image with the given bounds.

    NRGBA::new_empty

    source
    fn NRGBA::new_empty() -> NRGBA

    NRGBA::nrgba_at

    source
    fn NRGBA::nrgba_at(self : NRGBA, x : Int, y : Int) -> 
    NRGBA

    NRGBA::opaque_

    source
    fn NRGBA::opaque_(self : NRGBA) -> Bool

    NRGBA::pix_offset

    source
    fn NRGBA::pix_offset(self : NRGBA, x : Int, y : Int) -> Int

    NRGBA::raw_data

    source
    fn NRGBA::raw_data(self : NRGBA) -> 
    Slice    [Byte]

    NRGBA::rgba64_at

    source
    fn NRGBA::rgba64_at(self : NRGBA, x : Int, y : Int) -> 
    RGBA64

    NRGBA::set

    source
    fn NRGBA::set(self : NRGBA, x : Int, y : Int, c : &
    Color    ) -> Unit

    NRGBA::set_nrgba

    source
    fn NRGBA::set_nrgba(self : NRGBA, x : Int, y : Int, c : 
    NRGBA    ) -> Unit

    NRGBA::set_point

    source
    #alias("_[_]=_")
    fn NRGBA::set_point(self : NRGBA, p : Point, c : &
    Color    ) -> Unit

    NRGBA::set_rgba64

    source
    fn NRGBA::set_rgba64(self : NRGBA, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    NRGBA::sub_image

    source
    fn NRGBA::sub_image(self : NRGBA, r : Rectangle) -> &Image

    NRGBA64

    source
    pub(all) struct NRGBA64 {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    NRGBA64 is an in-memory image whose At method returns [color.NRGBA64] values.
    impl Image for NRGBA64

    NRGBA64::as_ycbcr

    source
    fn NRGBA64::as_ycbcr(_self : NRGBA64) -> YCbCr?

    NRGBA64::at

    source
    fn NRGBA64::at(self : NRGBA64, x : Int, y : Int) -> &
    Color

    NRGBA64::bounds

    source
    fn NRGBA64::bounds(self : NRGBA64) -> Rectangle

    NRGBA64::color_index_at

    source
    fn NRGBA64::color_index_at(_self : NRGBA64, _x : Int, _y : Int) -> Byte

    NRGBA64::color_model

    source
    fn NRGBA64::color_model(_self : NRGBA64) -> &
    Model

    NRGBA64::get

    source
    #alias("_[_]")
    fn NRGBA64::get(self : NRGBA64, p : Point) -> &
    Color

    NRGBA64::get_bytes_per_pixel

    source
    fn NRGBA64::get_bytes_per_pixel(_self : NRGBA64) -> Int

    NRGBA64::get_stride

    source
    fn NRGBA64::get_stride(self : NRGBA64) -> Int

    NRGBA64::new

    source
    fn NRGBA64::new(r : Rectangle) -> NRGBA64 raise SizeError

    NRGBA64::new returns a new [NRGBA64] image with the given bounds.

    NRGBA64::new_empty

    source
    fn NRGBA64::new_empty() -> NRGBA64

    NRGBA64::nrgba64_at

    source
    fn NRGBA64::nrgba64_at(self : NRGBA64, x : Int, y : Int) -> 
    NRGBA64

    NRGBA64::opaque_

    source
    fn NRGBA64::opaque_(self : NRGBA64) -> Bool

    NRGBA64::pix_offset

    source
    fn NRGBA64::pix_offset(self : NRGBA64, x : Int, y : Int) -> Int

    NRGBA64::raw_data

    source
    fn NRGBA64::raw_data(self : NRGBA64) -> 
    Slice    [Byte]

    NRGBA64::rgba64_at

    source
    fn NRGBA64::rgba64_at(self : NRGBA64, x : Int, y : Int) -> 
    RGBA64

    NRGBA64::set

    source
    fn NRGBA64::set(self : NRGBA64, x : Int, y : Int, c : &
    Color    ) -> Unit

    NRGBA64::set_nrgba64

    source
    fn NRGBA64::set_nrgba64(self : NRGBA64, x : Int, y : Int, c : 
    NRGBA64    ) -> Unit

    NRGBA64::set_point

    source
    #alias("_[_]=_")
    fn NRGBA64::set_point(self : NRGBA64, p : Point, c : &
    Color    ) -> Unit

    NRGBA64::set_rgba64

    source
    fn NRGBA64::set_rgba64(self : NRGBA64, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    NRGBA64::sub_image

    source
    fn NRGBA64::sub_image(self : NRGBA64, r : Rectangle) -> &Image

    Paletted

    source
    pub(all) struct Paletted {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
      palette : 
    Palette
    }

    Paletted is an in-memory image of Byte indices into a given palette.
    impl Image for Paletted

    Paletted::as_ycbcr

    source
    fn Paletted::as_ycbcr(_self : Paletted) -> YCbCr?

    Paletted::at

    source
    fn Paletted::at(self : Paletted, x : Int, y : Int) -> &
    Color

    Paletted::bounds

    source
    fn Paletted::bounds(self : Paletted) -> Rectangle

    Paletted::color_index_at

    source
    fn Paletted::color_index_at(self : Paletted, x : Int, y : Int) -> Byte

    Paletted::color_model

    source

    Paletted::get

    source
    #alias("_[_]")
    fn Paletted::get(self : Paletted, p : Point) -> &
    Color

    Paletted::get_bytes_per_pixel

    source
    fn Paletted::get_bytes_per_pixel(_self : Paletted) -> Int

    Paletted::get_stride

    source
    fn Paletted::get_stride(self : Paletted) -> Int

    Paletted::new

    source

    Paletted::new returns a new [Paletted] image with the given width, height and palette.

    Paletted::new_empty

    source
    fn Paletted::new_empty() -> Paletted

    Paletted::opaque_

    source
    fn Paletted::opaque_(self : Paletted) -> Bool

    Paletted::pix_offset

    source
    fn Paletted::pix_offset(self : Paletted, x : Int, y : Int) -> Int

    Paletted::raw_data

    source
    fn Paletted::raw_data(self : Paletted) -> 
    Slice    [Byte]

    Paletted::rgba64_at

    source
    fn Paletted::rgba64_at(self : Paletted, x : Int, y : Int) -> 
    RGBA64

    Paletted::set

    source
    fn Paletted::set(self : Paletted, x : Int, y : Int, c : &
    Color    ) -> Unit

    Paletted::set_color_index

    source
    fn Paletted::set_color_index(self : Paletted, x : Int, y : Int, index : Byte) -> Unit

    Paletted::set_point

    source
    #alias("_[_]=_")
    fn Paletted::set_point(self : Paletted, p : Point, c : &
    Color    ) -> Unit

    Paletted::set_rgba64

    source
    fn Paletted::set_rgba64(self : Paletted, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    Paletted::sub_image

    source
    fn Paletted::sub_image(self : Paletted, r : Rectangle) -> &Image

    Point

    source
    pub(all) struct Point {
      x : Int
      y : Int
    } derive(Eq)

    A Point is an X, Y coordinate pair. The axes increase right and down.
    impl Add for Point
    impl Show for Point
    impl Sub for Point

    Point::add

    source
    fn Point::add(self : Point, q : Point) -> Point

    Point::div

    source
    fn Point::div(self : Point, k : Int) -> Point

    div returns the vector p/k.

    Point::equal

    source
    fn Point::equal(Point, Point) -> Bool

    Point::is_in

    source
    fn Point::is_in(self : Point, r : Rectangle) -> Bool

    is_in reports whether p is in r.

    Point::mod

    source
    fn Point::mod(self : Point, 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

    source
    fn Point::mul(self : Point, k : Int) -> Point

    mul returns the vector p*k.

    Point::sub

    source
    fn Point::sub(self : Point, q : Point) -> Point

    Point::to_string

    source
    fn Point::to_string(self : Point) -> String

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

    RGBA

    source
    pub(all) struct RGBA {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    RGBA is an in-memory image whose At method returns [color.RGBA] values.
    impl Image for RGBA

    RGBA::as_ycbcr

    source
    fn RGBA::as_ycbcr(_self : RGBA) -> YCbCr?

    RGBA::at

    source
    fn RGBA::at(self : RGBA, x : Int, y : Int) -> &
    Color

    RGBA::bounds

    source
    fn RGBA::bounds(self : RGBA) -> Rectangle

    RGBA::color_index_at

    source
    fn RGBA::color_index_at(_self : RGBA, _x : Int, _y : Int) -> Byte

    RGBA::color_model

    source
    fn RGBA::color_model(_self : RGBA) -> &
    Model

    RGBA::get

    source
    #alias("_[_]")
    fn RGBA::get(self : RGBA, p : Point) -> &
    Color

    RGBA::get_bytes_per_pixel

    source
    fn RGBA::get_bytes_per_pixel(_self : RGBA) -> Int

    RGBA::get_stride

    source
    fn RGBA::get_stride(self : RGBA) -> Int

    RGBA::new

    source
    fn RGBA::new(r : Rectangle) -> RGBA raise SizeError

    RGBA::new returns a new [RGBA] image with the given bounds.

    RGBA::new_empty

    source
    fn RGBA::new_empty() -> RGBA

    RGBA::opaque_

    source
    fn RGBA::opaque_(self : RGBA) -> Bool

    RGBA::pix_offset

    source
    fn RGBA::pix_offset(self : RGBA, x : Int, y : Int) -> Int

    RGBA::raw_data

    source
    fn RGBA::raw_data(self : RGBA) -> 
    Slice    [Byte]

    RGBA::rgba64_at

    source
    fn RGBA::rgba64_at(self : RGBA, x : Int, y : Int) -> 
    RGBA64

    RGBA::rgba_at

    source
    fn RGBA::rgba_at(self : RGBA, x : Int, y : Int) -> 
    RGBA

    RGBA::set

    source
    fn RGBA::set(self : RGBA, x : Int, y : Int, c : &
    Color    ) -> Unit

    RGBA::set_point

    source
    #alias("_[_]=_")
    fn RGBA::set_point(self : RGBA, p : Point, c : &
    Color    ) -> Unit

    RGBA::set_rgba

    source
    fn RGBA::set_rgba(self : RGBA, x : Int, y : Int, c : 
    RGBA    ) -> Unit

    RGBA::set_rgba64

    source
    fn RGBA::set_rgba64(self : RGBA, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    RGBA::sub_image

    source
    fn RGBA::sub_image(self : RGBA, r : Rectangle) -> &Image

    RGBA64

    source
    pub(all) struct RGBA64 {
      pix : 
    Slice    [Byte]
      stride : Int
      rect : Rectangle
    }

    RGBA64 is an in-memory image whose At method returns [color.RGBA64] values.
    impl Image for RGBA64

    RGBA64::as_ycbcr

    source
    fn RGBA64::as_ycbcr(_self : RGBA64) -> YCbCr?

    RGBA64::at

    source
    fn RGBA64::at(self : RGBA64, x : Int, y : Int) -> &
    Color

    RGBA64::bounds

    source
    fn RGBA64::bounds(self : RGBA64) -> Rectangle

    RGBA64::color_index_at

    source
    fn RGBA64::color_index_at(_self : RGBA64, _x : Int, _y : Int) -> Byte

    RGBA64::color_model

    source
    fn RGBA64::color_model(_self : RGBA64) -> &
    Model

    RGBA64::get

    source
    #alias("_[_]")
    fn RGBA64::get(self : RGBA64, p : Point) -> &
    Color

    RGBA64::get_bytes_per_pixel

    source
    fn RGBA64::get_bytes_per_pixel(_self : RGBA64) -> Int

    RGBA64::get_stride

    source
    fn RGBA64::get_stride(self : RGBA64) -> Int

    RGBA64::new

    source
    fn RGBA64::new(r : Rectangle) -> RGBA64 raise SizeError

    RGBA64::new returns a new [RGBA64] image with the given bounds.

    RGBA64::new_empty

    source
    fn RGBA64::new_empty() -> RGBA64

    RGBA64::opaque_

    source
    fn RGBA64::opaque_(self : RGBA64) -> Bool

    RGBA64::pix_offset

    source
    fn RGBA64::pix_offset(self : RGBA64, x : Int, y : Int) -> Int

    RGBA64::raw_data

    source
    fn RGBA64::raw_data(self : RGBA64) -> 
    Slice    [Byte]

    RGBA64::rgba64_at

    source
    fn RGBA64::rgba64_at(self : RGBA64, x : Int, y : Int) -> 
    RGBA64

    RGBA64::set

    source
    fn RGBA64::set(self : RGBA64, x : Int, y : Int, c : &
    Color    ) -> Unit

    RGBA64::set_point

    source
    #alias("_[_]=_")
    fn RGBA64::set_point(self : RGBA64, p : Point, c : &
    Color    ) -> Unit

    RGBA64::set_rgba64

    source
    fn RGBA64::set_rgba64(self : RGBA64, x : Int, y : Int, c : 
    RGBA64    ) -> Unit

    RGBA64::sub_image

    source
    fn RGBA64::sub_image(self : RGBA64, r : Rectangle) -> &Image

    Rectangle

    source
    pub(all) struct Rectangle {
      min : Point
      max : Point
    }

    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.
    impl Image for Rectangle
    impl Eq for Rectangle
    impl Show for Rectangle

    Rectangle::add

    source
    fn Rectangle::add(self : Rectangle, p : Point) -> Rectangle

    add returns the rectangle r translated by p.

    Rectangle::as_ycbcr

    source
    fn Rectangle::as_ycbcr(_self : Rectangle) -> YCbCr?

    Rectangle::at

    source
    fn Rectangle::at(self : Rectangle, x : Int, y : Int) -> &
    Color

    Rectangle::bounds

    source
    fn Rectangle::bounds(self : Rectangle) -> Rectangle

    Rectangle::canon

    source
    fn Rectangle::canon(self : Rectangle) -> 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::color_index_at

    source
    fn Rectangle::color_index_at(_self : Rectangle, _x : Int, _y : Int) -> Byte

    Rectangle::color_model

    source

    Rectangle::copy

    source
    fn Rectangle::copy(self : Rectangle) -> Rectangle

    copy makes a copy of the provided rectangle without changing it.

    Rectangle::dx

    source
    fn Rectangle::dx(self : Rectangle) -> Int

    dx returns r's width.

    Rectangle::dy

    source
    fn Rectangle::dy(self : Rectangle) -> Int

    dy returns r's height.

    Rectangle::empty

    source
    fn Rectangle::empty(self : Rectangle) -> Bool

    empty reports whether the rectangle contains no points.

    Rectangle::equal

    source
    fn Rectangle::equal(self : Rectangle, s : Rectangle) -> Bool

    Rectangle::get_bytes_per_pixel

    source
    fn Rectangle::get_bytes_per_pixel(_self : Rectangle) -> Int

    Rectangle::get_stride

    source
    fn Rectangle::get_stride(_self : Rectangle) -> Int

    Rectangle::inset

    source
    fn Rectangle::inset(self : Rectangle, 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

    source
    fn Rectangle::intersect(self : Rectangle, 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::is_in

    source
    fn Rectangle::is_in(self : Rectangle, s : Rectangle) -> Bool

    is_in reports whether every point in r is in s.

    Rectangle::new

    source
    fn Rectangle::new() -> Rectangle

    Rectangle::new returns an empty (all zeros) rectangle.

    Rectangle::opaque_

    source
    fn Rectangle::opaque_(_self : Rectangle) -> Bool

    Rectangle::overlaps

    source
    fn Rectangle::overlaps(self : Rectangle, s : Rectangle) -> Bool

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

    Rectangle::pix_offset

    source
    fn Rectangle::pix_offset(_self : Rectangle, _x : Int, _y : Int) -> Int

    Rectangle::raw_data

    source
    fn Rectangle::raw_data(_self : Rectangle) -> 
    Slice    [Byte]

    Rectangle::rgba64_at

    source
    fn Rectangle::rgba64_at(self : Rectangle, x : Int, y : Int) -> 
    RGBA64

    rgba64_at implements the [RGBA64Image] trait.

    Rectangle::set

    source
    fn Rectangle::set(_self : Rectangle, _x : Int, _y : Int, _c : &
    Color    ) -> Unit

    Rectangle::size

    source
    fn Rectangle::size(self : Rectangle) -> Point

    size returns r's width and height.

    Rectangle::sub

    source
    fn Rectangle::sub(self : Rectangle, p : Point) -> Rectangle

    sub returns the rectangle r translated by -p.

    Rectangle::sub_image

    source
    fn Rectangle::sub_image(self : Rectangle, _o : Rectangle) -> &Image

    Rectangle::to_string

    source
    fn Rectangle::to_string(self : Rectangle) -> String

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

    Rectangle::union

    source
    fn Rectangle::union(self : Rectangle, s : Rectangle) -> Rectangle

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

    YCbCr

    source
    pub(all) struct YCbCr {
      y : 
    Slice    [Byte]
      cb : 
    Slice    [Byte]
      cr : 
    Slice    [Byte]
      y_stride : Int
      c_stride : Int
      subsampling : YCbCrSubsampling
      rect : Rectangle
    }

    YCbCr is an in-memory image of Y'CbCr colors.
    impl Image for YCbCr

    YCbCr::as_ycbcr

    source
    fn YCbCr::as_ycbcr(self : YCbCr) -> YCbCr?

    YCbCr::at

    source
    fn YCbCr::at(self : YCbCr, x : Int, y : Int) -> &
    Color

    YCbCr::bounds

    source
    fn YCbCr::bounds(self : YCbCr) -> Rectangle

    YCbCr::color_index_at

    source
    fn YCbCr::color_index_at(_self : YCbCr, _x : Int, _y : Int) -> Byte

    YCbCr::color_model

    source
    fn YCbCr::color_model(_self : YCbCr) -> &
    Model

    YCbCr::get_bytes_per_pixel

    source
    fn YCbCr::get_bytes_per_pixel(_self : YCbCr) -> Int

    YCbCr::get_stride

    source
    fn YCbCr::get_stride(self : YCbCr) -> Int

    YCbCr::new

    source
    fn YCbCr::new(r : Rectangle, subsampling : YCbCrSubsampling) -> YCbCr raise SizeError

    YCbCr::opaque_

    source
    fn YCbCr::opaque_(_self : YCbCr) -> Bool

    YCbCr::pix_offset

    source
    fn YCbCr::pix_offset(self : YCbCr, x : Int, y : Int) -> Int

    YCbCr::raw_data

    source
    fn YCbCr::raw_data(self : YCbCr) -> 
    Slice    [Byte]

    YCbCr::set

    source
    fn YCbCr::set(self : YCbCr, x : Int, y : Int, c : &
    Color    ) -> Unit

    YCbCr::sub_image

    source
    fn YCbCr::sub_image(self : YCbCr, r : Rectangle) -> &Image

    YCbCrSubsampling

    source
    pub(all) enum YCbCrSubsampling {
      YCbCrSubsampling444
      YCbCrSubsampling422
      YCbCrSubsampling420
      YCbCrSubsampling440
      YCbCrSubsampling411
      YCbCrSubsampling410
    } derive(Eq)

    YCbCrSubsampling represents the chroma subsampling ratio.

    YCbCrSubsampling::equal

    source

    add2_non_neg

    source
    fn add2_non_neg(x : Int, y : Int) -> Int

    add2_non_neg returns (x + y), unless at least one argument is negative or if the computation overflows the int type, in which case it returns -1.

    mul3_non_neg

    source
    fn mul3_non_neg(x : Int, y : Int, z : Int) -> Int

    mul3_non_neg returns (x * y * z), unless at least one argument is negative or if the computation overflows the int type, in which case it returns -1.
    fn pt(x : Int, y : Int) -> Point

    pt is shorthand for [Point]{X, Y}.

    rect

    source
    fn rect(x0 : Int, y0 : Int, x1 : Int, 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.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io