class IntelQA::Carrier::Grid(T)

• IntelQA::Carrier::Grid(T)
• Reference
• Object

Overview

A grid is 2D array of T pixels

To create a grid of size 400 x 200

grid = ImageCarrier::Grid.new(400, 200)

The default background color is transparent, but it can be passed in as a parameter or as a block that returns the color value for each {x, y} pair.

canvas2 = ImageCarrier::Grid.new(400, 200, RGBA::WHITE)

canvas3 = ImageCarrier::Grid.new(256, 256) do |x, y|
  RGBA.from_rgb_n(x, y, 255, 8)
end

Because of the way pixels are stored in a Slice, Grids are limited to Int32::MAX = 2147483647 pixels in total, e.g. a maximal size of 46340x46340 for a square image.

Defined in:

grid.cr

Constructors

• .new(width : Int32 = 0, height : Int32 = 0, cell = T::NULL)
• .new(width : Int32, height : Int32, &)

Instance Method Summary

• #==(other)

  Two canvases are considered equal if they are of equal size and all their pixels are equal

• #[](x, y)

  Short form for #get

• #[]=(x, y, cell)

  Short form for #set

• #each(type = :grid, index = Int32::MIN, &)
• #each_row(&)

  Iterate over each row of the grid (a Slice(RGBA) of size @width).

• #fill(destination : GridRegion, source : Grid(T))
• #fill(destination : GridRegion, source : NamedTuple(grid: Grid(T), region: GridRegion))
• #fill(region : GridRegion, value : T)
• #get(x, y)

  Get the value of pixel (x, y) without checking if (x, y) is a valid position.

• #height : Int32
• #includes_location?(x, y)

  Check if pixel (x, y) is part of this grid.

• #map(&)

  Same as #map!, but instead of mutating the current grid, a new one is created and returned

• #map!(&)

  Modify pixels by applying a function (color, x, y) -> new_color to each pixel of the current grid, e.g.

• #map_with_index(&)

  Same as #map but passes along a fourth parameter with the index in the #pixels slice

• #map_with_index!(&block : T, Int32, Int32, Int32 -> T)

  Same as #map! but passes along a fourth parameter with the index in the #pixels slice

• #max
• #min
• #paste(grid : Grid(T), x, y)

  Paste the contents of a second Grid into this one, starting at position (x, y).

• #pixel_type
• #pixels : Slice(T)
• #reduce(accumulator, &)
• #safe_get(x : Int32, y : Int32) : T | Nil

  Same as #get, but returns nil if (x, y) are outside of the grid

• #safe_set(x : Int32, y : Int32, cell : T) : Bool

  Same as #set, but only sets the pixel, if it is part of the grid.

• #set(x, y, cell)

  Set the value of pixel (x, y) to color without checking if (x, y) is a valid position.

• #tile(destination : GridRegion, source : NamedTuple(grid: Grid(T), region: GridRegion))
• #width : Int32
• #wrapping_get(x : Int32, y : Int32) : T

  Same as #get, but if x ore y are outside of the grid, wrap them over at the edges.

• #wrapping_set(x : Int32, y : Int32, cell : T)

  Same as #set, but wrapping along the grid edges.

Constructor Detail

Instance Method Detail