ChunkyPNG

https://www.rubydoc.info/gems/chunky_png/1.4.0
Admin
ChunkyPNG is a pure Ruby library for reading and writing PNG images with support for drawing,...
Tokens:112,805
Snippets:915
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Import and Export RMagick Images with ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/RMagick

Demonstrates how to include the RMagick module and use its export and import functionalities to convert between ChunkyPNG::Canvas and RMagick::Image objects. Ensure RMagick and ChunkyPNG are installed and the module is required.

```ruby
require 'rmagick'
require 'chunky_png/rmagick'

canvas = ChunkyPNG::Canvas.from_file('filename.png')
image = ChunkyPNG::RMagick.export(canvas)

# do something with the image using RMagick

updated_canvas = ChunkyPNG::RMagick.import(image)
```

--------------------------------

### Benchmark Across Multiple Ruby Interpreters

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/file/BENCHMARKING.rdoc

Use rvm to run ChunkyPNG benchmarks against different Ruby interpreters. Ensure chunky_png is installed for each interpreter before execution.

```bash
rvm 1.8.7,1.9.3,rbx bundle exec rake benchmark N=10
```

--------------------------------

### from_data_url

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/DataUrlImporting

Imports a canvas from a PNG data URL. The input string must be a valid data URL for a PNG image, starting with 'data:image/png;base64,'.

```APIDOC
## from_data_url(string)

### Description
Imports a canvas from a PNG data URL.

### Method
`from_data_url`

### Parameters
#### Path Parameters
- **string** (String) - Required - The data URL string to load from.

### Response
#### Success Response
- **Canvas** - The imported canvas.

#### Error Response
- **ChunkyPNG::SignatureMismatch** - If the provided string is not a properly formatted PNG data URL.
```

--------------------------------

### ChunkyPNG::Image#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Image%3Ainitialize

Initializes a new ChunkyPNG::Image instance with specified dimensions, background color, and metadata.

```APIDOC
## ChunkyPNG::Image#initialize

### Description
Initializes a new ChunkyPNG::Image instance.

### Method
initialize(width, height, bg_color = ChunkyPNG::Color::TRANSPARENT, metadata = {})

### Parameters
#### Parameters
- **width** (Integer) - The width of the new image.
- **height** (Integer) - The height of the new image.
- **bg_color** (Integer) - Optional - The background color of the new image. Defaults to ChunkyPNG::Color::TRANSPARENT.
- **metadata** (Hash) - Optional - A hash of metadata fields and values for this image. Defaults to {}.

### See Also
- Canvas#initialize
```

--------------------------------

### Get Y-coordinate of a Point

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Point%3Ax

Returns the y-coordinate of the point. This is a simple accessor method.

```ruby
def y
  @y
end
```

--------------------------------

### Initialize ChunkyPNG::Image

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Image%3Ainitialize

Initializes a new ChunkyPNG::Image instance with specified dimensions, background color, and optional metadata. The background defaults to transparent if not provided.

```ruby
def initialize(width, height, bg_color = ChunkyPNG::Color::TRANSPARENT, metadata = {})
  super(width, height, bg_color)
  @metadata = metadata
end
```

--------------------------------

### Get X-coordinate of a Point

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Point%3Ax

Returns the x-coordinate of the point. This is a simple accessor method.

```ruby
def x
  @x
end
```

--------------------------------

### Get Samples Per Pixel for Color Mode

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color%3Asamples_per_pixel

Use this method to determine the number of color samples (e.g., R, G, B, Alpha) for a given PNG color mode. It handles various standard color modes and raises an error for unsupported ones.

```ruby
def samples_per_pixel(color_mode)
  case color_mode
    when ChunkyPNG::COLOR_INDEXED         then 1
    when ChunkyPNG::COLOR_TRUECOLOR       then 3
    when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then 4
    when ChunkyPNG::COLOR_GRAYSCALE       then 1
    when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then 2
    else raise ChunkyPNG::NotSupported, "Don't know the number of samples for this colormode: #{color_mode}!"
  end
end
```

--------------------------------

### Get Canvas Width - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Awidth

Returns the number of columns in this canvas. This is a readonly property.

```ruby
def width
  @width
end
```

--------------------------------

### ChunkyPNG::Chunk::Base#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Base

Initializes a new chunk instance with a given type and attributes.

```APIDOC
## ChunkyPNG::Chunk::Base#initialize

### Description
Initializes the chunk instance.

### Parameters
* **type** (String) - The four character chunk type indicator.
* **attributes** (Hash) - A hash of attributes to set on this chunk.

### Constructor
```ruby
def initialize(type, attributes = {})
  self.type = type
  attributes.each { |k, v| send("#{k}=", v) }
end
```
```

--------------------------------

### ChunkyPNG::Point#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Point%3Ainitialize

Initializes a new point instance with the given x and y coordinates.

```APIDOC
## ChunkyPNG::Point#initialize

### Description
Initializes a new point instance with the given x and y coordinates.

### Method
initialize(x, y)

### Parameters
#### Path Parameters
- **x** (Integer, :to_i) - The x-coordinate.
- **y** (Integer, :to_i) - The y-coordinate.

### Request Example
```ruby
ChunkyPNG::Point.new(10, 20)
```

### Response
#### Success Response (Point)
- Returns a new Point object with the specified coordinates.

#### Response Example
```ruby
#<ChunkyPNG::Point:0x000000010d8a8b58 @x=10, @y=20>
```
```

--------------------------------

### Get Canvas Height - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Aheight

Returns the number of rows in this canvas. This is a readonly attribute.

```ruby
def height
  @height
end
```

--------------------------------

### Get ppuy Attribute Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Physical%3Appuy

Returns the value of the ppuy attribute. This is a simple getter method.

```ruby
def ppuy
  @ppuy
end
```

--------------------------------

### ChunkyPNG::Chunk::Base#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Base%3Ainitialize

Initializes a new chunk instance with a specified type and optional attributes.

```APIDOC
## ChunkyPNG::Chunk::Base#initialize

### Description
Initializes the chunk instance.

### Method
initialize(type, attributes = {})

### Parameters
#### Path Parameters
- **type** (String) - Required - The four character chunk type indicator.
- **attributes** (Hash) - Optional - A hash of attributes to set on this chunk.

### Response
- **Base** - The initialized chunk instance.
```

--------------------------------

### Get Vector Points - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Apoints

Returns the array containing all points that define this vector. This is a read-only attribute.

```ruby
def points
  @points
end
```

--------------------------------

### ChunkyPNG::Chunk::Header#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Ainitialize

Initializes a new Header chunk with optional attributes. Defaults are provided for color, compression, filtering, and interlacing.

```APIDOC
## ChunkyPNG::Chunk::Header#initialize

### Description
Initializes a new instance of Header.

### Method
initialize(attrs = {})

### Parameters
#### Path Parameters
- **attrs** (Hash) - Optional. A hash of attributes to set for the header.

### Request Example
```ruby
header = ChunkyPNG::Chunk::Header.new({
  width: 100,
  height: 50,
  depth: 8,
  color: ChunkyPNG::COLOR_TRUECOLOR,
  compression: ChunkyPNG::COMPRESSION_DEFAULT,
  filtering: ChunkyPNG::FILTERING_DEFAULT,
  interlace: ChunkyPNG::INTERLACING_NONE
})
```

### Response
#### Success Response
- **Header** - A new instance of ChunkyPNG::Chunk::Header.
```

--------------------------------

### Get Opaque Palette - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Palette%3Aopaque_palette

Use this method to create a new ChunkyPNG::Palette instance containing only the opaque versions of the colors from the original palette. This is useful when you need to ensure all colors are fully opaque.

```ruby
def opaque_palette
  self.class.new(map { |c| ChunkyPNG::Color.opaque!(c) })
end
```

--------------------------------

### encoding_palette

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/PNGEncoding%3Aencoding_palette

The palette used for encoding the image. This is only used for images that get encoded using indexed colors.

```APIDOC
## encoding_palette

### Description
The palette used for encoding the image. This is only used for images that get encoded using indexed colors.

### Method
GET

### Endpoint
/encoding_palette

### Returns
* (`ChunkyPNG::Palette`)
```

--------------------------------

### Initialize ChunkyPNG::Chunk::CompressedText

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/CompressedText%3Ainitialize

Initializes a new CompressedText chunk with a keyword and value. The chunk type is hardcoded to 'zTXt'.

```ruby
def initialize(keyword, value)
  super("zTXt")
  @keyword, @value = keyword, value
end
```

--------------------------------

### Get Other Chunks from PNG Datastream

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Aother_chunks

This method returns an array of all chunks in the PNG file that are not standard. It is defined in `lib/chunky_png/datastream.rb`.

```ruby
def other_chunks
  @other_chunks
end
```

--------------------------------

### ChunkyPNG::Palette#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Palette%3Ainitialize

Builds a new palette given a set (Enumerable instance) of colors. The decoding_map can be provided to specify the exact order of colors for decoding.

```APIDOC
## ChunkyPNG::Palette#initialize

### Description
Builds a new palette given a set (Enumerable instance) of colors.

### Method
initialize(enum, decoding_map = nil)

### Parameters
#### Path Parameters
- **enum** (Enumerable<Integer>) - Required - The set of colors to include in this palette. This Enumerable can contain duplicates.
- **decoding_map** (Array) - Optional - An array of colors in the exact order at which they appeared in the palette chunk, so that this array can be used for decoding.

### Request Example
```ruby
ChunkyPNG::Palette.new([color1, color2, color3])
ChunkyPNG::Palette.new([color1, color2, color3], [color1, color3, color2])
```

### Response
#### Success Response (Palette)
- Returns a new Palette object.

### Response Example
```ruby
#<ChunkyPNG::Palette:0x00007f8a1b9c7a00 @decoding_map=[...], @encoding_map={...}>
```
```

--------------------------------

### Get Compressed Attribute Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Acompressed

Returns the value of the `compressed` attribute for an InternationalText chunk. This is a simple getter method.

```ruby
def compressed
  @compressed
end
```

--------------------------------

### ChunkyPNG::Canvas#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Ainitialize

Initializes a new Canvas instance with given width and height. The canvas can be initialized with a background color or an array of pixel data.

```APIDOC
## ChunkyPNG::Canvas#initialize

### Description
Initializes a new Canvas instance.

### Method
`initialize(width, height, background_color)` or `initialize(width, height, initial)`

### Parameters
#### initialize(width, height, background_color)
- **width** (Integer) - Required - The width in pixels of this canvas.
- **height** (Integer) - Required - The height in pixels of this canvas.
- **background_color** (Integer, ...) - Required - The initial background color of this canvas. This can be a color value or any value that ChunkyPNG::Color#parse can handle.

#### initialize(width, height, initial)
- **width** (Integer) - Required - The width in pixels of this canvas.
- **height** (Integer) - Required - The height in pixels of this canvas.
- **initial** (Array<Integer>) - Required - The initial pixel values. Must be an array with `width * height` elements.

### Returns
- Canvas - A new Canvas instance.
```

--------------------------------

### Get Header Depth ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Adepth

Returns the value of the depth attribute. This is a simple getter method for an instance variable.

```ruby
def depth
  @depth
end
```

--------------------------------

### Get Translated Keyword Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Atranslated_keyword

Returns the value of the translated_keyword attribute. This method is part of the ChunkyPNG::Chunk::InternationalText class.

```ruby
def translated_keyword
  @translated_keyword
end
```

--------------------------------

### Initialize ChunkyPNG Generic Chunk

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Generic%3Ainitialize

Use this method to create a new instance of a Generic chunk. It requires a chunk type and optionally accepts content.

```ruby
def initialize(type, content = "")
  super(type, content: content)
end
```

--------------------------------

### Initialize ChunkyPNG Canvas

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Ainitialize

Initializes a new Canvas instance with specified width and height. It can be initialized with a background color or an array of pixel values. Raises an ArgumentError if the provided pixel array does not match the canvas dimensions.

```ruby
def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
  @width, @height = width, height

  if initial.is_a?(Array)
    pixel_count = width * height
    unless initial.length == pixel_count
      raise ArgumentError, "The initial array should have #{width}x#{height} = #{pixel_count} elements!"
    end
    @pixels = initial
  else
    @pixels = Array.new(width * height, ChunkyPNG::Color.parse(initial))
  end
end
```

--------------------------------

### Get Interlace Value - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Ainterlace

Returns the value of the interlace attribute. This method is part of the ChunkyPNG::Chunk::Header class.

```ruby
def interlace
  @interlace
end
```

--------------------------------

### ChunkyPNG::Datastream#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Ainitialize

Initializes a new Datastream instance. This method sets up internal arrays to store chunks.

```APIDOC
## ChunkyPNG::Datastream#initialize

### Description
Initializes a new Datastream instance.

### Method
initialize

### Parameters
None

### Request Example
```ruby
ChunkyPNG::Datastream.new
```

### Response
#### Success Response (Datastream)
- Initializes a new Datastream object.

#### Response Example
```ruby
#<ChunkyPNG::Datastream: @other_chunks=[], @data_chunks=[]>
```
```

--------------------------------

### Get Header Color ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Acolor

Returns the value of the color attribute for a PNG header chunk. This is used internally by ChunkyPNG.

```ruby
def color
  @color
end
```

--------------------------------

### Get Canvas Pixels - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Apixels

Returns the list of pixels in the canvas. This array will always contain `width * height` elements.

```ruby
def pixels
  @pixels
end
```

--------------------------------

### ChunkyPNG::Dimension#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Dimension%3Ainitialize

Initializes a new dimension instance with the specified width and height.

```APIDOC
## ChunkyPNG::Dimension#initialize

### Description
Initializes a new dimension instance with the specified width and height.

### Method
initialize(width, height)

### Parameters
#### Path Parameters
- **width** (Integer) - The width-component of the new dimension.
- **height** (Integer) - The height-component of the new dimension.

### Request Example
```ruby
ChunkyPNG::Dimension.new(100, 50)
```

### Response
#### Success Response
- **Dimension** - A new Dimension object with the provided width and height.
```

--------------------------------

### Get Blue Component (Ruby)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color

Extracts the blue component from a color integer. The value is shifted and masked to isolate the blue bits.

```ruby
# File 'lib/chunky_png/color.rb', line 291
def b(value)
  (value & 0x0000ff00) >> 8
end
```

--------------------------------

### Run ChunkyPNG Encoding/Decoding Benchmarks

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/file/BENCHMARKING.rdoc

Execute the encoding and decoding benchmark suites for ChunkyPNG. The number of iterations can be controlled using the 'N' environment variable.

```bash
bundle exec rake benchmark:encoding
bundle exec rake benchmark:decoding
```

```bash
bundle exec rake benchmark N=10
```

--------------------------------

### Initialize ChunkyPNG Physical Chunk

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Physical%3Ainitialize

Initializes a new Physical chunk with specified pixel dimensions per unit and a unit type. Raises an ArgumentError if the unit is not supported.

```ruby
def initialize(ppux, ppuy, unit = :unknown)
  raise ArgumentError, "unit must be either :meters or :unknown" unless [:meters, :unknown].member?(unit)
  super("pHYs")
  @ppux, @ppuy, @unit = ppux, ppuy, unit
end
```

--------------------------------

### Get Color Index in ChunkyPNG Palette

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Palette%3Aindex

Returns the 0-based position of a color in the palette. If the color is nil, it defaults to index 0.

```ruby
def index(color)
  color.nil? ? 0 : @encoding_map[color]
end
```

--------------------------------

### Get PNG Image Metadata

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Image%3Ametadata

Returns the hash of metadata fields for the PNG image. This method is part of the ChunkyPNG::Image class.

```ruby
def metadata
  @metadata
end
```

--------------------------------

### ChunkyPNG::Image#initialize_copy

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Image%3Ainitialize_copy

Initializes a new ChunkyPNG::Image instance by copying an existing one. This method ensures that the metadata from the original image is also copied to the new instance.

```APIDOC
## ChunkyPNG::Image#initialize_copy

### Description
Initializes a copy of another ChunkyPNG::Image instance.

### Parameters
- **other** (ChunkyPNG::Image) - The other image to copy.

### Method Signature
`initialize_copy(other)`

### Source Code
```ruby
def initialize_copy(other)
  super(other)
  @metadata = other.metadata
end
```
```

--------------------------------

### Calculate Dimension Area in Ruby

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Dimension%3Aarea

Use this method to get the total pixel count of an image dimension. It multiplies the width by the height.

```ruby
def area
  width * height
end
```

--------------------------------

### Initialize ChunkyPNG::Chunk::Base

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Base%3Ainitialize

Initializes a chunk instance with a type and optional attributes. Use this when creating new chunk objects.

```ruby
def initialize(type, attributes = {})
  self.type = type
  attributes.each { |k, v| send("#{k}=", v) }
end
```

--------------------------------

### compose_quick(fg, bg)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color

Composes two colors with an alpha channel using integer math. This method is faster than `compose_precise` and is the default compositing function.

```APIDOC
## compose_quick(fg, bg)

### Description
Composes two colors with an alpha channel using integer math.
This version is faster than the version based on floating point math, so this compositing function is used by default.

### Parameters
* **fg** (Integer) - The foreground color.
* **bg** (Integer) - The background color.

### Returns
* (Integer) - The composited color.

### See Also
* #compose_precise
```

--------------------------------

### Get the end chunk of a datastream

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Aend_chunk

Returns the empty chunk that signals the end of this datastream. This method is part of the ChunkyPNG::Datastream class.

```ruby
def end_chunk
  @end_chunk
end
```

--------------------------------

### Initialize ChunkyPNG Point

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Point%3Ainitialize

Initializes a new Point instance with the given x and y coordinates. Coordinates are converted to integers using `to_i`.

```ruby
def initialize(x, y)
  @x, @y = x.to_i, y.to_i
end
```

--------------------------------

### Get ppux Attribute Value - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Physical%3Appux

Returns the value of the ppux attribute. This method is part of the ChunkyPNG::Chunk::Physical class.

```ruby
def ppux
  @ppux
end
```

--------------------------------

### ChunkyPNG::Chunk::CompressedText#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/CompressedText%3Ainitialize

Initializes a new instance of the CompressedText chunk with a keyword and a value. This method is part of the ChunkyPNG library for handling PNG image data.

```APIDOC
## ChunkyPNG::Chunk::CompressedText#initialize

### Description
Returns a new instance of CompressedText.

### Method
initialize(keyword, value)

### Parameters
* **keyword** (String) - The keyword for the text chunk.
* **value** (String) - The text value associated with the keyword.

### Returns
* CompressedText - A new instance of the CompressedText chunk.
```

--------------------------------

### Get ChunkyPNG Chunk Header Compression

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Acompression

Returns the value of the compression attribute for a PNG chunk header. This is a simple getter method.

```ruby
def compression
  @compression
end
```

--------------------------------

### Convert ChunkyPNG Dimension to Array

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Dimension%3Ato_a

Use this method to get the width and height of a dimension as an array. It returns an array in the format [width, height].

```ruby
def to_a
  [width, height]
end
```

--------------------------------

### ChunkyPNG::Chunk::Text#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Text%3Ainitialize

Initializes a new Text chunk with a given keyword and value. This method is part of the ChunkyPNG library for handling PNG file structures.

```APIDOC
## ChunkyPNG::Chunk::Text#initialize

### Description
Initializes a new instance of Text.

### Method
`initialize(keyword, value)`

### Parameters
* **keyword** (String) - The keyword for the text chunk.
* **value** (String) - The value associated with the keyword.

### Returns
* `Text` - A new instance of the Text chunk.
```

--------------------------------

### Get Grayscale Transparency Entry

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Transparency

Use this method for images with ChunkyPNG::COLOR_GRAYSCALE mode to retrieve the grayscale color value that will be considered transparent.

```ruby
def grayscale_entry(bit_depth)
  value = ChunkyPNG::Canvas.send(:
```

--------------------------------

### ChunkyPNG::Vector#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Ainitialize

Initializes a vector based on a list of Point instances. It is generally recommended to use ChunkyPNG::Vector directly instead of this initializer.

```APIDOC
## ChunkyPNG::Vector#initialize

### Description
Initializes a vector based on a list of Point instances. You usually do not want to use this method directly, but call ChunkyPNG::Vector instead.

### Method Signature
`initialize(points = []) ⇒ Vector`

### Parameters
#### Path Parameters
- **points** (Array<ChunkyPNG::Point>) - Optional - Defaults to `[]`. A list of Point instances to initialize the vector with.

### See Also
- ChunkyPNG::Vector
```

--------------------------------

### Get Language Tag - ChunkyPNG::Chunk::InternationalText

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Alanguage_tag

Returns the value of the language_tag attribute. This is used to identify the language of the internationalized text chunk.

```ruby
def language_tag
  @language_tag
end
```

--------------------------------

### Convert Canvas to Grayscale (New Instance)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/Operations

Use this method to create a new canvas with grayscale colors without altering the original. It relies on the `grayscale!` method internally.

```ruby
# File 'lib/chunky_png/canvas/operations.rb', line 36

def grayscale
  dup.grayscale!
end
```

--------------------------------

### Get Canvas Dimension

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Adimension

Returns a ChunkyPNG::Dimension object representing the width and height of the canvas. This method is useful for retrieving the size of an image.

```ruby
def dimension
  ChunkyPNG::Dimension.new(width, height)
end
```

--------------------------------

### Initialize Copy of ChunkyPNG::Image

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Image%3Ainitialize_copy

Use this method to create a deep copy of a ChunkyPNG::Image object. It ensures that the metadata from the original image is preserved in the new copy.

```ruby
def initialize_copy(other)
  super(other)
  @metadata = other.metadata
end
```

--------------------------------

### Get Encoding Palette ChunkyPNG::Canvas::PNGEncoding

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/PNGEncoding%3Aencoding_palette

Returns the palette used for encoding the image. This is only used for images encoded with indexed colors.

```ruby
def encoding_palette
  @encoding_palette
end
```

--------------------------------

### Initialize ChunkyPNG::Vector

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Ainitialize

Initializes a vector with a list of Point instances. It's generally recommended to use the ChunkyPNG::Vector constructor directly instead of this method.

```ruby
def initialize(points = [])
  @points = points
end
```

--------------------------------

### Get Y-Coordinate Range of Vector Points

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Ay_range

Returns the inclusive range of y-coordinates for all points in this vector. Requires the `points` method to be defined on the vector object.

```ruby
def y_range
  Range.new(*points.map { |p| p.y }.minmax)
end
```

--------------------------------

### ChunkyPNG Color compose_quick Method

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color%3Acompose_quick

Composes two colors with an alpha channel using integer math. This version is faster than the version based on floating point math, so this compositing function is used by default. It handles edge cases where one color is fully opaque or the other is fully transparent.

```ruby
def compose_quick(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)

  a_com = int8_mult(0xff - a(fg), a(bg))
  new_r = int8_mult(a(fg), r(fg)) + int8_mult(a_com, r(bg))
  new_g = int8_mult(a(fg), g(fg)) + int8_mult(a_com, g(bg))
  new_b = int8_mult(a(fg), b(fg)) + int8_mult(a_com, b(bg))
  new_a = a(fg) + a_com
  rgba(new_r, new_g, new_b, new_a)
end
```

--------------------------------

### ChunkyPNG::Chunk::Generic#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Generic%3Ainitialize

Initializes a new instance of ChunkyPNG::Chunk::Generic. This method is used to create a new chunk with a specified type and content.

```APIDOC
## ChunkyPNG::Chunk::Generic#initialize

### Description
Returns a new instance of Generic.

### Method
initialize(type, content = "")

### Parameters
* **type** - Description not available
* **content** (String) - Optional. Defaults to "".

### Returns
* **Generic** - A new instance of ChunkyPNG::Chunk::Generic.
```

--------------------------------

### Get Vector Offset

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Aoffset

Returns the offset from (0,0) of the minimal bounding box of all the points in this vector. This is useful for determining the top-left corner for rendering or further calculations.

```ruby
def offset
  ChunkyPNG::Point.new(min_x, min_y)
end
```

--------------------------------

### Find Maximum Y-coordinate in ChunkyPNG Vector

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Amax_y

Use this method to get the highest y-coordinate among all points in a vector. It relies on the `y_range` attribute of the vector.

```ruby
def max_y
  y_range.last
end
```

--------------------------------

### Initialize ChunkyPNG::Dimension

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Dimension%3Ainitialize

Initializes a new dimension instance with the given width and height. Both parameters are converted to integers.

```ruby
def initialize(width, height)
  @width, @height = width.to_i, height.to_i
end
```

--------------------------------

### Get Transparency Chunk - ChunkyPNG Datastream

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Atransparency_chunk

Retrieves the transparency chunk associated with the palette. This method is used to access the transparency data of a PNG image.

```ruby
def transparency_chunk
  @transparency_chunk
end
```

--------------------------------

### ChunkyPNG::Chunk::Physical#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Physical%3Ainitialize

Initializes a new Physical chunk with specified pixel dimensions per unit and an optional unit type. It raises an ArgumentError if the unit is not supported.

```APIDOC
## ChunkyPNG::Chunk::Physical#initialize

### Description
Initializes a new Physical chunk with specified pixel dimensions per unit and an optional unit type. It raises an ArgumentError if the unit is not supported.

### Method
`initialize(ppux, ppuy, unit = :unknown)`

### Parameters
* **ppux** (Integer) - Pixels per unit in the x-direction.
* **ppuy** (Integer) - Pixels per unit in the y-direction.
* **unit** (Symbol) - Optional. The unit of measurement. Defaults to `:unknown`. Must be either `:meters` or `:unknown`.

### Raises
* `ArgumentError` - If the provided unit is not `:meters` or `:unknown`.

### Returns
* `Physical` - A new instance of the Physical chunk.
```

--------------------------------

### Get Datastream Chunks Enumerator

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Achunks

Returns an enumerator for iterating over the chunks of a datastream. Use this when you need to process chunks sequentially without loading them all into memory at once.

```ruby
def chunks
  enum_for(:each_chunk)
end
```

--------------------------------

### Initialize ChunkyPNG Header Chunk

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Ainitialize

Initializes a new Header chunk with default values for PNG properties. The `attrs` hash can be used to override these defaults.

```ruby
def initialize(attrs = {})
  super("IHDR", attrs)
  @depth       ||= 8
  @color       ||= ChunkyPNG::COLOR_TRUECOLOR
  @compression ||= ChunkyPNG::COMPRESSION_DEFAULT
  @filtering   ||= ChunkyPNG::FILTERING_DEFAULT
  @interlace   ||= ChunkyPNG::INTERLACING_NONE
end
```

--------------------------------

### Initialize ChunkyPNG::Datastream

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Ainitialize

Initializes a new Datastream instance. This method sets up two internal arrays, `@other_chunks` and `@data_chunks`, to store different types of PNG chunks.

```ruby
def initialize
  @other_chunks = []
  @data_chunks  = []
end
```

--------------------------------

### Get Red Component of a Color

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color%3Ar

Extracts the red component from an integer color value. The value is expected to be in a format where the red component is the most significant byte.

```ruby
def r(value)
  (value & 0xff000000) >> 24
end
```

--------------------------------

### Get Truecolor Transparency Entry

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Transparency

Use this method for truecolor images (ChunkyPNG::COLOR_TRUECOLOR mode) to retrieve the RGB color value that will be considered transparent.

```ruby
def truecolor_entry(bit_depth)
  decode_method_name = :
```

--------------------------------

### ChunkyPNG.Vector

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG.Vector

Factory method for creating ChunkyPNG::Vector instances. It supports multiple argument formats for initialization.

```APIDOC
## ChunkyPNG.Vector

### Description
Factory method for Vector instances. It supports creating vectors from coordinate pairs, a string of coordinates, or point-like objects.

### Method
`self.Vector(*args)`

### Parameters
- `args`: Variable number of arguments. Can be:
  - `x0, y0, x1, y1, x2, y2, ...`: Pairs of x and y coordinates.
  - `string`: A string containing coordinates (e.g., '1,1 2,2 3,3').
  - `pointlike, pointlike, pointlike, ...`: Arguments that can be converted to points.

### Returns
- `ChunkyPNG::Vector`: The instantiated vector.

### Raises
- `ArgumentError`: If the given arguments cannot be understood as a vector.

### Code Example
```ruby
# Example 1: Creating a vector from coordinate pairs
vector1 = ChunkyPNG::Vector.Vector(1, 1, 2, 2, 3, 3)

# Example 2: Creating a vector from a string
vector2 = ChunkyPNG::Vector.Vector('1,1 2,2 3,3')

# Example 3: Creating a vector from point-like arguments
vector3 = ChunkyPNG::Vector.Vector([1,1], [2,2], [3,3])
```
```

--------------------------------

### Create ChunkyPNG Palette from Pixels

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Palette.from_pixels

Builds a palette instance from a given set of pixels. This method is useful when you need to generate a palette based on the colors present in an image's pixel data.

```ruby
def self.from_pixels(pixels)
  new(pixels)
end
```

--------------------------------

### Get CompressedText Chunk Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/CompressedText%3Avalue

Use this method to retrieve the stored value of a CompressedText chunk. It directly accesses the instance variable holding the data.

```ruby
def value
  @value
end
```

--------------------------------

### Get Canvas Area in Pixels

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Aarea

Use the #area method to retrieve the total number of pixels in a canvas. This is calculated by the length of the internal pixels array.

```ruby
def area
  pixels.length
end
```

--------------------------------

### Initialize ChunkyPNG Palette

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Palette%3Ainitialize

Builds a new palette given a set of colors. The 'enum' parameter should be an Enumerable instance of colors, which can contain duplicates. The optional 'decoding_map' parameter is an array of colors in the exact order they appeared in the palette chunk, used for decoding.

```ruby
def initialize(enum, decoding_map = nil)
  super(enum.sort.freeze)
  @decoding_map = decoding_map if decoding_map
  @encoding_map = {}
  freeze
end
```

--------------------------------

### Initialize ChunkyPNG Text Chunk

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Text%3Ainitialize

Initializes a new Text chunk with a given keyword and value. This chunk type is used for storing arbitrary text data within a PNG file.

```ruby
def initialize(keyword, value)
  super("tEXt")
  @keyword, @value = keyword, value
end
```

--------------------------------

### Get Vector Length in ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Vector%3Alength

Use this method to determine the number of points stored within a ChunkyPNG vector object. It returns an integer representing the count.

```ruby
def length
  points.length
end
```

--------------------------------

### Get Palette Chunk from Datastream

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Apalette_chunk

Retrieves the palette chunk associated with the datastream. This method is used internally by ChunkyPNG to access the image's color palette.

```ruby
def palette_chunk
  @palette_chunk
end
```

--------------------------------

### steps

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/Resampling

Calculates the integer steps for interpolation between two values, useful for resampling.

```APIDOC
## steps(width, new_width)

### Description
Calculates the integer steps for interpolation between two values, useful for resampling.

### Parameters
* `width` (Integer) - The original width.
* `new_width` (Integer) - The target width.

### Returns
* `Array<Integer>` - An array representing the integer steps.
```

--------------------------------

### ChunkyPNG::Color#compose_quick

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color%3Acompose_quick

Composes two colors with an alpha channel using integer math. This version is faster than the version based on floating point math, so this compositing function is used by default.

```APIDOC
## ChunkyPNG::Color#compose_quick

### Description
Composes two colors with an alpha channel using integer math. This version is faster than the version based on floating point math, so this compositing function is used by default.

### Method
`compose_quick(fg, bg)`

### Parameters
#### Path Parameters
- **fg** (`Integer`) - The foreground color.
- **bg** (`Integer`) - The background color.

### Returns
- **Integer** - The composited color.

### See Also
- `#compose_precise`
```

--------------------------------

### Get Textual Metadata from PNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Datastream%3Ametadata

Retrieves all textual metadata key/value pairs from a PNG datastream. It iterates through available chunks and collects those that respond to 'keyword' and 'value'.

```ruby
def metadata
  metadata = {}
  other_chunks.each do |chunk|
    metadata[chunk.keyword] = chunk.value if chunk.respond_to?(:keyword) && chunk.respond_to?(:value)
  end
  metadata
end
```

--------------------------------

### Rotate Canvas Left (New Instance)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/Operations

Returns a new canvas rotated 90 degrees counter-clockwise. The original canvas remains unchanged. Use #rotate_left! for in-place rotation.

```ruby
# File 'lib/chunky_png/canvas/operations.rb', line 295

def rotate_left
  dup.rotate_left!
end
```

--------------------------------

### Get International Text Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Atext

Returns the value of the 'text' attribute for an InternationalText chunk. This method is part of the ChunkyPNG library for handling PNG image data.

```ruby
def text
  @text
end
```

--------------------------------

### Create ChunkyPNG Vector Instance

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG.Vector

Factory method for creating ChunkyPNG::Vector instances. It supports creating vectors from a single Vector object, a string of coordinates, or an array of points/coordinates.

```ruby
def self.Vector(*args)
  return args.first if args.length == 1 && args.first.is_a?(ChunkyPNG::Vector)

  if args.length == 1 && args.first.respond_to?(:scan)
    ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_string(args.first)) # e.g. ['1,1 2,2 3,3']
  else
    ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_array(args)) # e.g. [[1,1], [2,2], [3,3]] or [1,1,2,2,3,3]
  end
end
```

--------------------------------

### Get ChunkyPNG Header Filtering Value

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/Header%3Afiltering

Returns the value of the filtering attribute for a ChunkyPNG Header chunk. This method is part of the ChunkyPNG::Chunk::Header class.

```ruby
def filtering
  @filtering
end
```

--------------------------------

### Get Canvas Palette - ChunkyPNG

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3Apalette

Retrieves the ChunkyPNG::Palette object associated with the current canvas. This method is useful for inspecting or manipulating the colors used in an image.

```ruby
def palette
  ChunkyPNG::Palette.from_canvas(self)
end
```

--------------------------------

### Get Pixel Color Value - ChunkyPNG Canvas

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas%3A%5B%5D

Retrieves the color value of a single pixel at the specified coordinates. Raises ChunkyPNG::OutOfBounds if coordinates are invalid.

```ruby
def [](x, y)
  assert_xy!(x, y)
  @pixels[y * width + x]
end
```

--------------------------------

### ChunkyPNG::Chunk::InternationalText#initialize

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Ainitialize

Initializes a new InternationalText chunk. This chunk type is used for international text information within a PNG file.

```APIDOC
## ChunkyPNG::Chunk::InternationalText#initialize

### Description
Returns a new instance of InternationalText.

### Method
initialize(keyword, text, language_tag = "", translated_keyword = "", compressed = ChunkyPNG::UNCOMPRESSED_CONTENT, compression = ChunkyPNG::COMPRESSION_DEFAULT)

### Parameters
- **keyword** (String) - Required - The keyword for the text.
- **text** (String) - Required - The actual text content.
- **language_tag** (String) - Optional - The IETF language tag (e.g., "en-US"). Defaults to an empty string.
- **translated_keyword** (String) - Optional - The translated keyword. Defaults to an empty string.
- **compressed** (Boolean) - Optional - Indicates if the text is compressed. Defaults to ChunkyPNG::UNCOMPRESSED_CONTENT.
- **compression** (Integer) - Optional - The compression method used. Defaults to ChunkyPNG::COMPRESSION_DEFAULT.

### Returns
- InternationalText - A new instance of the InternationalText chunk.
```

--------------------------------

### ChunkyPNG::Canvas::Operations#replace!

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Canvas/Operations%3Areplace%21

Replaces pixels on the current canvas with pixels from another canvas, starting at a specified offset. This operation modifies the canvas in place.

```APIDOC
## ChunkyPNG::Canvas::Operations#replace!

### Description
Replaces pixels on this image by pixels from another pixels, on a given offset. This method will modify the current canvas. This will completely replace the pixels of the background image. If you want to blend them with semi-transparent pixels from the foreground image, see #compose!.

### Method
replace!

### Parameters
#### Path Parameters
- **other** (ChunkyPNG::Canvas) - Required - The foreground canvas to get the pixels from.
- **offset_x** (Integer) - Optional - The x-offset to apply the new foreground on. (defaults to: 0)
- **offset_y** (Integer) - Optional - The y-offset to apply the new foreground on. (defaults to: 0)

### Returns
- **ChunkyPNG::Canvas** - Returns itself, but with the other canvas placed onto it.

### Raises
- **ChunkyPNG::OutOfBounds** - when the other canvas doesn't fit on this one, given the offset and size of the other canvas.

### See Also
- #compose!
- #replace
```

--------------------------------

### Initialize ChunkyPNG::Chunk::InternationalText

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Chunk/InternationalText%3Ainitialize

Initializes a new InternationalText chunk. This method sets up the chunk with keyword, text, language tag, translated keyword, and compression details. Use this when creating or modifying iTXt chunks.

```ruby
def initialize(keyword, text, language_tag = "", translated_keyword = "", compressed = ChunkyPNG::UNCOMPRESSED_CONTENT, compression = Chunky::PNG_COMPRESSION_DEFAULT)
  super("iTXt")
  @keyword = keyword
  @text = text
  @language_tag = language_tag
  @translated_keyword = translated_keyword
  @compressed = compressed
  @compression = compression
end
```

--------------------------------

### ChunkyPNG::Color#blend

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color%3Ablend

Blends the foreground and background color by taking the average of the components.

```APIDOC
## ChunkyPNG::Color#blend

### Description
Blends the foreground and background color by taking the average of the components.

### Method
`blend(fg, bg)`

### Parameters
#### Path Parameters
- **fg** (Integer) - The foreground color.
- **bg** (Integer) - The foreground color.

### Returns
- **Integer** - The blended color.
```

--------------------------------

### Compose Colors Quickly (Ruby)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color

Composes two colors with alpha channels using integer math for speed. This is the default and generally preferred compositing method due to its performance.

```ruby
# File 'lib/chunky_png/color.rb', line 361
def compose_quick(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)

  a_com = int8_mult(0xff - a(fg), a(bg))
  new_r = int8_mult(a(fg), r(fg)) + int8_mult(a_com, r(bg))
  new_g = int8_mult(a(fg), g(fg)) + int8_mult(a_com, g(bg))
  new_b = int8_mult(a(fg), b(fg)) + int8_mult(a_com, b(bg))
  new_a = a(fg) + a_com
  rgba(new_r, new_g, new_b, new_a)
end
```

--------------------------------

### Export ChunkyPNG Canvas to RMagick::Image

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/RMagick%3Aexport

Use this method to convert a ChunkyPNG::Canvas object into a RMagick::Image instance. Ensure RMagick is installed and available.

```ruby
def export(canvas)
  image = Magick::Image.new(canvas.width, canvas.height)
  image.import_pixels(0, 0, canvas.width, canvas.height, "RGBA", canvas.pixels.pack("N*"))
  image
end
```

--------------------------------

### compose_precise(fg, bg)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color

Composes two colors with an alpha channel using floating point math for higher precision. Note that precision may be lost when converting back to an integer. This method is slower than `compose_quick`.

```APIDOC
## compose_precise(fg, bg)

### Description
Composes two colors with an alpha channel using floating point math.
This method uses more precise floating point math, but this precision is lost when the result is converted back to an integer. Because it is slower than the version based on integer math, that version is preferred.

### Parameters
* **fg** (Integer) - The foreground color.
* **bg** (Integer) - The background color.

### Returns
* (Integer) - The composited color.

### See Also
* #compose_quick
```

--------------------------------

### Get Alpha Channel Value (Ruby)

Source: https://www.rubydoc.info/gems/chunky_png/1.4.0/ChunkyPNG/Color

Extracts the alpha channel value from a given color integer. The value is masked to ensure it's within the valid range.

```ruby
# File 'lib/chunky_png/color.rb', line 299
def a(value)
  value & 0x000000ff
end
```
Tokens:
Raw