sorbet/rbi/gems/chunky_png@1.4.0.rbi
# typed: true
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `chunky_png` gem.
# Please instead update this file by running `bin/tapioca gem chunky_png`.
# ChunkyPNG - the pure ruby library to access PNG files.
#
# The ChunkyPNG module defines some constants that are used in the
# PNG specification, specifies some exception classes, and serves as
# a namespace for all the other modules and classes in this library.
#
# {ChunkyPNG::Image}:: class to represent PNG images, including metadata.
# {ChunkyPNG::Canvas}:: class to represent the image's canvas.
# {ChunkyPNG::Color}:: module to work with color values.
# {ChunkyPNG::Palette}:: represents the palette of colors used on a {ChunkyPNG::Canvas}.
# {ChunkyPNG::Datastream}:: represents the internal structure of a PNG {ChunkyPNG::Image}.
# {ChunkyPNG::Color}:: represents one chunk of data within a {ChunkyPNG::Datastream}.
# {ChunkyPNG::Point}:: geometry helper class representing a 2-dimensional point.
# {ChunkyPNG::Dimension}:: geometry helper class representing a dimension (i.e. width x height).
# {ChunkyPNG::Vector}:: geometry helper class representing a series of points.
#
# @author Willem van Bergen
#
# source://chunky_png//lib/chunky_png.rb#25
module ChunkyPNG
class << self
# Factory method to return a color value, based on the arguments given.
#
# @overload Color
# @overload Color
# @overload Color
# @overload Color
# @overload Color
# @raise [ArgumentError] if the arguments weren't understood as a color.
# @return [Integer] The determined color value as RGBA integer.
# @see ChunkyPNG::Color
# @see ChunkyPNG::Color.parse
#
# source://chunky_png//lib/chunky_png/color.rb#33
def Color(*args); end
# Creates a {ChunkyPNG::Dimension} instance using arguments that can be interpreted
# as width and height.
#
# @overload Dimension
# @overload Dimension
# @overload Dimension
# @overload Dimension
# @raise [ArgumentError] If the argument(s) given where not understood as a dimension.
# @return [ChunkyPNG::Dimension] The dimension created by this factory method.
# @see ChunkyPNG::Dimension
#
# source://chunky_png//lib/chunky_png/dimension.rb#31
def Dimension(*args); end
# Factory method to create {ChunkyPNG::Point} instances.
#
# This method tries to be as flexible as possible with regards to the given input: besides
# explicit coordinates, this method also accepts arrays, hashes, strings, {ChunkyPNG::Dimension}
# instances and anything that responds to <tt>:x</tt> and <tt>:y</tt>.
#
# @overload Point
# @overload Point
# @overload Point
# @overload Point
# @raise [ArgumentError] if the arguments weren't understood.
# @return [ChunkyPNG::Point]
# @see ChunkyPNG::Point
#
# source://chunky_png//lib/chunky_png/point.rb#32
def Point(*args); end
# Factory method for {ChunkyPNG::Vector} instances.
#
# @overload Vector
# @overload Vector
# @overload Vector
# @raise [ArgumentError] If the given arguments could not be understood as a vector.
# @return [ChunkyPNG::Vector] The vector created by this factory method.
# @see ChunkyPNG::Vector
#
# source://chunky_png//lib/chunky_png/vector.rb#20
def Vector(*args); end
private
# source://chunky_png//lib/chunky_png/dimension.rb#40
def build_dimension_from_object(source); end
# source://chunky_png//lib/chunky_png/point.rb#41
def build_point_from_object(source); end
end
end
# Indicates that the PNG image uses grayscale colors, i.e. only a
# single teint channel.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#33
ChunkyPNG::COLOR_GRAYSCALE = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG image uses grayscale colors with opacity, i.e.
# a teint channel with an alpha channel.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#48
ChunkyPNG::COLOR_GRAYSCALE_ALPHA = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG image uses indexed colors, where the values
# point to colors defined on a palette.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#43
ChunkyPNG::COLOR_INDEXED = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG image uses true color, composed of a red
# green and blue channel.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#38
ChunkyPNG::COLOR_TRUECOLOR = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG image uses true color with opacity, composed of
# a red, green and blue channel, and an alpha value.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#53
ChunkyPNG::COLOR_TRUECOLOR_ALPHA = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG chunk content is compressed
# flag used in iTXt chunk
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#68
ChunkyPNG::COMPRESSED_CONTENT = T.let(T.unsafe(nil), Integer)
# Indicates that the PNG specification's default compression
# method is used (Zlib/Deflate)
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#58
ChunkyPNG::COMPRESSION_DEFAULT = T.let(T.unsafe(nil), Integer)
# Exception that is raised if the CRC check for a block fails
#
# source://chunky_png//lib/chunky_png.rb#123
class ChunkyPNG::CRCMismatch < ::ChunkyPNG::Exception; end
# The ChunkyPNG::Canvas class represents a raster image as a matrix of
# pixels.
#
# This class supports loading a Canvas from a PNG datastream, and creating a
# {ChunkyPNG::Datastream PNG datastream} based on this matrix. ChunkyPNG
# only supports 8-bit color depth, otherwise all of the PNG format's
# variations are supported for both reading and writing.
#
# This class offers per-pixel access to the matrix by using x,y coordinates.
# It uses a palette (see {ChunkyPNG::Palette}) to keep track of the
# different colors used in this matrix.
#
# The pixels in the canvas are stored as 4-byte fixnum, representing 32-bit
# RGBA colors (8 bit per channel). The module {ChunkyPNG::Color} is provided
# to work more easily with these number as color values.
#
# The module {ChunkyPNG::Canvas::Operations} is imported for operations on
# the whole canvas, like cropping and alpha compositing. Simple drawing
# functions are imported from the {ChunkyPNG::Canvas::Drawing} module.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#4
class ChunkyPNG::Canvas
include ::ChunkyPNG::Canvas::PNGEncoding
include ::ChunkyPNG::Canvas::StreamExporting
include ::ChunkyPNG::Canvas::DataUrlExporting
include ::ChunkyPNG::Canvas::Operations
include ::ChunkyPNG::Canvas::Drawing
include ::ChunkyPNG::Canvas::Resampling
include ::ChunkyPNG::Canvas::Masking
extend ::ChunkyPNG::Canvas::PNGDecoding
extend ::ChunkyPNG::Canvas::Adam7Interlacing
extend ::ChunkyPNG::Canvas::StreamImporting
extend ::ChunkyPNG::Canvas::DataUrlImporting
# Initializes a new Canvas instance.
#
# @overload initialize
# @overload initialize
# @return [Canvas] a new instance of Canvas
#
# source://chunky_png//lib/chunky_png/canvas.rb#79
def initialize(width, height, initial = T.unsafe(nil)); end
# Equality check to compare this canvas with other matrices.
#
# @param other The object to compare this Matrix to.
# @return [true, false] True if the size and pixel values of the other
# canvas are exactly the same as this canvas's size and pixel values.
#
# source://chunky_png//lib/chunky_png/canvas.rb#277
def ==(other); end
# Returns a single pixel's color value from this canvas.
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
# image's dimensions.
# @return [Integer] The current color value at the provided coordinates.
# @see #get_pixel
#
# source://chunky_png//lib/chunky_png/canvas.rb#174
def [](x, y); end
# Replaces a single pixel in this canvas.
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @param color [Integer] The new color for the provided coordinates.
# @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
# image's dimensions.
# @return [Integer] The new color value for this pixel, i.e.
# <tt>color</tt>.
# @see #set_pixel
#
# source://chunky_png//lib/chunky_png/canvas.rb#135
def []=(x, y, color); end
# Returns the area of this canvas in number of pixels.
#
# @return [Integer] The number of pixels in this canvas
#
# source://chunky_png//lib/chunky_png/canvas.rb#122
def area; end
# Returns an extracted column as vector of pixels.
#
# @param x [Integer] The 0-based column index.
# @return [Array<Integer>] The vector of pixels in the requested column.
#
# source://chunky_png//lib/chunky_png/canvas.rb#200
def column(x); end
# Returns the dimension (width x height) for this canvas.
#
# @return [ChunkyPNG::Dimension] A dimension instance with the width and
# height set for this canvas.
#
# source://chunky_png//lib/chunky_png/canvas.rb#116
def dimension; end
# Equality check to compare this canvas with other matrices.
#
# @param other The object to compare this Matrix to.
# @return [true, false] True if the size and pixel values of the other
# canvas are exactly the same as this canvas's size and pixel values.
#
# source://chunky_png//lib/chunky_png/canvas.rb#277
def eql?(other); end
# Returns a single pixel from this canvas, without checking bounds. The
# return value for this method is undefined if the coordinates are out of
# bounds.
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @return [Integer] The current pixel at the provided coordinates.
#
# source://chunky_png//lib/chunky_png/canvas.rb#185
def get_pixel(x, y); end
# @return [Integer] The number of rows in this canvas
#
# source://chunky_png//lib/chunky_png/canvas.rb#55
def height; end
# Checks whether the given coordinates are in the range of the canvas
#
# @param point_like [ChunkyPNG::Point, Array, Hash, String] The point to
# check.
# @return [true, false] True if the x and y coordinates of the point are
# within the limits of this canvas.
# @see ChunkyPNG.Point
#
# source://chunky_png//lib/chunky_png/canvas.rb#233
def include?(*point_like); end
# Checks whether the given coordinates are in the range of the canvas
#
# @param point_like [ChunkyPNG::Point, Array, Hash, String] The point to
# check.
# @return [true, false] True if the x and y coordinates of the point are
# within the limits of this canvas.
# @see ChunkyPNG.Point
#
# source://chunky_png//lib/chunky_png/canvas.rb#233
def include_point?(*point_like); end
# Checks whether the given x-coordinate is in the range of the canvas
#
# @param x [Integer] The y-coordinate of the pixel (column)
# @return [true, false] True if the x-coordinate is in the range of this
# canvas.
#
# source://chunky_png//lib/chunky_png/canvas.rb#262
def include_x?(x); end
# Checks whether the given x- and y-coordinate are in the range of the
# canvas
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @return [true, false] True if the x- and y-coordinate is in the range of
# this canvas.
#
# source://chunky_png//lib/chunky_png/canvas.rb#246
def include_xy?(x, y); end
# Checks whether the given y-coordinate is in the range of the canvas
#
# @param y [Integer] The y-coordinate of the pixel (row)
# @return [true, false] True if the y-coordinate is in the range of this
# canvas.
#
# source://chunky_png//lib/chunky_png/canvas.rb#254
def include_y?(y); end
# Alternative implementation of the inspect method.
#
# @private
# @return [String] A nicely formatted string representation of this canvas.
#
# source://chunky_png//lib/chunky_png/canvas.rb#299
def inspect; end
# Returns the palette used for this canvas.
#
# @return [ChunkyPNG::Palette] A palette which contains all the colors that
# are being used for this image.
#
# source://chunky_png//lib/chunky_png/canvas.rb#269
def palette; end
# @return [Array<ChunkyPNG::Color>] The list of pixels in this canvas.
# This array always should have +width * height+ elements.
#
# source://chunky_png//lib/chunky_png/canvas.rb#59
def pixels; end
# Replaces a column of pixels on this canvas.
#
# @param x [Integer] The 0-based column index.
# @param vector [Array<Integer>] The vector of pixels to replace the column
# with.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas.rb#220
def replace_column!(x, vector); end
# Replaces a row of pixels on this canvas.
#
# @param y [Integer] The 0-based row index.
# @param vector [Array<Integer>] The vector of pixels to replace the row
# with.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas.rb#210
def replace_row!(y, vector); end
# Returns an extracted row as vector of pixels
#
# @param y [Integer] The 0-based row index
# @return [Array<Integer>] The vector of pixels in the requested row
#
# source://chunky_png//lib/chunky_png/canvas.rb#192
def row(y); end
# Replaces a single pixel in this canvas, without bounds checking.
#
# This method return value and effects are undefined for coordinates
# out of bounds of the canvas.
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @param color [Integer] The new color for the provided coordinates.
# @return [Integer] The new color value for this pixel, i.e.
# <tt>color</tt>.
#
# source://chunky_png//lib/chunky_png/canvas.rb#150
def set_pixel(x, y, color); end
# Replaces a single pixel in this canvas, with bounds checking. It will do
# noting if the provided coordinates are out of bounds.
#
# @param x [Integer] The x-coordinate of the pixel (column)
# @param y [Integer] The y-coordinate of the pixel (row)
# @param color [Integer] The new color value for the provided coordinates.
# @return [Integer] The new color value for this pixel, i.e.
# <tt>color</tt>, or <tt>nil</tt> if the coordinates are out of bounds.
#
# source://chunky_png//lib/chunky_png/canvas.rb#162
def set_pixel_if_within_bounds(x, y, color); end
# Creates an ChunkyPNG::Image object from this canvas.
#
# @return [ChunkyPNG::Image] This canvas wrapped in an Image instance.
#
# source://chunky_png//lib/chunky_png/canvas.rb#292
def to_image; end
# @return [Integer] The number of columns in this canvas
#
# source://chunky_png//lib/chunky_png/canvas.rb#52
def width; end
protected
# Throws an exception if the vector_length does not match this canvas'
# height.
#
# source://chunky_png//lib/chunky_png/canvas.rb#344
def assert_height!(vector_length); end
# Throws an exception if the matrix width and height does not match this canvas' dimensions.
#
# source://chunky_png//lib/chunky_png/canvas.rb#363
def assert_size!(matrix_width, matrix_height); end
# Throws an exception if the vector_length does not match this canvas'
# width.
#
# source://chunky_png//lib/chunky_png/canvas.rb#354
def assert_width!(vector_length); end
# Throws an exception if the x-coordinate is out of bounds.
#
# source://chunky_png//lib/chunky_png/canvas.rb#319
def assert_x!(x); end
# Throws an exception if the x- or y-coordinate is out of bounds.
#
# source://chunky_png//lib/chunky_png/canvas.rb#335
def assert_xy!(x, y); end
# Throws an exception if the y-coordinate is out of bounds.
#
# source://chunky_png//lib/chunky_png/canvas.rb#327
def assert_y!(y); end
# Replaces the image, given a new width, new height, and a new pixel array.
#
# source://chunky_png//lib/chunky_png/canvas.rb#310
def replace_canvas!(new_width, new_height, new_pixels); end
private
# Initializes a new Canvas instances when being cloned.
#
# @param other [ChunkyPNG::Canvas] The canvas to duplicate
# @private
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas.rb#97
def initialize_copy(other); end
class << self
# Creates a new canvas instance by duplicating another instance.
#
# @param canvas [ChunkyPNG::Canvas] The canvas to duplicate
# @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas.rb#105
def from_canvas(canvas); end
end
end
# Methods for decoding and encoding Adam7 interlacing.
#
# Adam7 interlacing extracts 7 pass images out of a single image, that can be encoded to a
# stream separately so the image can be built up progressively. The module is included into
# ChunkyPNG canvas and is used to extract the pass images from the original image, or to
# reconstruct an original image from separate pass images.
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#11
module ChunkyPNG::Canvas::Adam7Interlacing
# Extracts a pass from a complete image
#
# @param pass [Integer] The pass number, should be in 0..6.
# @param canvas [ChunkyPNG::Canvas] The image that is being deconstructed.
# @return [ChunkyPNG::Canvas] The extracted pass image.
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#63
def adam7_extract_pass(pass, canvas); end
# Merges a pass image into a total image that is being constructed.
#
# @param pass [Integer] The pass number, should be in 0..6.
# @param canvas [ChunkyPNG::Canvas] The image that is being constructed.
# @param subcanvas [ChunkyPNG::Canvas] The pass image that should be merged
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#48
def adam7_merge_pass(pass, canvas, subcanvas); end
# Returns an array with the x-shift, x-offset, y-shift and y-offset for the requested pass.
#
# @param pass [Integer] The pass number, should be in 0..6.
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#14
def adam7_multiplier_offset(pass); end
# Returns the pixel dimensions of the requested pass.
#
# @param pass [Integer] The pass number, should be in 0..6.
# @param original_width [Integer] The width of the original image.
# @param original_height [Integer] The height of the original image.
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#27
def adam7_pass_size(pass, original_width, original_height); end
# Returns an array of the dimension of all the pass images.
#
# @param original_width [Integer] The width of the original image.
# @param original_height [Integer] The height of the original image.
# @return [Array<Array<Integer>>] Returns an array with 7 pairs of dimensions.
# @see #adam7_pass_size
#
# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#40
def adam7_pass_sizes(original_width, original_height); end
end
# Methods to export a canvas to a PNG data URL.
#
# source://chunky_png//lib/chunky_png/canvas/data_url_exporting.rb#6
module ChunkyPNG::Canvas::DataUrlExporting
# Exports the canvas as a data url (e.g. data:image/png;base64,<data>) that can
# easily be used inline in CSS or HTML.
#
# @return [String] The canvas formatted as a data URL string.
#
# source://chunky_png//lib/chunky_png/canvas/data_url_exporting.rb#10
def to_data_url; end
end
# Methods to import a canvas from a PNG data URL.
#
# source://chunky_png//lib/chunky_png/canvas/data_url_importing.rb#6
module ChunkyPNG::Canvas::DataUrlImporting
# Imports a canvas from a PNG data URL.
#
# @param string [String] The data URL string to load from.
# @raise ChunkyPNG::SignatureMismatch if the provides string is not a properly
# formatted PNG data URL (i.e. it should start with "data:image/png;base64,")
# @return [Canvas] The imported canvas.
#
# source://chunky_png//lib/chunky_png/canvas/data_url_importing.rb#12
def from_data_url(string); end
end
# Module that adds some primitive drawing methods to {ChunkyPNG::Canvas}.
#
# All of these methods change the current canvas instance and do not create
# a new one, even though the method names do not end with a bang.
#
# @note Drawing operations will not fail when something is drawn outside of
# the bounds of the canvas; these pixels will simply be ignored.
# @see ChunkyPNG::Canvas
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#13
module ChunkyPNG::Canvas::Drawing
# Draws a Bezier curve
#
# @param points [Array, Point] A collection of control points
# @param stroke_color [Integer]
# @return [Chunky:PNG::Canvas] Itself, with the curve drawn
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#39
def bezier_curve(points, stroke_color = T.unsafe(nil)); end
# Draws a circle on the canvas.
#
# @param x0 [Integer] The x-coordinate of the center of the circle.
# @param y0 [Integer] The y-coordinate of the center of the circle.
# @param radius [Integer] The radius of the circle from the center point.
# @param stroke_color [Integer] The color to use for the line.
# @param fill_color [Integer] The color to use that fills the circle.
# @return [ChunkyPNG::Canvas] Itself, with the circle drawn.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#241
def circle(x0, y0, radius, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
# Composes a pixel on the canvas by alpha blending a color with its
# background color.
#
# @param x [Integer] The x-coordinate of the pixel to blend.
# @param y [Integer] The y-coordinate of the pixel to blend.
# @param color [Integer] The foreground color to blend with
# @return [Integer] The composed color.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#21
def compose_pixel(x, y, color); end
# Composes a pixel on the canvas by alpha blending a color with its
# background color, without bounds checking.
#
# @param x [Integer] The x-coordinate of the pixel to blend.
# @param y [Integer] The y-coordinate of the pixel to blend.
# @param color [Integer] The foreground color to blend with
# @return [Integer] The composed color.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#31
def compose_pixel_unsafe(x, y, color); end
# Draws an anti-aliased line using Xiaolin Wu's algorithm.
#
# @param x0 [Integer] The x-coordinate of the first control point.
# @param y0 [Integer] The y-coordinate of the first control point.
# @param x1 [Integer] The x-coordinate of the second control point.
# @param y1 [Integer] The y-coordinate of the second control point.
# @param stroke_color [Integer] The color to use for this line.
# @param inclusive [true, false] Whether to draw the last pixel. Set to
# false when drawing multiple lines in a path.
# @return [ChunkyPNG::Canvas] Itself, with the line drawn.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#94
def line(x0, y0, x1, y1, stroke_color, inclusive = T.unsafe(nil)); end
# Draws an anti-aliased line using Xiaolin Wu's algorithm.
#
# @param x0 [Integer] The x-coordinate of the first control point.
# @param y0 [Integer] The y-coordinate of the first control point.
# @param x1 [Integer] The x-coordinate of the second control point.
# @param y1 [Integer] The y-coordinate of the second control point.
# @param stroke_color [Integer] The color to use for this line.
# @param inclusive [true, false] Whether to draw the last pixel. Set to
# false when drawing multiple lines in a path.
# @return [ChunkyPNG::Canvas] Itself, with the line drawn.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#94
def line_xiaolin_wu(x0, y0, x1, y1, stroke_color, inclusive = T.unsafe(nil)); end
# Draws a polygon on the canvas using the stroke_color, filled using the
# fill_color if any.
#
# @param path [Array, String] The control point vector. Accepts everything
# {ChunkyPNG.Vector} accepts.
# @param stroke_color [Integer] The stroke color to use for this polygon.
# @param fill_color [Integer] The fill color to use for this polygon.
# @return [ChunkyPNG::Canvas] Itself, with the polygon drawn.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#166
def polygon(path, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
# Draws a rectangle on the canvas, using two control points.
#
# @param x0 [Integer] The x-coordinate of the first control point.
# @param y0 [Integer] The y-coordinate of the first control point.
# @param x1 [Integer] The x-coordinate of the second control point.
# @param y1 [Integer] The y-coordinate of the second control point.
# @param stroke_color [Integer] The line color to use for this rectangle.
# @param fill_color [Integer] The fill color to use for this rectangle.
# @return [ChunkyPNG::Canvas] Itself, with the rectangle drawn.
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#211
def rect(x0, y0, x1, y1, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
private
# Calculates the binomial coefficient for n over k.
#
# @param n [Integer] first parameter in coeffient (the number on top when
# looking at the mathematic formula)
# @param k [Integer] k-element, second parameter in coeffient (the number
# on the bottom when looking at the mathematic formula)
# @return [Integer] The binomial coeffcient of (n,k)
#
# source://chunky_png//lib/chunky_png/canvas/drawing.rb#311
def binomial_coefficient(n, k); end
end
# The ChunkyPNG::Canvas::Masking module defines methods to perform masking
# and theming operations on a {ChunkyPNG::Canvas}. The module is included into the Canvas class so all
# these methods are available on every canvas.
#
# @see ChunkyPNG::Canvas
#
# source://chunky_png//lib/chunky_png/canvas/masking.rb#10
module ChunkyPNG::Canvas::Masking
# Changes the color of a mask image.
#
# This method works on a canvas extracted out of another image using the {#extract_mask} method.
# It can then be applied on the extracted base image. See {#change_theme_color!} to perform
# these operations in one go.
#
# @param new_color [Integer] The color to replace the original mask color with.
# @raise [ChunkyPNG::ExpectationFailed] when this canvas is not a mask image, i.e. its palette
# has more than once color, disregarding transparency.
# @see #change_theme_color!
# @see #extract_mask
#
# source://chunky_png//lib/chunky_png/canvas/masking.rb#84
def change_mask_color!(new_color); end
# Creates a new image, based on the current image but with a new theme color.
#
# This method will replace one color in an image with another image. This is done by
# first extracting the pixels with a color close to the original theme color as a mask
# image, changing the color of this mask image and then apply it on the original image.
#
# Mask extraction works best when the theme colored pixels are clearly distinguishable
# from a background color (preferably white). You can set a tolerance level to influence
# the extraction process.
#
# @param old_theme_color [Integer] The original theme color in this image.
# @param new_theme_color [Integer] The color to replace the old theme color with.
# @param bg_color [Integer] The background color on which the theme colored pixels are placed.
# @param tolerance [Integer] The tolerance level to use when extracting the mask image. Five is
# the default; increase this if the masked image does not extract all the required pixels,
# decrease it if too many pixels get extracted.
# @return [ChunkyPNG::Canvas] Returns itself, but with the theme colored pixels changed.
# @see #change_theme_color!
# @see #change_mask_color!
#
# source://chunky_png//lib/chunky_png/canvas/masking.rb#30
def change_theme_color!(old_theme_color, new_theme_color, bg_color = T.unsafe(nil), tolerance = T.unsafe(nil)); end
# Creates a base image and a mask image from an original image that has a particular theme color.
# This can be used to easily change a theme color in an image.
#
# It will extract all the pixels that look like the theme color (with a tolerance level) and put
# these in a mask image. All the other pixels will be stored in a base image. Both images will be
# of the exact same size as the original image. The original image will be left untouched.
#
# The color of the mask image can be changed with {#change_mask_color!}. This new mask image can
# then be composed upon the base image to create an image with a new theme color. A call to
# {#change_theme_color!} will perform this in one go.
#
# @param mask_color [Integer] The current theme color.
# @param bg_color [Integer] The background color on which the theme colored pixels are applied.
# @param tolerance [Integer] The tolerance level to use when extracting the mask image. Five is
# the default; increase this if the masked image does not extract all the required pixels,
# decrease it if too many pixels get extracted.
# @return [Array<ChunkyPNG::Canvas, ChunkyPNG::Canvas>] An array with the base canvas and the mask
# canvas as elements.
# @see #change_theme_color!
# @see #change_mask_color!
#
# source://chunky_png//lib/chunky_png/canvas/masking.rb#56
def extract_mask(mask_color, bg_color = T.unsafe(nil), tolerance = T.unsafe(nil)); end
end
# The ChunkyPNG::Canvas::Operations module defines methods to perform
# operations on a {ChunkyPNG::Canvas}. The module is included into the
# Canvas class so all these methods are available on every canvas.
#
# Note that some of these operations modify the canvas, while some
# operations return a new canvas and leave the original intact.
#
# @see ChunkyPNG::Canvas
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#13
module ChunkyPNG::Canvas::Operations
# Draws a border around the image.
#
# @param size [Integer] The size of the border.
# @param color [Integer] The color of the border.
# @return [ChunkyPNG::Canvas] Returns a bordered version of the image.
# @see #border!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#366
def border(size, color = T.unsafe(nil)); end
# Draws a border around the image in place.
#
# @param size [Integer] The size of the border.
# @param color [Integer] The color of the border.
# @return [ChunkyPNG::Canvas] Returns itself with the border added.
# @see #border
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#376
def border!(size, color = T.unsafe(nil)); end
# Composes another image onto this image using alpha blending. This will
# return a new canvas and leave the original intact.
#
# If you simply want to replace pixels or when the other image does not
# have transparency, it is faster to use {#replace}.
#
# @note API changed since 1.0 - This method now no longer is in place,
# but returns a new canvas and leaves the original intact. Use
# {#compose!} if you want to compose on the canvas in place.
# @param other [ChunkyPNG::Canvas] The foreground canvas to compose on
# the current canvas, using alpha compositing.
# @param offset_x [Integer] The x-offset to apply the new foreground on.
# @param offset_y [Integer] The y-offset to apply the new foreground on.
# @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
# this one, given the offset and size of the other canvas.
# @return [ChunkyPNG::Canvas] Returns the new canvas, composed of the
# other 2.
# @see #replace
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#90
def compose(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
# Composes another image onto this image using alpha blending. This will
# modify the current canvas.
#
# If you simply want to replace pixels or when the other image does not
# have transparency, it is faster to use {#replace!}.
#
# @param other [ChunkyPNG::Canvas] The foreground canvas to compose on
# the current canvas, using alpha compositing.
# @param offset_x [Integer] The x-offset to apply the new foreground on.
# @param offset_y [Integer] The y-offset to apply the new foreground on.
# @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
# this one, given the offset and size of the other canvas.
# @return [ChunkyPNG::Canvas] Returns itself, but with the other canvas
# composed onto it.
# @see #replace!
# @see #compose
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#56
def compose!(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
# Crops an image, given the coordinates and size of the image that needs
# to be cut out. This will leave the original image intact and return a
# new, cropped image with pixels copied from the original image.
#
# @param x [Integer] The x-coordinate of the top left corner of the image
# to be cropped.
# @param y [Integer] The y-coordinate of the top left corner of the image
# to be cropped.
# @param crop_width [Integer] The width of the image to be cropped.
# @param crop_height [Integer] The height of the image to be cropped.
# @raise [ChunkyPNG::OutOfBounds] when the crop dimensions plus the given
# coordinates are bigger then the original image.
# @return [ChunkyPNG::Canvas] Returns the newly created cropped image.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#155
def crop(x, y, crop_width, crop_height); end
# Crops an image, given the coordinates and size of the image that needs
# to be cut out.
#
# This will change the size and content of the current canvas. Use
# {#crop} if you want to have a new canvas returned instead, leaving the
# current canvas intact.
#
# @param x [Integer] The x-coordinate of the top left corner of the image
# to be cropped.
# @param y [Integer] The y-coordinate of the top left corner of the image
# to be cropped.
# @param crop_width [Integer] The width of the image to be cropped.
# @param crop_height [Integer] The height of the image to be cropped.
# @raise [ChunkyPNG::OutOfBounds] when the crop dimensions plus the given
# coordinates are bigger then the original image.
# @return [ChunkyPNG::Canvas] Returns itself, but cropped.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#175
def crop!(x, y, crop_width, crop_height); end
# Flips the image horizontally, leaving the original intact.
#
# This will flip the image on its horizontal axis, e.g. pixels on the top
# will now be pixels on the bottom. Chaining this method twice will
# return the original canvas. This method will leave the original object
# intact and return a new canvas.
#
# @return [ChunkyPNG::Canvas] The flipped image
# @see #flip_horizontally!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#205
def flip; end
# Flips the image horizontally in place.
#
# This will flip the image on its horizontal axis, e.g. pixels on the top
# will now be pixels on the bottom. Chaining this method twice will
# return the original canvas. This method will leave the original object
# intact and return a new canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but flipped
# @see #flip_horizontally
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#218
def flip!; end
# Flips the image horizontally, leaving the original intact.
#
# This will flip the image on its horizontal axis, e.g. pixels on the top
# will now be pixels on the bottom. Chaining this method twice will
# return the original canvas. This method will leave the original object
# intact and return a new canvas.
#
# @return [ChunkyPNG::Canvas] The flipped image
# @see #flip_horizontally!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#205
def flip_horizontally; end
# Flips the image horizontally in place.
#
# This will flip the image on its horizontal axis, e.g. pixels on the top
# will now be pixels on the bottom. Chaining this method twice will
# return the original canvas. This method will leave the original object
# intact and return a new canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but flipped
# @see #flip_horizontally
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#218
def flip_horizontally!; end
# Flips the image vertically, leaving the original intact.
#
# This will flip the image on its vertical axis, e.g. pixels on the left
# will now be pixels on the right. Chaining this method twice will return
# the original canvas. This method will leave the original object intact
# and return a new canvas.
#
# @return [ChunkyPNG::Canvas] The flipped image
# @see #flip_vertically!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#240
def flip_vertically; end
# Flips the image vertically in place.
#
# This will flip the image on its vertical axis, e.g. pixels on the left
# will now be pixels on the right. Chaining this method twice will return
# the original canvas. This method will leave the original object intact
# and return a new canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but flipped
# @see #flip_vertically
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#253
def flip_vertically!; end
# Converts the canvas to grayscale, returning a new canvas.
#
# This method will not modify the canvas. To modift the current canvas,
# use {#grayscale!} instead.
#
# @return [ChunkyPNG::Canvas] A copy of the canvas, converted to
# grayscale.
# @see #grayscale!
# @see ChunkyPNG::Color#to_grayscale
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#36
def grayscale; end
# Converts the canvas to grayscale.
#
# This method will modify the canvas. The obtain a new canvas and leave
# the current instance intact, use {#grayscale} instead.
#
# @return [ChunkyPNG::Canvas] Returns itself, converted to grayscale.
# @see #grayscale
# @see ChunkyPNG::Color#to_grayscale
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#22
def grayscale!; end
# Flips the image vertically, leaving the original intact.
#
# This will flip the image on its vertical axis, e.g. pixels on the left
# will now be pixels on the right. Chaining this method twice will return
# the original canvas. This method will leave the original object intact
# and return a new canvas.
#
# @return [ChunkyPNG::Canvas] The flipped image
# @see #flip_vertically!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#240
def mirror; end
# Flips the image vertically in place.
#
# This will flip the image on its vertical axis, e.g. pixels on the left
# will now be pixels on the right. Chaining this method twice will return
# the original canvas. This method will leave the original object intact
# and return a new canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but flipped
# @see #flip_vertically
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#253
def mirror!; end
# 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!}.
#
# @note API changed since 1.0 - This method now no longer is in place,
# but returns a new canvas and leaves the original intact. Use
# {#replace!} if you want to replace pixels on the canvas in place.
# @param other [ChunkyPNG::Canvas] The foreground canvas to get the
# pixels from.
# @param offset_x [Integer] The x-offset to apply the new foreground on.
# @param offset_y [Integer] The y-offset to apply the new foreground on.
# @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
# this one, given the offset and size of the other canvas.
# @return [ChunkyPNG::Canvas] Returns a new, combined canvas.
# @see #compose
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#138
def replace(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
# 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!}.
#
# @param other [ChunkyPNG::Canvas] The foreground canvas to get the
# pixels from.
# @param offset_x [Integer] The x-offset to apply the new foreground on.
# @param offset_y [Integer] The y-offset to apply the new foreground on.
# @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
# this one, given the offset and size of the other canvas.
# @return [ChunkyPNG::Canvas] Returns itself, but with the other canvas
# placed onto it.
# @see #compose!
# @see #replace
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#111
def replace!(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
# Rotates the image 180 degrees.
#
# This method will leave the original object intact and return a new
# canvas.
#
# @return [ChunkyPNG::Canvas] The rotated image.
# @see #rotate_180!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#322
def rotate_180; end
# Rotates the image 180 degrees in place.
#
# @return [ChunkyPNG::Canvas] Itself, but rotated 180 degrees.
# @see #rotate_180
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#330
def rotate_180!; end
# Returns a new canvas instance that is rotated 90 degrees clockwise.
#
# This method will return a new canvas and leaves the original intact.
#
# @return [ChunkyPNG::Canvas] A clockwise-rotated copy.
# @see #rotate_right! for the in place version.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#269
def rotate_clockwise; end
# Rotates the image 90 degrees clockwise in place.
#
# This method will change the current canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but rotated clockwise.
# @see #rotate_right for a version that leaves the current canvas intact
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#279
def rotate_clockwise!; end
# Returns an image that is rotated 90 degrees counter-clockwise.
#
# This method will leave the original object intact and return a new
# canvas.
#
# @return [ChunkyPNG::Canvas] A rotated copy of itself.
# @see #rotate_left! for the in-place version.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#295
def rotate_counter_clockwise; end
# Rotates the image 90 degrees counter-clockwise in place.
#
# This method will change the original canvas. See {#rotate_left} for a
# version that leaves the canvas intact and returns a new rotated canvas
# instead.
#
# @return [ChunkyPNG::Canvas] Itself, but rotated.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#306
def rotate_counter_clockwise!; end
# Returns an image that is rotated 90 degrees counter-clockwise.
#
# This method will leave the original object intact and return a new
# canvas.
#
# @return [ChunkyPNG::Canvas] A rotated copy of itself.
# @see #rotate_left! for the in-place version.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#295
def rotate_left; end
# Rotates the image 90 degrees counter-clockwise in place.
#
# This method will change the original canvas. See {#rotate_left} for a
# version that leaves the canvas intact and returns a new rotated canvas
# instead.
#
# @return [ChunkyPNG::Canvas] Itself, but rotated.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#306
def rotate_left!; end
# Returns a new canvas instance that is rotated 90 degrees clockwise.
#
# This method will return a new canvas and leaves the original intact.
#
# @return [ChunkyPNG::Canvas] A clockwise-rotated copy.
# @see #rotate_right! for the in place version.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#269
def rotate_right; end
# Rotates the image 90 degrees clockwise in place.
#
# This method will change the current canvas.
#
# @return [ChunkyPNG::Canvas] Itself, but rotated clockwise.
# @see #rotate_right for a version that leaves the current canvas intact
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#279
def rotate_right!; end
# Trims the border around the image, presumed to be the color of the
# first pixel.
#
# @param border [Integer] The color to attempt to trim.
# @return [ChunkyPNG::Canvas] The trimmed image.
# @see #trim!
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#341
def trim(border = T.unsafe(nil)); end
# Trims the border around the image in place.
#
# @param border [Integer] The color to attempt to trim.
# @return [ChunkyPNG::Canvas] Returns itself, but with the border
# trimmed.
# @see #trim
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#351
def trim!(border = T.unsafe(nil)); end
protected
# Checks whether another image has the correct dimension to be used for
# an operation on the current image, given an offset coordinate to work
# with.
#
# @param other [ChunkyPNG::Canvas] The other canvas
# @param offset_x [Integer] The x offset on which the other image will be
# applied.
# @param offset_y [Integer] The y offset on which the other image will be
# applied.
# @raise [ChunkyPNG::OutOfBounds] when the other image doesn't fit.
#
# source://chunky_png//lib/chunky_png/canvas/operations.rb#395
def check_size_constraints!(other, offset_x, offset_y); end
end
# The PNGDecoding contains methods for decoding PNG datastreams to create a
# Canvas object. The datastream can be provided as filename, string or IO
# stream.
#
# Overview of the decoding process:
#
# * The optional PLTE and tRNS chunk are decoded for the color palette of
# the original image.
# * The contents of the IDAT chunks is combined, and uncompressed using
# Inflate decompression to the image pixelstream.
# * Based on the color mode, width and height of the original image, which
# is read from the PNG header (IHDR chunk), the amount of bytes
# per line is determined.
# * For every line of pixels in the encoded image, the original byte values
# are restored by unapplying the milter method for that line.
# * The read bytes are unfiltered given by the filter function specified by
# the first byte of the line.
# * The unfiltered pixelstream are is into colored pixels, using the color mode.
# * All lines combined to form the original image.
#
# For interlaced images, the original image was split into 7 subimages.
# These images get decoded just like the process above (from step 3), and get
# combined to form the original images.
#
# @see ChunkyPNG::Canvas::PNGEncoding
# @see https://www.w3.org/TR/PNG/ The W3C PNG format specification
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#31
module ChunkyPNG::Canvas::PNGDecoding
# Decodes a canvas from a PNG encoded pixelstream, using a given width, height,
# color mode and interlacing mode.
#
# @param stream [String] The pixelstream to read from.
# @param width [Integer] The width of the image.
# @param height [Integer] The height of the image.
# @param color_mode [Integer] The color mode of the encoded pixelstream.
# @param depth [Integer] The bit depth of the pixel samples.
# @param interlace [Integer] The interlace method of the encoded pixelstream.
# @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
# @param transparent_color [Integer] The color that should be considered fully transparent.
# @raise [ChunkyPNG::ExpectationFailed]
# @return [ChunkyPNG::Canvas] The decoded Canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#95
def decode_png_pixelstream(stream, width, height, color_mode, depth, interlace, decoding_palette, transparent_color); end
# Decodes a Canvas from a PNG encoded string.
#
# @param str [String] The string to read from.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#35
def from_blob(str); end
# Decodes the Canvas from a PNG datastream instance.
#
# @param ds [ChunkyPNG::Datastream] The datastream to decode.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG datastream.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#60
def from_datastream(ds); end
# Decodes a Canvas from a PNG encoded file.
#
# @param filename [String] The file to read from.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG file.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#44
def from_file(filename); end
# Decodes a Canvas from a PNG encoded stream.
#
# @param io [IO, #read] The stream to read from.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG stream.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#51
def from_io(io); end
# Decodes a Canvas from a PNG encoded stream.
#
# @param io [IO, #read] The stream to read from.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG stream.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#51
def from_stream(io); end
# Decodes a Canvas from a PNG encoded string.
#
# @param str [String] The string to read from.
# @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#35
def from_string(str); end
protected
# Extract a bit from a byte on a given index.
#
# @param byte [Integer] The byte (0..255) value to extract a bit from.
# @param index [Integer] The index within the byte. This should be 0..7;
# the value will be modded by 8 to enforce this.
# @return [Integer] Either 1 or 0.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#168
def decode_png_extract_1bit_value(byte, index); end
# Extract 2 consecutive bits from a byte.
#
# @param byte [Integer] The byte (0..255) value to extract a 2 bit value from.
# @param index [Integer] The index within the byte. This should be either 0, 1, 2, or 3;
# the value will be modded by 4 to enforce this.
# @return [Integer] The extracted 2 bit value (0..3)
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#158
def decode_png_extract_2bit_value(byte, index); end
# Extract 4 consecutive bits from a byte.
#
# @param byte [Integer] The byte (0..255) value to extract a 4 bit value from.
# @param index [Integer] The index within the byte. This should be either 0 or 2;
# the value will be modded by 2 to enforce this.
# @return [Integer] The extracted 4bit value (0..15)
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#149
def decode_png_extract_4bit_value(byte, index); end
# Decodes a single PNG image pass width a given width, height and color
# mode, to a Canvas, starting at the given position in the stream.
#
# A non-interlaced image only consists of one pass, while an Adam7
# image consists of 7 passes that must be combined after decoding.
#
# @param start_pos [Integer] The position in the pixel stream to start reading.
# @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
# @param stream [String] The pixelstream to read from.
# @param width [Integer] The width of the image.
# @param height [Integer] The height of the image.
# @param color_mode [Integer] The color mode of the encoded pixelstream.
# @return [ChunkyPNG::Canvas] The decoded Canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#383
def decode_png_image_pass(stream, width, height, color_mode, depth, start_pos, decoding_palette); end
# Decodes a scanline of a 16-bit, grayscale image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#347
def decode_png_pixels_from_scanline_grayscale_16bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 1-bit, grayscale image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#310
def decode_png_pixels_from_scanline_grayscale_1bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 2-bit, grayscale image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#320
def decode_png_pixels_from_scanline_grayscale_2bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 4-bit, grayscale image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#330
def decode_png_pixels_from_scanline_grayscale_4bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of an 8-bit, grayscale image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#340
def decode_png_pixels_from_scanline_grayscale_8bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 16-bit, grayscale image with transparency into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#299
def decode_png_pixels_from_scanline_grayscale_alpha_16bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of an 8-bit, grayscale image with transparency into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#292
def decode_png_pixels_from_scanline_grayscale_alpha_8bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 1-bit, indexed image into a row of pixels.
#
# @param stream [String] The stream to decode from.
# @param pos [Integer] The position in the stream on which the scanline starts (including the filter byte).
# @param width [Integer] The width in pixels of the scanline.
# @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#214
def decode_png_pixels_from_scanline_indexed_1bit(stream, pos, width, decoding_palette); end
# Decodes a scanline of a 2-bit, indexed image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#224
def decode_png_pixels_from_scanline_indexed_2bit(stream, pos, width, decoding_palette); end
# Decodes a scanline of a 4-bit, indexed image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#234
def decode_png_pixels_from_scanline_indexed_4bit(stream, pos, width, decoding_palette); end
# Decodes a scanline of a 8-bit, indexed image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#244
def decode_png_pixels_from_scanline_indexed_8bit(stream, pos, width, decoding_palette); end
# Returns the method name to use to decode scanlines into pixels.
#
# @param color_mode [Integer] The color mode of the image.
# @param depth [Integer] The bit depth of the image.
# @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
# @return [Symbol] The method name to use for decoding, to be called on the canvas class.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#357
def decode_png_pixels_from_scanline_method(color_mode, depth); end
# Decodes a scanline of a 16-bit, true color image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#281
def decode_png_pixels_from_scanline_truecolor_16bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of an 8-bit, true color image into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#274
def decode_png_pixels_from_scanline_truecolor_8bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of a 16-bit, true color image with transparency into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#258
def decode_png_pixels_from_scanline_truecolor_alpha_16bit(stream, pos, width, _decoding_palette); end
# Decodes a scanline of an 8-bit, true color image with transparency into a row of pixels.
#
# @return [Array<Integer>] An array of decoded pixels.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#251
def decode_png_pixels_from_scanline_truecolor_alpha_8bit(stream, pos, width, _decoding_palette); end
# Resamples a 16 bit value to an 8 bit value. This will discard some color information.
#
# @param value [Integer] The 16 bit value to resample.
# @return [Integer] The 8 bit resampled value
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#176
def decode_png_resample_16bit_value(value); end
# Resamples a 1 bit value to an 8 bit value.
#
# @param value [Integer] The 1 bit value to resample.
# @return [Integer] The 8 bit resampled value
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#204
def decode_png_resample_1bit_value(value); end
# Resamples a 2 bit value to an 8 bit value.
#
# @param value [Integer] The 2 bit value to resample.
# @return [Integer] The 8 bit resampled value.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#197
def decode_png_resample_2bit_value(value); end
# Resamples a 4 bit value to an 8 bit value.
#
# @param value [Integer] The 4 bit value to resample.
# @return [Integer] The 8 bit resampled value.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#190
def decode_png_resample_4bit_value(value); end
# No-op - available for completeness sake only
#
# @param value [Integer] The 8 bit value to resample.
# @return [Integer] The 8 bit resampled value
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#183
def decode_png_resample_8bit_value(value); end
# Decodes a scanline if it was encoded using filtering.
#
# It will extract the filtering method from the first byte of the scanline, and uses the
# method to change the subsequent bytes to unfiltered values. This will modify the pixelstream.
#
# The bytes of the scanline can then be used to construct pixels, based on the color mode..
#
# @param stream [String] The pixelstream to undo the filtering in.
# @param pos [Integer] The starting position of the scanline to decode.
# @param prev_pos [Integer, nil] The starting position of the previously decoded scanline, or <tt>nil</tt>
# if this is the first scanline of the image.
# @param line_length [Integer] The number of bytes in the scanline, discounting the filter method byte.
# @param pixel_size [Integer] The number of bytes used per pixel, based on the color mode.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#421
def decode_png_str_scanline(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a scanline in a pixelstream that was encoded using AVERAGE filtering.
# This will change the pixelstream to have unfiltered values.
#
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#464
def decode_png_str_scanline_average(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a scanline in a pixelstream that was encoded using PAETH filtering.
# This will change the pixelstream to have unfiltered values.
#
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#476
def decode_png_str_scanline_paeth(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a scanline in a pixelstream that was encoded using SUB filtering.
# This will change the pixelstream to have unfiltered values.
#
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#443
def decode_png_str_scanline_sub(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a scanline that wasn't encoded using filtering. This is a no-op.
#
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#435
def decode_png_str_scanline_sub_none(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a scanline in a pixelstream that was encoded using UP filtering.
# This will change the pixelstream to have unfiltered values.
#
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#453
def decode_png_str_scanline_up(stream, pos, prev_pos, line_length, pixel_size); end
# Decodes a canvas from a Adam 7 interlaced PNG encoded pixelstream, using a
# given width, height and color mode.
#
# @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
# @param stream [String] The pixelstream to read from.
# @param width [Integer] The width of the image.
# @param height [Integer] The height of the image.
# @param color_mode [Integer] The color mode of the encoded pixelstream.
# @param depth [Integer] The bit depth of the pixel samples.
# @return [ChunkyPNG::Canvas] The decoded Canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#132
def decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette); end
# Decodes a canvas from a non-interlaced PNG encoded pixelstream, using a
# given width, height and color mode.
#
# @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
# @param stream [String] The pixelstream to read from.
# @param width [Integer] The width of the image.
# @param height [Integer] The height of the image.
# @param color_mode [Integer] The color mode of the encoded pixelstream.
# @param depth [Integer] The bit depth of the pixel samples.
# @return [ChunkyPNG::Canvas] The decoded Canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#119
def decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette); end
end
# Methods for encoding a Canvas instance into a PNG datastream.
#
# Overview of the encoding process:
#
# * The image is split up in scanlines (i.e. rows of pixels);
# * All pixels are encoded as a pixelstream, based on the color mode.
# * All the pixel bytes in the pixelstream are adjusted using a filtering
# method if one is specified.
# * Compress the resulting string using deflate compression.
# * Split compressed data over one or more PNG chunks.
# * These chunks should be embedded in a datastream with at least a IHDR and
# IEND chunk and possibly a PLTE chunk.
#
# For interlaced images, the initial image is first split into 7 subimages.
# These images get encoded exactly as above, and the result gets combined
# before the compression step.
#
# @see ChunkyPNG::Canvas::PNGDecoding
# @see https://www.w3.org/TR/PNG/ The W3C PNG format specification
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#24
module ChunkyPNG::Canvas::PNGEncoding
# The palette used for encoding the image.This is only in used for images
# that get encoded using indexed colors.
#
# @return [ChunkyPNG::Palette]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#28
def encoding_palette; end
# The palette used for encoding the image.This is only in used for images
# that get encoded using indexed colors.
#
# @return [ChunkyPNG::Palette]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#28
def encoding_palette=(_arg0); end
# Writes the canvas to a file, encoded as a PNG image.
#
# @param filename [String] The file to save the PNG image to.
# @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
# This can either be a hash with different constraints, or a symbol which acts as a
# preset for some constraints. If no constraints are given, ChunkyPNG will decide
# for itself how to best create the PNG datastream.
# Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
# <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
# obtain the smallest possible filesize.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#42
def save(filename, constraints = T.unsafe(nil)); end
# Encoded the canvas to a PNG formatted string.
#
# @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
# This can either be a hash with different constraints, or a symbol which acts as a
# preset for some constraints. If no constraints are given, ChunkyPNG will decide
# for itself how to best create the PNG datastream.
# Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
# <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
# obtain the smallest possible filesize.
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
def to_blob(constraints = T.unsafe(nil)); end
# Converts this Canvas to a datastream, so that it can be saved as a PNG image.
#
# @option constraints
# @option constraints
# @option constraints
# @option constraints
# @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
# This can either be a hash with different constraints, or a symbol which acts as a
# preset for some constraints. If no constraints are given, ChunkyPNG will decide
# for itself how to best create the PNG datastream.
# Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
# <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
# obtain the smallest possible filesize.
# @return [ChunkyPNG::Datastream] The PNG datastream containing the encoded canvas.
# @see ChunkyPNG::Canvas::PNGEncoding#determine_png_encoding
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#74
def to_datastream(constraints = T.unsafe(nil)); end
# Encoded the canvas to a PNG formatted string.
#
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
def to_s(constraints = T.unsafe(nil)); end
# Encoded the canvas to a PNG formatted string.
#
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
def to_string(constraints = T.unsafe(nil)); end
# Writes the canvas to an IO stream, encoded as a PNG image.
#
# @param io [IO] The output stream to write to.
# @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
# This can either be a hash with different constraints, or a symbol which acts as a
# preset for some constraints. If no constraints are given, ChunkyPNG will decide
# for itself how to best create the PNG datastream.
# Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
# <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
# obtain the smallest possible filesize.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#34
def write(io, constraints = T.unsafe(nil)); end
protected
# Determines the best possible PNG encoding variables for this image, by analyzing
# the colors used for the image.
#
# You can provide constraints for the encoding variables by passing a hash with
# encoding variables to this method.
#
# @param constraints [Hash, Symbol] The constraints for the encoding. This can be a
# Hash or a preset symbol.
# @return [Hash] A hash with encoding options for {ChunkyPNG::Canvas::PNGEncoding#to_datastream}
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#107
def determine_png_encoding(constraints = T.unsafe(nil)); end
# Encodes the canvas to a stream, in a given color mode.
#
# @param stream [String] The stream to write to.
# @param color_mode [Integer] The color mode to use for encoding.
# @param bit_depth [Integer] The bit depth of the image.
# @param filtering [Integer] The filtering method to use.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#206
def encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering); end
# Encodes the canvas according to the PNG format specification with a given color
# mode and Adam7 interlacing.
#
# This method will split the original canvas in 7 smaller canvases and encode them
# one by one, concatenating the resulting strings.
#
# @param color_mode [Integer] The color mode to use for encoding.
# @param bit_depth [Integer] The bit depth of the image.
# @param filtering [Integer] The filtering method to use.
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#191
def encode_png_image_with_interlacing(color_mode, bit_depth = T.unsafe(nil), filtering = T.unsafe(nil)); end
# Encodes the canvas according to the PNG format specification with a given color mode.
#
# @param color_mode [Integer] The color mode to use for encoding.
# @param bit_depth [Integer] The bit depth of the image.
# @param filtering [Integer] The filtering method to use.
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#175
def encode_png_image_without_interlacing(color_mode, bit_depth = T.unsafe(nil), filtering = T.unsafe(nil)); end
# Encodes a line of pixels using 1-bit grayscale mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#307
def encode_png_pixels_to_scanline_grayscale_1bit(pixels); end
# Encodes a line of pixels using 2-bit grayscale mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#325
def encode_png_pixels_to_scanline_grayscale_2bit(pixels); end
# Encodes a line of pixels using 2-bit grayscale mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#339
def encode_png_pixels_to_scanline_grayscale_4bit(pixels); end
# Encodes a line of pixels using 8-bit grayscale mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#350
def encode_png_pixels_to_scanline_grayscale_8bit(pixels); end
# Encodes a line of pixels using 8-bit grayscale alpha mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#357
def encode_png_pixels_to_scanline_grayscale_alpha_8bit(pixels); end
# Encodes a line of pixels using 1-bit indexed mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#253
def encode_png_pixels_to_scanline_indexed_1bit(pixels); end
# Encodes a line of pixels using 2-bit indexed mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#273
def encode_png_pixels_to_scanline_indexed_2bit(pixels); end
# Encodes a line of pixels using 4-bit indexed mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#289
def encode_png_pixels_to_scanline_indexed_4bit(pixels); end
# Encodes a line of pixels using 8-bit indexed mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#300
def encode_png_pixels_to_scanline_indexed_8bit(pixels); end
# Returns the method name to use to decode scanlines into pixels.
#
# @param color_mode [Integer] The color mode of the image.
# @param depth [Integer] The bit depth of the image.
# @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
# @return [Symbol] The method name to use for decoding, to be called on the canvas class.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#366
def encode_png_pixels_to_scanline_method(color_mode, depth); end
# Encodes a line of pixels using 8-bit truecolor mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#239
def encode_png_pixels_to_scanline_truecolor_8bit(pixels); end
# Encodes a line of pixels using 8-bit truecolor alpha mode.
#
# @param pixels [Array<Integer>] A row of pixels of the original image.
# @return [String] The encoded scanline as binary string
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#246
def encode_png_pixels_to_scanline_truecolor_alpha_8bit(pixels); end
# Encodes the canvas according to the PNG format specification with a given color
# mode, possibly with interlacing.
#
# @param color_mode [Integer] The color mode to use for encoding.
# @param bit_depth [Integer] The bit depth of the image.
# @param interlace [Integer] The interlacing method to use.
# @return [String] The PNG encoded canvas as string.
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#157
def encode_png_pixelstream(color_mode = T.unsafe(nil), bit_depth = T.unsafe(nil), interlace = T.unsafe(nil), filtering = T.unsafe(nil)); end
# Encodes a scanline of a pixelstream using AVERAGE filtering. This will modify the stream.
#
# @param stream [String] The pixelstream to work on. This string will be modified.
# @param pos [Integer] The starting position of the scanline.
# @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
# this is the first line.
# @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
# method byte.
# @param pixel_size [Integer] The number of bytes used per pixel.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#417
def encode_png_str_scanline_average(stream, pos, prev_pos, line_width, pixel_size); end
# Encodes a scanline of a pixelstream without filtering. This is a no-op.
#
# @param stream [String] The pixelstream to work on. This string will be modified.
# @param pos [Integer] The starting position of the scanline.
# @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
# this is the first line.
# @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
# method byte.
# @param pixel_size [Integer] The number of bytes used per pixel.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#388
def encode_png_str_scanline_none(stream, pos, prev_pos, line_width, pixel_size); end
# Encodes a scanline of a pixelstream using PAETH filtering. This will modify the stream.
#
# @param stream [String] The pixelstream to work on. This string will be modified.
# @param pos [Integer] The starting position of the scanline.
# @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
# this is the first line.
# @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
# method byte.
# @param pixel_size [Integer] The number of bytes used per pixel.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#429
def encode_png_str_scanline_paeth(stream, pos, prev_pos, line_width, pixel_size); end
# Encodes a scanline of a pixelstream using SUB filtering. This will modify the stream.
#
# @param stream [String] The pixelstream to work on. This string will be modified.
# @param pos [Integer] The starting position of the scanline.
# @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
# this is the first line.
# @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
# method byte.
# @param pixel_size [Integer] The number of bytes used per pixel.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#395
def encode_png_str_scanline_sub(stream, pos, prev_pos, line_width, pixel_size); end
# Encodes a scanline of a pixelstream using UP filtering. This will modify the stream.
#
# @param stream [String] The pixelstream to work on. This string will be modified.
# @param pos [Integer] The starting position of the scanline.
# @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
# this is the first line.
# @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
# method byte.
# @param pixel_size [Integer] The number of bytes used per pixel.
# @return [void]
#
# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#406
def encode_png_str_scanline_up(stream, pos, prev_pos, line_width, pixel_size); end
end
# The ChunkyPNG::Canvas::Resampling module defines methods to perform image resampling to
# a {ChunkyPNG::Canvas}.
#
# Currently, only the nearest neighbor algorithm is implemented. Bilinear and cubic
# algorithms may be added later on.
#
# @see ChunkyPNG::Canvas
#
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#12
module ChunkyPNG::Canvas::Resampling
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
def resample(new_width, new_height); end
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#134
def resample_bilinear(new_width, new_height); end
# Resamples the canvas with bilinear interpolation.
#
# @param new_width [Integer] The width of the resampled canvas.
# @param new_height [Integer] The height of the resampled canvas.
# @return [ChunkyPNG::Canvas] A new canvas instance with the resampled pixels.
#
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#98
def resample_bilinear!(new_width, new_height); end
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
def resample_nearest_neighbor(new_width, new_height); end
# Resamples the canvas using nearest neighbor interpolation.
#
# @param new_width [Integer] The width of the resampled canvas.
# @param new_height [Integer] The height of the resampled canvas.
# @return [ChunkyPNG::Canvas] A new canvas instance with the resampled pixels.
#
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#74
def resample_nearest_neighbor!(new_width, new_height); end
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
def resize(new_width, new_height); end
# Integer Interpolation between two values
#
# Used for generating indicies for interpolation (eg, nearest
# neighbour).
#
# @param width [Integer] The width of the source
# @param new_width [Integer] The width of the destination
# @return [Array<Integer>] An Array of Integer indicies
#
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#21
def steps(width, new_width); end
# Fractional Interpolation between two values
#
# Used for generating values for interpolation (eg, bilinear).
# Produces both the indices and the interpolation factors (residues).
#
# @param width [Integer] The width of the source
# @param new_width [Integer] The width of the destination
# @return [Array<Integer>, Array<Integer>] Two arrays of indicies and residues
#
# source://chunky_png//lib/chunky_png/canvas/resampling.rb#38
def steps_residues(width, new_width); end
end
# Methods to save load a canvas from to stream, encoded in RGB, RGBA, BGR or ABGR format.
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#6
module ChunkyPNG::Canvas::StreamExporting
# Creates an ABGR-formatted pixelstream with the pixel data from this canvas.
#
# Note that this format is fast but bloated, because no compression is used
# and the internal representation is left intact. To reconstruct the
# canvas, the width and height should be known.
#
# @return [String] The RGBA-formatted pixel data.
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#53
def to_abgr_stream; end
# Creates a stream of the alpha channel of this canvas.
#
# @return [String] The 0-255 alpha values of all pixels packed as string
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#32
def to_alpha_channel_stream; end
# Creates a grayscale stream of this canvas.
#
# This method assume sthat this image is fully grayscale, i.e. R = G = B for
# every pixel. The alpha channel will not be included in the stream.
#
# @return [String] The 0-255 grayscale values of all pixels packed as string.
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#42
def to_grayscale_stream; end
# Creates an RGB-formatted pixelstream with the pixel data from this canvas.
#
# Note that this format is fast but bloated, because no compression is used
# and the internal representation is almost left intact. To reconstruct
# the canvas, the width and height should be known.
#
# @return [String] The RGB-formatted pixel data.
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#25
def to_rgb_stream; end
# Creates an RGB-formatted pixelstream with the pixel data from this canvas.
#
# Note that this format is fast but bloated, because no compression is used
# and the internal representation is left intact. To reconstruct the
# canvas, the width and height should be known.
#
# @return [String] The RGBA-formatted pixel data.
#
# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#14
def to_rgba_stream; end
end
# Methods to quickly load a canvas from a stream, encoded in RGB, RGBA, BGR or ABGR format.
#
# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#6
module ChunkyPNG::Canvas::StreamImporting
# Creates a canvas by reading pixels from an ARGB formatted stream with a
# provided with and height.
#
# Every pixel should be represented by 4 bytes in the stream, in the correct
# ARGB order. This format is almost like the internal representation of a
# canvas object, so this kind of stream can be read extremely quickly.
#
# @param width [Integer] The width of the new canvas.
# @param height [Integer] The height of the new canvas.
# @param stream [#read, String] The stream to read the pixel data from.
# @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#71
def from_abgr_stream(width, height, stream); end
# Creates a canvas by reading pixels from an BGR formatted stream with a
# provided with and height.
#
# Every pixel should be represented by 3 bytes in the stream, in the correct
# BGR order. This format closely resembles the internal representation of a
# canvas object, so this kind of stream can be read extremely quickly.
#
# @param width [Integer] The width of the new canvas.
# @param height [Integer] The height of the new canvas.
# @param stream [#read, String] The stream to read the pixel data from.
# @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#53
def from_bgr_stream(width, height, stream); end
# Creates a canvas by reading pixels from an RGB formatted stream with a
# provided with and height.
#
# Every pixel should be represented by 3 bytes in the stream, in the correct
# RGB order. This format closely resembles the internal representation of a
# canvas object, so this kind of stream can be read extremely quickly.
#
# @param width [Integer] The width of the new canvas.
# @param height [Integer] The height of the new canvas.
# @param stream [#read, String] The stream to read the pixel data from.
# @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#18
def from_rgb_stream(width, height, stream); end
# Creates a canvas by reading pixels from an RGBA formatted stream with a
# provided with and height.
#
# Every pixel should be represented by 4 bytes in the stream, in the correct
# RGBA order. This format is exactly like the internal representation of a
# canvas object, so this kind of stream can be read extremely quickly.
#
# @param width [Integer] The width of the new canvas.
# @param height [Integer] The height of the new canvas.
# @param stream [#read, String] The stream to read the pixel data from.
# @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
#
# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#37
def from_rgba_stream(width, height, stream); end
end
# A PNG datastream consists of multiple chunks. This module, and the classes
# contained within, help with handling these chunks. It supports both reading
# and writing chunks.
#
# All chunk types are instances of the {ChunkyPNG::Chunk::Base} class. For
# some chunk types a specialized class is available, e.g. the IHDR chunk is
# represented by the {ChunkyPNG::Chunk::Header} class. These specialized
# classes help accessing the content of the chunk. All other chunks are
# represented by the {ChunkyPNG::Chunk::Generic} class.
#
# @see ChunkyPNG::Datastream
#
# source://chunky_png//lib/chunky_png/chunk.rb#15
module ChunkyPNG::Chunk
class << self
# Reads a chunk from an IO stream.
#
# @param io [IO, #read] The IO stream to read from.
# @return [ChunkyPNG::Chung::Base] The loaded chunk instance.
#
# source://chunky_png//lib/chunky_png/chunk.rb#20
def read(io); end
# Reads an exact number of bytes from an IO stream.
#
# @param io [IO, #read] The IO stream to read from.
# @param length [Integer] The IO exact number of bytes to read.
# @raise [ChunkyPNG::ExpectationFailed] If not exactly length
# bytes could be read from the IO stream.
# @return [String] A binary string of exactly length bytes.
#
# source://chunky_png//lib/chunky_png/chunk.rb#36
def read_bytes(io, length); end
# Verifies the CRC of a chunk.
#
# @param type [String] The chunk's type.
# @param content [String] The chunk's content.
# @param found_crc [Integer] The chunk's found CRC value.
# @raise [ChunkyPNG::CRCMismatch] An exception is raised if
# the found CRC value is not equal to the expected CRC value.
#
# source://chunky_png//lib/chunky_png/chunk.rb#48
def verify_crc!(type, content, found_crc); end
end
end
# The base chunk class is the superclass for every chunk type. It contains
# methods to write the chunk to an output stream.
#
# A subclass should implement the +content+ method, which gets called when
# the chunk gets written to a PNG datastream
#
# @abstract
#
# source://chunky_png//lib/chunky_png/chunk.rb#60
class ChunkyPNG::Chunk::Base
# Initializes the chunk instance.
#
# @param type [String] The four character chunk type indicator.
# @param attributes [Hash] A hash of attributes to set on this chunk.
# @return [Base] a new instance of Base
#
# source://chunky_png//lib/chunky_png/chunk.rb#69
def initialize(type, attributes = T.unsafe(nil)); end
# The four-character type indicator for the chunk. This field is used to
# find the correct class for a chunk when it is loaded from a PNG stream.
#
# @return [String]
#
# source://chunky_png//lib/chunky_png/chunk.rb#64
def type; end
# The four-character type indicator for the chunk. This field is used to
# find the correct class for a chunk when it is loaded from a PNG stream.
#
# @return [String]
#
# source://chunky_png//lib/chunky_png/chunk.rb#64
def type=(_arg0); end
# Writes the chunk to the IO stream.
#
# It will call the +content+ method to get the content for this chunk,
# and will calculate and append the checksum automatically.
#
# @param io [IO] The IO stream to write to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#88
def write(io); end
# Writes the chunk to the IO stream, using the provided content.
# The checksum will be calculated and appended to the stream.
#
# @param io [IO] The IO stream to write to.
# @param content [String] The content for this chunk.
#
# source://chunky_png//lib/chunky_png/chunk.rb#78
def write_with_crc(io, content); end
end
# Maps chunk types to classes, based on the four byte chunk type indicator
# at the beginning of a chunk.
#
# If a chunk type is not specified in this hash, the Generic chunk type
# will be used.
#
# @see ChunkyPNG::Chunk.read
#
# source://chunky_png//lib/chunky_png/chunk.rb#460
ChunkyPNG::Chunk::CHUNK_TYPES = T.let(T.unsafe(nil), Hash)
# The CompressedText (zTXt) chunk contains keyword/value metadata about the
# PNG stream. In this chunk, the value is compressed using Deflate
# compression.
#
# @see https://www.w3.org/TR/PNG/#11zTXt
# @see ChunkyPNG::Chunk::CompressedText
# @see ChunkyPNG::Chunk::InternationalText
#
# source://chunky_png//lib/chunky_png/chunk.rb#331
class ChunkyPNG::Chunk::CompressedText < ::ChunkyPNG::Chunk::Base
# @return [CompressedText] a new instance of CompressedText
#
# source://chunky_png//lib/chunky_png/chunk.rb#334
def initialize(keyword, value); end
# Creates the content to write to the stream, by concatenating the
# keyword with the deflated value, joined by a null character.
#
# @return The content that should be written to the datastream.
#
# source://chunky_png//lib/chunky_png/chunk.rb#349
def content; end
# Returns the value of attribute keyword.
#
# source://chunky_png//lib/chunky_png/chunk.rb#332
def keyword; end
# Sets the attribute keyword
#
# @param value the value to set the attribute keyword to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#332
def keyword=(_arg0); end
# Returns the value of attribute value.
#
# source://chunky_png//lib/chunky_png/chunk.rb#332
def value; end
# Sets the attribute value
#
# @param value the value to set the attribute value to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#332
def value=(_arg0); end
class << self
# @raise [ChunkyPNG::NotSupported]
#
# source://chunky_png//lib/chunky_png/chunk.rb#339
def read(type, content); end
end
end
# The End (IEND) chunk indicates the last chunk of a PNG stream. It does
# not contain any data.
#
# @see https://www.w3.org/TR/PNG/#11IEND
#
# source://chunky_png//lib/chunky_png/chunk.rb#175
class ChunkyPNG::Chunk::End < ::ChunkyPNG::Chunk::Base
# @return [End] a new instance of End
#
# source://chunky_png//lib/chunky_png/chunk.rb#176
def initialize; end
# Returns an empty string, because this chunk should always be empty.
#
# @return [""] An empty string.
#
# source://chunky_png//lib/chunky_png/chunk.rb#194
def content; end
class << self
# Reads the END chunk. It will check if the content is empty.
#
# @param type [String] The four character chunk type indicator (=
# "IEND").
# @param content [String] The content read from the chunk. Should be
# empty.
# @raise [ChunkyPNG::ExpectationFailed] Raises an exception if the content was not empty.
# @return [ChunkyPNG::Chunk::End] The new End chunk instance.
#
# source://chunky_png//lib/chunky_png/chunk.rb#187
def read(type, content); end
end
end
# The Generic chunk type will read the content from the chunk as it,
# and will write it back as it was read.
#
# source://chunky_png//lib/chunky_png/chunk.rb#97
class ChunkyPNG::Chunk::Generic < ::ChunkyPNG::Chunk::Base
# @return [Generic] a new instance of Generic
#
# source://chunky_png//lib/chunky_png/chunk.rb#100
def initialize(type, content = T.unsafe(nil)); end
# The attribute to store the content from the chunk, which gets
# written by the +write+ method.
#
# source://chunky_png//lib/chunky_png/chunk.rb#98
def content; end
# The attribute to store the content from the chunk, which gets
# written by the +write+ method.
#
# source://chunky_png//lib/chunky_png/chunk.rb#98
def content=(_arg0); end
class << self
# Creates an instance, given the chunk's type and content.
#
# @param type [String] The four character chunk type indicator.
# @param content [String] The content read from the chunk.
# @return [ChunkyPNG::Chunk::Generic] The new chunk instance.
#
# source://chunky_png//lib/chunky_png/chunk.rb#108
def read(type, content); end
end
end
# The header (IHDR) chunk is the first chunk of every PNG image, and
# contains information about the image: i.e. its width, height, color
# depth, color mode, compression method, filtering method and interlace
# method.
#
# ChunkyPNG supports all values for these variables that are defined in the
# PNG spec, except for color depth: Only 8-bit depth images are supported.
# Note that it is still possible to access the chunk for such an image, but
# ChunkyPNG will raise an exception if you try to access the pixel data.
#
# @see https://www.w3.org/TR/PNG/#11IHDR
#
# source://chunky_png//lib/chunky_png/chunk.rb#124
class ChunkyPNG::Chunk::Header < ::ChunkyPNG::Chunk::Base
# @return [Header] a new instance of Header
#
# source://chunky_png//lib/chunky_png/chunk.rb#127
def initialize(attrs = T.unsafe(nil)); end
# Returns the value of attribute color.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def color; end
# Sets the attribute color
#
# @param value the value to set the attribute color to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def color=(_arg0); end
# Returns the value of attribute compression.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def compression; end
# Sets the attribute compression
#
# @param value the value to set the attribute compression to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def compression=(_arg0); end
# Returns the content for this chunk when it gets written to a file, by
# packing the image information variables into the correct format.
#
# @return [String] The 13-byte content for the header chunk.
#
# source://chunky_png//lib/chunky_png/chunk.rb#158
def content; end
# Returns the value of attribute depth.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def depth; end
# Sets the attribute depth
#
# @param value the value to set the attribute depth to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def depth=(_arg0); end
# Returns the value of attribute filtering.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def filtering; end
# Sets the attribute filtering
#
# @param value the value to set the attribute filtering to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def filtering=(_arg0); end
# Returns the value of attribute height.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def height; end
# Sets the attribute height
#
# @param value the value to set the attribute height to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def height=(_arg0); end
# Returns the value of attribute interlace.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def interlace; end
# Sets the attribute interlace
#
# @param value the value to set the attribute interlace to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def interlace=(_arg0); end
# Returns the value of attribute width.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def width; end
# Sets the attribute width
#
# @param value the value to set the attribute width to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#125
def width=(_arg0); end
class << self
# Reads the 13 bytes of content from the header chunk to set the image
# attributes.
#
# @param type [String] The four character chunk type indicator (= "IHDR").
# @param content [String] The 13 bytes of content read from the chunk.
# @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the
# variables set to the values according to the content.
#
# source://chunky_png//lib/chunky_png/chunk.rb#142
def read(type, content); end
end
end
# An image data (IDAT) chunk holds (part of) the compressed image pixel data.
#
# The data of an image can be split over multiple chunks, which will have to be combined
# and inflated in order to decode an image. See {{.combine_chunks}} to combine chunks
# to decode, and {{.split_in_chunks}} for encoding a pixeldata stream into IDAT chunks.
#
# @see https://www.w3.org/TR/PNG/#11IDAT
#
# source://chunky_png//lib/chunky_png/chunk.rb#271
class ChunkyPNG::Chunk::ImageData < ::ChunkyPNG::Chunk::Generic
class << self
# Combines the list of IDAT chunks and inflates their contents to produce the
# pixeldata stream for the image.
#
# @return [String] The combined, inflated pixeldata as binary string
#
# source://chunky_png//lib/chunky_png/chunk.rb#272
def combine_chunks(data_chunks); end
# Splits and compresses a pixeldata stream into a list of IDAT chunks.
#
# @param data [String] The binary string of pixeldata
# @param level [Integer] The compression level to use.
# @param chunk_size [Integer] The maximum size of a chunk.
#
# source://chunky_png//lib/chunky_png/chunk.rb#286
def split_in_chunks(data, level = T.unsafe(nil), chunk_size = T.unsafe(nil)); end
end
end
# The InternationalText (iTXt) chunk contains keyword/value metadata about the PNG
# stream, translated to a given locale.
#
# The metadata in this chunk can be encoded using UTF-8 characters.
# Moreover, it is possible to define the language of the metadata, and give
# a translation of the keyword name. Finally, it supports bot compressed
# and uncompressed values.
#
# @see https://www.w3.org/TR/PNG/#11iTXt
# @see ChunkyPNG::Chunk::Text
# @see ChunkyPNG::Chunk::CompressedText
#
# source://chunky_png//lib/chunky_png/chunk.rb#407
class ChunkyPNG::Chunk::InternationalText < ::ChunkyPNG::Chunk::Base
# @return [InternationalText] a new instance of InternationalText
#
# source://chunky_png//lib/chunky_png/chunk.rb#410
def initialize(keyword, text, language_tag = T.unsafe(nil), translated_keyword = T.unsafe(nil), compressed = T.unsafe(nil), compression = T.unsafe(nil)); end
# Returns the value of attribute compressed.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def compressed; end
# Sets the attribute compressed
#
# @param value the value to set the attribute compressed to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def compressed=(_arg0); end
# Returns the value of attribute compression.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def compression; end
# Sets the attribute compression
#
# @param value the value to set the attribute compression to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def compression=(_arg0); end
# Assembles the content to write to the stream for this chunk.
#
# @return [String] The binary content that should be written to the datastream.
#
# source://chunky_png//lib/chunky_png/chunk.rb#445
def content; end
# Returns the value of attribute keyword.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def keyword; end
# Sets the attribute keyword
#
# @param value the value to set the attribute keyword to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def keyword=(_arg0); end
# Returns the value of attribute language_tag.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def language_tag; end
# Sets the attribute language_tag
#
# @param value the value to set the attribute language_tag to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def language_tag=(_arg0); end
# Returns the value of attribute text.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def text; end
# Sets the attribute text
#
# @param value the value to set the attribute text to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def text=(_arg0); end
# Returns the value of attribute translated_keyword.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def translated_keyword; end
# Sets the attribute translated_keyword
#
# @param value the value to set the attribute translated_keyword to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#408
def translated_keyword=(_arg0); end
class << self
# Reads the iTXt chunk.
#
# @param type [String] The four character chunk type indicator (= "iTXt").
# @param content [String] The content read from the chunk.
# @raise [ChunkyPNG::InvalidUTF8] If the chunk contains data that is not UTF8-encoded text.
# @raise [ChunkyPNG::NotSupported] If the chunk refers to an unsupported compression method.
# Currently uncompressed data and deflate are supported.
# @return [ChunkyPNG::Chunk::InternationalText] The new End chunk instance.
#
# source://chunky_png//lib/chunky_png/chunk.rb#427
def read(type, content); end
end
end
# The Palette (PLTE) chunk contains the image's palette, i.e. the
# 8-bit RGB colors this image is using.
#
# @see https://www.w3.org/TR/PNG/#11PLTE
# @see ChunkyPNG::Chunk::Transparency
# @see ChunkyPNG::Palette
#
# source://chunky_png//lib/chunky_png/chunk.rb#205
class ChunkyPNG::Chunk::Palette < ::ChunkyPNG::Chunk::Generic; end
# The Physical (pHYs) chunk specifies the intended pixel size or aspect
# ratio for display of the image.
#
# @see https://www.w3.org/TR/PNG/#11pHYs
#
# source://chunky_png//lib/chunky_png/chunk.rb#362
class ChunkyPNG::Chunk::Physical < ::ChunkyPNG::Chunk::Base
# @raise [ArgumentError]
# @return [Physical] a new instance of Physical
#
# source://chunky_png//lib/chunky_png/chunk.rb#365
def initialize(ppux, ppuy, unit = T.unsafe(nil)); end
# Assembles the content to write to the stream for this chunk.
#
# @return [String] The binary content that should be written to the datastream.
#
# source://chunky_png//lib/chunky_png/chunk.rb#389
def content; end
# @raise [ChunkyPNG::UnitsUnknown]
#
# source://chunky_png//lib/chunky_png/chunk.rb#371
def dpix; end
# @raise [ChunkyPNG::UnitsUnknown]
#
# source://chunky_png//lib/chunky_png/chunk.rb#376
def dpiy; end
# Returns the value of attribute ppux.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def ppux; end
# Sets the attribute ppux
#
# @param value the value to set the attribute ppux to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def ppux=(_arg0); end
# Returns the value of attribute ppuy.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def ppuy; end
# Sets the attribute ppuy
#
# @param value the value to set the attribute ppuy to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def ppuy=(_arg0); end
# Returns the value of attribute unit.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def unit; end
# Sets the attribute unit
#
# @param value the value to set the attribute unit to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#363
def unit=(_arg0); end
class << self
# source://chunky_png//lib/chunky_png/chunk.rb#381
def read(type, content); end
end
end
# source://chunky_png//lib/chunky_png/chunk.rb#393
ChunkyPNG::Chunk::Physical::INCHES_PER_METER = T.let(T.unsafe(nil), Float)
# The Text (tEXt) chunk contains keyword/value metadata about the PNG
# stream. In this chunk, the value is stored uncompressed.
#
# The tEXt chunk only supports Latin-1 encoded textual data. If you need
# UTF-8 support, check out the InternationalText chunk type.
#
# @see https://www.w3.org/TR/PNG/#11tEXt
# @see ChunkyPNG::Chunk::CompressedText
# @see ChunkyPNG::Chunk::InternationalText
#
# source://chunky_png//lib/chunky_png/chunk.rb#302
class ChunkyPNG::Chunk::Text < ::ChunkyPNG::Chunk::Base
# @return [Text] a new instance of Text
#
# source://chunky_png//lib/chunky_png/chunk.rb#305
def initialize(keyword, value); end
# Creates the content to write to the stream, by concatenating the
# keyword with the value, joined by a null character.
#
# @return The content that should be written to the datastream.
#
# source://chunky_png//lib/chunky_png/chunk.rb#319
def content; end
# Returns the value of attribute keyword.
#
# source://chunky_png//lib/chunky_png/chunk.rb#303
def keyword; end
# Sets the attribute keyword
#
# @param value the value to set the attribute keyword to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#303
def keyword=(_arg0); end
# Returns the value of attribute value.
#
# source://chunky_png//lib/chunky_png/chunk.rb#303
def value; end
# Sets the attribute value
#
# @param value the value to set the attribute value to.
#
# source://chunky_png//lib/chunky_png/chunk.rb#303
def value=(_arg0); end
class << self
# source://chunky_png//lib/chunky_png/chunk.rb#310
def read(type, content); end
end
end
# A transparency (tRNS) chunk defines the transparency for an image.
#
# * For indexed images, it contains the alpha channel for the colors
# defined in the Palette (PLTE) chunk.
# * For grayscale images, it contains the grayscale teint that should be
# considered fully transparent.
# * For truecolor images, it contains the color that should be considered
# fully transparent.
#
# Images having a color mode that already includes an alpha channel, this
# chunk should not be included.
#
# @see https://www.w3.org/TR/PNG/#11tRNS
# @see ChunkyPNG::Chunk::Palette
# @see ChunkyPNG::Palette
#
# source://chunky_png//lib/chunky_png/chunk.rb#230
class ChunkyPNG::Chunk::Transparency < ::ChunkyPNG::Chunk::Generic
# Returns the grayscale entry to be replaced by transparent pixels.
#
# This method should only be used for images having color mode
# ChunkyPNG::COLOR_GRAYSCALE (0).
#
# @return [Integer] The (grayscale) color to replace with fully
# transparent pixels.
#
# source://chunky_png//lib/chunky_png/chunk.rb#254
def grayscale_entry(bit_depth); end
# Returns the alpha channel for the palette of an indexed image.
#
# This method should only be used for images having color mode
# ChunkyPNG::COLOR_INDEXED (3).
#
# @return [Array<Integer>] Returns an array of alpha channel values
# [0-255].
#
# source://chunky_png//lib/chunky_png/chunk.rb#231
def palette_alpha_channel; end
# Returns the truecolor entry to be replaced by transparent pixels,
#
# This method should only be used for images having color mode
# ChunkyPNG::COLOR_TRUECOLOR (2).
#
# @return [Integer] The color to replace with fully transparent pixels.
#
# source://chunky_png//lib/chunky_png/chunk.rb#241
def truecolor_entry(bit_depth); end
end
# The Color module defines methods for handling colors. Within the ChunkyPNG
# library, the concepts of pixels and colors are both used, and they are
# both represented by a Integer.
#
# Pixels/colors are represented in RGBA components. Each of the four
# components is stored with a depth of 8 bits (maximum value = 255 =
# {ChunkyPNG::Color::MAX}). Together, these components are stored in a 4-byte
# Integer.
#
# A color will always be represented using these 4 components in memory.
# When the image is encoded, a more suitable representation can be used
# (e.g. rgb, grayscale, palette-based), for which several conversion methods
# are provided in this module.
#
# source://chunky_png//lib/chunky_png/color.rb#57
module ChunkyPNG::Color
extend ::ChunkyPNG::Color
# Returns the alpha channel value for the color value.
#
# @param value [Integer] The color value.
# @return [Integer] A value between 0 and MAX.
#
# source://chunky_png//lib/chunky_png/color.rb#299
def a(value); end
# Checks whether an alpha channel value can successfully be composed
# given the resulting color, the mask color and a background color,
# all of which should be opaque.
#
# @param color [Integer] The color that was the result of compositing.
# @param mask [Integer] The opaque variant of the color that was being
# composed
# @param bg [Integer] The background color on which the color was composed.
# @param tolerance [Integer] The decomposition tolerance level, a value
# between 0 and 255.
# @return [Boolean] True if the alpha component can be decomposed
# successfully.
# @see #decompose_alpha
#
# source://chunky_png//lib/chunky_png/color.rb#503
def alpha_decomposable?(color, mask, bg, tolerance = T.unsafe(nil)); end
# Returns the blue-component from the color value.
#
# @param value [Integer] The color value.
# @return [Integer] A value between 0 and MAX.
#
# source://chunky_png//lib/chunky_png/color.rb#291
def b(value); end
# Blends the foreground and background color by taking the average of
# the components.
#
# @param fg [Integer] The foreground color.
# @param bg [Integer] The foreground color.
# @return [Integer] The blended color.
#
# source://chunky_png//lib/chunky_png/color.rb#406
def blend(fg, bg); end
# 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.
#
# @param fg [Integer] The foreground color.
# @param bg [Integer] The background color.
# @return [Integer] The composited color.
# @see ChunkyPNG::Color#compose_precise
#
# source://chunky_png//lib/chunky_png/color.rb#361
def compose(fg, bg); end
# 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.
#
# @param fg [Integer] The foreground color.
# @param bg [Integer] The background color.
# @return [Integer] The composited color.
# @see ChunkyPNG::Color#compose_quick
#
# source://chunky_png//lib/chunky_png/color.rb#383
def compose_precise(fg, bg); end
# 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.
#
# @param fg [Integer] The foreground color.
# @param bg [Integer] The background color.
# @return [Integer] The composited color.
# @see ChunkyPNG::Color#compose_precise
#
# source://chunky_png//lib/chunky_png/color.rb#361
def compose_quick(fg, bg); end
# Decomposes the alpha channel value given the resulting color, the mask
# color and a background color, all of which should be opaque.
#
# Make sure to call {#alpha_decomposable?} first to see if the alpha
# channel value can successfully decomposed with a given tolerance,
# otherwise the return value of this method is undefined.
#
# @param color [Integer] The color that was the result of compositing.
# @param mask [Integer] The opaque variant of the color that was being
# composed
# @param bg [Integer] The background color on which the color was composed.
# @return [Integer] The best fitting alpha channel, a value between 0 and
# 255.
# @see #alpha_decomposable?
#
# source://chunky_png//lib/chunky_png/color.rb#524
def decompose_alpha(color, mask, bg); end
# Decomposes an alpha channel for either the r, g or b color channel.
#
# @param channel [:r, :g, :b] The channel to decompose the alpha channel
# from.
# @param color [Integer] The color that was the result of compositing.
# @param mask [Integer] The opaque variant of the color that was being
# composed
# @param bg [Integer] The background color on which the color was composed.
# @return [Integer] The decomposed alpha value for the channel.
#
# source://chunky_png//lib/chunky_png/color.rb#537
def decompose_alpha_component(channel, color, mask, bg); end
# Decomposes the alpha channels for the r, g and b color channel.
#
# @param color [Integer] The color that was the result of compositing.
# @param mask [Integer] The opaque variant of the color that was being
# composed
# @param bg [Integer] The background color on which the color was composed.
# @return [Array<Integer>] The decomposed alpha values for the r, g and b
# channels.
#
# source://chunky_png//lib/chunky_png/color.rb#554
def decompose_alpha_components(color, mask, bg); end
# Decomposes a color, given a color, a mask color and a background color.
# The returned color will be a variant of the mask color, with the alpha
# channel set to the best fitting value. This basically is the reverse
# operation if alpha composition.
#
# If the color cannot be decomposed, this method will return the fully
# transparent variant of the mask color.
#
# @param color [Integer] The color that was the result of compositing.
# @param mask [Integer] The opaque variant of the color that was being
# composed
# @param bg [Integer] The background color on which the color was composed.
# @param tolerance [Integer] The decomposition tolerance level, a value
# between 0 and 255.
# @return [Integer] The decomposed color, a variant of the masked color
# with the alpha channel set to an appropriate value.
#
# source://chunky_png//lib/chunky_png/color.rb#482
def decompose_color(color, mask, bg, tolerance = T.unsafe(nil)); end
# Compute the Euclidean distance between 2 colors in RGBA
#
# This method simply takes the Euclidean distance between the RGBA channels
# of 2 colors, which gives us a measure of how different the two colors
# are.
#
# Although it would be more perceptually accurate to calculate a proper
# Delta E in Lab colorspace, this method should serve many use-cases while
# avoiding the overhead of converting RGBA to Lab.
#
# @param pixel_after [Integer]
# @param pixel_before [Integer]
# @return [Float]
#
# source://chunky_png//lib/chunky_png/color.rb#722
def euclidean_distance_rgba(pixel_after, pixel_before); end
# Lowers the intensity of a color, by lowering its alpha by a given factor.
#
# @param color [Integer] The color to adjust.
# @param factor [Integer] Fade factor as an integer between 0 and 255.
# @return [Integer] The faded color.
#
# source://chunky_png//lib/chunky_png/color.rb#461
def fade(color, factor); end
# Creates a color by converting it from a string in hex notation.
#
# It supports colors with (#rrggbbaa) or without (#rrggbb) alpha channel
# as well as the 3-digit short format (#rgb) for those without.
# Color strings may include the prefix "0x" or "#".
#
# @param hex_value [String] The color in hex notation.
# @param opacity [Integer] The opacity value for the color. Overrides any
# opacity value given in the hex value if given.
# @raise [ArgumentError] if the value given is not a hex color notation.
# @return [Integer] The color value.
#
# source://chunky_png//lib/chunky_png/color.rb#167
def from_hex(hex_value, opacity = T.unsafe(nil)); end
# Creates a new color from an HSV triple.
#
# Create a new color using an HSV (sometimes also called HSB) triple. The
# words `value` and `brightness` are used interchangeably and synonymously
# in descriptions of this colorspace. This implementation follows the modern
# convention of 0 degrees hue indicating red.
#
# @param hue [Fixnum] The hue component (0-360)
# @param saturation [Fixnum] The saturation component (0-1)
# @param value [Fixnum] The value (brightness) component (0-1)
# @param alpha [Fixnum] Defaults to opaque (255).
# @raise [ArgumentError] if the hsv triple is invalid.
# @return [Integer] The newly constructed color value.
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#194
def from_hsb(hue, saturation, value, alpha = T.unsafe(nil)); end
# Creates a new color from an HSL triple.
#
# This implementation follows the modern convention of 0 degrees hue
# indicating red.
#
# @param hue [Fixnum] The hue component (0-360)
# @param saturation [Fixnum] The saturation component (0-1)
# @param lightness [Fixnum] The lightness component (0-1)
# @param alpha [Fixnum] Defaults to opaque (255).
# @raise [ArgumentError] if the hsl triple is invalid.
# @return [Integer] The newly constructed color value.
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#220
def from_hsl(hue, saturation, lightness, alpha = T.unsafe(nil)); end
# Creates a new color from an HSV triple.
#
# Create a new color using an HSV (sometimes also called HSB) triple. The
# words `value` and `brightness` are used interchangeably and synonymously
# in descriptions of this colorspace. This implementation follows the modern
# convention of 0 degrees hue indicating red.
#
# @param hue [Fixnum] The hue component (0-360)
# @param saturation [Fixnum] The saturation component (0-1)
# @param value [Fixnum] The value (brightness) component (0-1)
# @param alpha [Fixnum] Defaults to opaque (255).
# @raise [ArgumentError] if the hsv triple is invalid.
# @return [Integer] The newly constructed color value.
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#194
def from_hsv(hue, saturation, value, alpha = T.unsafe(nil)); end
# Creates a color by unpacking an rgb triple from a string.
#
# @param stream [String] The string to load the color from. It should be
# at least 3 + pos bytes long.
# @param pos [Integer] The position in the string to load the triple from.
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#142
def from_rgb_stream(stream, pos = T.unsafe(nil)); end
# Creates a color by unpacking an rgba triple from a string
#
# @param stream [String] The string to load the color from. It should be
# at least 4 + pos bytes long.
# @param pos [Integer] The position in the string to load the triple from.
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#152
def from_rgba_stream(stream, pos = T.unsafe(nil)); end
# Returns true if this color is fully transparent.
#
# @param value [Integer] The color to test.
# @return [true, false] True if the alpha channel equals 0.
#
# source://chunky_png//lib/chunky_png/color.rb#330
def fully_transparent?(value); end
# Returns the green-component from the color value.
#
# @param value [Integer] The color value.
# @return [Integer] A value between 0 and MAX.
#
# source://chunky_png//lib/chunky_png/color.rb#283
def g(value); end
# Creates a new color using a grayscale teint.
#
# @param teint [Integer] The grayscale teint (0-255), will be used as r, g,
# and b value.
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#119
def grayscale(teint); end
# Returns true if this color is fully transparent.
#
# @param value [Integer] The color to test.
# @return [true, false] True if the r, g and b component are equal.
#
# source://chunky_png//lib/chunky_png/color.rb#322
def grayscale?(value); end
# Creates a new color using a grayscale teint and alpha value.
#
# @param teint [Integer] The grayscale teint (0-255), will be used as r, g,
# and b value.
# @param a [Integer] The opacity (0-255)
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#128
def grayscale_alpha(teint, a); end
# Calculates the grayscale teint of an RGB color.
#
# @param color [Integer] The color to convert.
# @return [Integer] The grayscale teint of the input color, 0-255.
#
# source://chunky_png//lib/chunky_png/color.rb#438
def grayscale_teint(color); end
# Gets a color value based on a HTML color name.
#
# The color name is flexible. E.g. <tt>'yellowgreen'</tt>, <tt>'Yellow
# green'</tt>, <tt>'YellowGreen'</tt>, <tt>'YELLOW_GREEN'</tt> and
# <tt>:yellow_green</tt> will all return the same color value.
#
# You can include a opacity level in the color name (e.g. <tt>'red @
# 0.5'</tt>) or give an explicit opacity value as second argument. If no
# opacity value is given, the color will be fully opaque.
#
# @param color_name [Symbol, String] The color name. It may include an
# opacity specifier like <tt>@ 0.8</tt> to set the color's opacity.
# @param opacity [Integer] The opacity value for the color between 0 and
# 255. Overrides any opacity value given in the color name.
# @raise [ChunkyPNG::Exception] If the color name was not recognized.
# @return [Integer] The color value.
#
# source://chunky_png//lib/chunky_png/color.rb#909
def html_color(color_name, opacity = T.unsafe(nil)); end
# Multiplies two fractions using integer math, where the fractions are
# stored using an integer between 0 and 255. This method is used as a
# helper method for compositing colors using integer math.
#
# This is a quicker implementation of ((a * b) / 255.0).round.
#
# @param a [Integer] The first fraction.
# @param b [Integer] The second fraction.
# @return [Integer] The result of the multiplication.
#
# source://chunky_png//lib/chunky_png/color.rb#347
def int8_mult(a, b); end
# Interpolates the foreground and background colors by the given alpha
# value. This also blends the alpha channels themselves.
#
# A blending factor of 255 will give entirely the foreground,
# while a blending factor of 0 will give the background.
#
# @param fg [Integer] The foreground color.
# @param bg [Integer] The background color.
# @param alpha [Integer] The blending factor (fixed 8bit)
# @return [Integer] The interpolated color.
#
# source://chunky_png//lib/chunky_png/color.rb#420
def interpolate_quick(fg, bg, alpha); end
# Returns the opaque value of this color by removing the alpha channel.
#
# @param value [Integer] The color to transform.
# @return [Integer] The opaque color
#
# source://chunky_png//lib/chunky_png/color.rb#314
def opaque!(value); end
# Returns true if this color is fully opaque.
#
# @param value [Integer] The color to test.
# @return [true, false] True if the alpha channel equals MAX.
#
# source://chunky_png//lib/chunky_png/color.rb#307
def opaque?(value); end
# Parses a color value given a numeric or string argument.
#
# It supports color numbers, colors in hex notation and named HTML colors.
#
# @param source [Integer, String] The color value.
# @return [Integer] The color value, with the opacity applied if one was
# given.
#
# source://chunky_png//lib/chunky_png/color.rb#86
def parse(source); end
# Returns the number of bytes used for an image pass
#
# @param color_mode [Integer] The color mode in which the pixels are
# stored.
# @param depth [Integer] The color depth of the pixels.
# @param width [Integer] The width of the image pass.
# @param height [Integer] The height of the image pass.
# @return [Integer] The number of bytes used per scanline in a datastream.
#
# source://chunky_png//lib/chunky_png/color.rb#984
def pass_bytesize(color_mode, depth, width, height); end
# Returns the size in bits of a pixel when it is stored using a given color
# mode.
#
# @param color_mode [Integer] The color mode in which the pixels are
# stored.
# @param depth [Integer] The color depth of the pixels.
# @return [Integer] The number of bytes used per pixel in a datastream.
#
# source://chunky_png//lib/chunky_png/color.rb#963
def pixel_bitsize(color_mode, depth = T.unsafe(nil)); end
# Returns the size in bytes of a pixel when it is stored using a given
# color mode.
#
# @param color_mode [Integer] The color mode in which the pixels are
# stored.
# @return [Integer] The number of bytes used per pixel in a datastream.
#
# source://chunky_png//lib/chunky_png/color.rb#951
def pixel_bytesize(color_mode, depth = T.unsafe(nil)); end
# Returns the red-component from the color value.
#
# @param value [Integer] The color value.
# @return [Integer] A value between 0 and MAX.
#
# source://chunky_png//lib/chunky_png/color.rb#275
def r(value); end
# Creates a new color using an r, g, b triple.
#
# @param r [Integer] The r-component (0-255)
# @param g [Integer] The g-component (0-255)
# @param b [Integer] The b-component (0-255)
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#111
def rgb(r, g, b); end
# Creates a new color using an r, g, b triple and an alpha value.
#
# @param r [Integer] The r-component (0-255)
# @param g [Integer] The g-component (0-255)
# @param b [Integer] The b-component (0-255)
# @param a [Integer] The opacity (0-255)
# @return [Integer] The newly constructed color value.
#
# source://chunky_png//lib/chunky_png/color.rb#102
def rgba(r, g, b, a); end
# Returns the number of sample values per pixel.
#
# @param color_mode [Integer] The color mode being used.
# @return [Integer] The number of sample values per pixel.
#
# source://chunky_png//lib/chunky_png/color.rb#934
def samples_per_pixel(color_mode); end
# Returns the number of bytes used per scanline.
#
# @param color_mode [Integer] The color mode in which the pixels are
# stored.
# @param depth [Integer] The color depth of the pixels.
# @param width [Integer] The number of pixels per scanline.
# @return [Integer] The number of bytes used per scanline in a datastream.
#
# source://chunky_png//lib/chunky_png/color.rb#973
def scanline_bytesize(color_mode, depth, width); end
# Converts a color to a fiting grayscale value. It will conserve the alpha
# channel.
#
# This method will return a full color value, with the R, G, and B value
# set to the grayscale teint calcuated from the input color's R, G and B
# values.
#
# @param color [Integer] The color to convert.
# @return [Integer] The input color, converted to the best fitting
# grayscale.
# @see #grayscale_teint
#
# source://chunky_png//lib/chunky_png/color.rb#453
def to_grayscale(color); end
# Returns an array with the grayscale teint and alpha channel values for
# this color.
#
# This method expects the color to be grayscale, i.e. r, g, and b value to
# be equal and uses only the B channel. If you need to convert a color to
# grayscale first, see {#to_grayscale}.
#
# @param color [Integer] The grayscale color to convert.
# @return [Array<Integer>] An array with 2 Integer elements.
# @see #to_grayscale
#
# source://chunky_png//lib/chunky_png/color.rb#701
def to_grayscale_alpha_bytes(color); end
# Returns an array with the grayscale teint value for this color.
#
# This method expects the r, g, and b value to be equal, and the alpha
# channel will be discarded.
#
# @param color [Integer] The grayscale color to convert.
# @return [Array<Integer>] An array with 1 Integer element.
#
# source://chunky_png//lib/chunky_png/color.rb#687
def to_grayscale_bytes(color); end
# Returns a string representing this color using hex notation (i.e.
# #rrggbbaa).
#
# @param color [Integer] The color to convert.
# @param include_alpha [Boolean]
# @return [String] The color in hex notation, starting with a pound sign.
#
# source://chunky_png//lib/chunky_png/color.rb#572
def to_hex(color, include_alpha = T.unsafe(nil)); end
# Returns an array with the separate HSV components of a color.
#
# Because ChunkyPNG internally handles colors as Integers for performance
# reasons, some rounding occurs when importing or exporting HSV colors
# whose coordinates are float-based. Because of this rounding, #to_hsv and
# #from_hsv may not be perfect inverses.
#
# This implementation follows the modern convention of 0 degrees hue
# indicating red.
#
# @param color [Integer] The ChunkyPNG color to convert.
# @param include_alpha [Boolean] Flag indicates whether a fourth element
# representing alpha channel should be included in the returned array.
# @return [Array[0]] The hue of the color (0-360)
# @return [Array[1]] The saturation of the color (0-1)
# @return [Array[2]] The value of the color (0-1)
# @return [Array[3]] Optional fourth element for alpha, included if
# include_alpha=true (0-255)
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#595
def to_hsb(color, include_alpha = T.unsafe(nil)); end
# Returns an array with the separate HSL components of a color.
#
# Because ChunkyPNG internally handles colors as Integers for performance
# reasons, some rounding occurs when importing or exporting HSL colors
# whose coordinates are float-based. Because of this rounding, #to_hsl and
# #from_hsl may not be perfect inverses.
#
# This implementation follows the modern convention of 0 degrees hue indicating red.
#
# @param color [Integer] The ChunkyPNG color to convert.
# @param include_alpha [Boolean] Flag indicates whether a fourth element
# representing alpha channel should be included in the returned array.
# @return [Array<Fixnum>[0]] The hue of the color (0-360)
# @return [Array<Fixnum>[1]] The saturation of the color (0-1)
# @return [Array<Fixnum>[2]] The lightness of the color (0-1)
# @return [Array<Fixnum>[3]] Optional fourth element for alpha, included if
# include_alpha=true (0-255)
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#624
def to_hsl(color, include_alpha = T.unsafe(nil)); end
# Returns an array with the separate HSV components of a color.
#
# Because ChunkyPNG internally handles colors as Integers for performance
# reasons, some rounding occurs when importing or exporting HSV colors
# whose coordinates are float-based. Because of this rounding, #to_hsv and
# #from_hsv may not be perfect inverses.
#
# This implementation follows the modern convention of 0 degrees hue
# indicating red.
#
# @param color [Integer] The ChunkyPNG color to convert.
# @param include_alpha [Boolean] Flag indicates whether a fourth element
# representing alpha channel should be included in the returned array.
# @return [Array[0]] The hue of the color (0-360)
# @return [Array[1]] The saturation of the color (0-1)
# @return [Array[2]] The value of the color (0-1)
# @return [Array[3]] Optional fourth element for alpha, included if
# include_alpha=true (0-255)
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#595
def to_hsv(color, include_alpha = T.unsafe(nil)); end
# Returns an array with the separate RGBA values for this color.
#
# @param color [Integer] The color to convert.
# @return [Array<Integer>] An array with 4 Integer elements.
#
# source://chunky_png//lib/chunky_png/color.rb#667
def to_truecolor_alpha_bytes(color); end
# Returns an array with the separate RGB values for this color. The alpha
# channel will be discarded.
#
# @param color [Integer] The color to convert.
# @return [Array<Integer>] An array with 3 Integer elements.
#
# source://chunky_png//lib/chunky_png/color.rb#676
def to_truecolor_bytes(color); end
private
# Convert one HSL or HSV triple and associated chroma to a scaled rgb triple
#
# This method encapsulates the shared mathematical operations needed to
# convert coordinates from a cylindrical colorspace such as HSL or HSV into
# coordinates of the RGB colorspace.
#
# Even though chroma values are derived from the other three coordinates,
# the formula for calculating chroma differs for each colorspace. Since it
# is calculated differently for each colorspace, it must be passed in as
# a parameter.
#
# @param hue [Fixnum] The hue-component (0-360)
# @param saturation [Fixnum] The saturation-component (0-1)
# @param y_component [Fixnum] The y_component can represent either lightness
# or brightness/value (0-1) depending on which scheme (HSV/HSL) is being used.
# @param chroma [Fixnum] The associated chroma value.
# @private
# @return [Array<Fixnum>] A scaled r,g,b triple. Scheme-dependent
# adjustments are still needed to reach the true r,g,b values.
# @see https://en.wikipedia.org/wiki/HSL_and_HSV
#
# source://chunky_png//lib/chunky_png/color.rb#252
def cylindrical_to_cubic(hue, saturation, y_component, chroma); end
# This method encapsulates the logic needed to extract hue and chroma from
# a ChunkPNG color. This logic is shared by the cylindrical HSV/HSB and HSL
# color space models.
#
# @param color [Integer] A ChunkyPNG color.
# @private
# @return [Fixnum] hue The hue of the color (0-360)
# @return [Fixnum] chroma The chroma of the color (0-1)
# @return [Fixnum] max The magnitude of the largest scaled rgb component (0-1)
# @return [Fixnum] min The magnitude of the smallest scaled rgb component (0-1)
#
# source://chunky_png//lib/chunky_png/color.rb#643
def hue_and_chroma(color); end
end
# @return [Integer] Black pixel/color
#
# source://chunky_png//lib/chunky_png/color.rb#919
ChunkyPNG::Color::BLACK = T.let(T.unsafe(nil), Integer)
# @private
# @return [Regexp] The regexp to parse 3-digit hex color values.
#
# source://chunky_png//lib/chunky_png/color.rb#65
ChunkyPNG::Color::HEX3_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
# @private
# @return [Regexp] The regexp to parse 6- and 8-digit hex color values.
#
# source://chunky_png//lib/chunky_png/color.rb#69
ChunkyPNG::Color::HEX6_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
# @private
# @return [Regexp] The regexp to parse named color values.
#
# source://chunky_png//lib/chunky_png/color.rb#73
ChunkyPNG::Color::HTML_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
# @return [Integer] The maximum value of each color component.
#
# source://chunky_png//lib/chunky_png/color.rb#61
ChunkyPNG::Color::MAX = T.let(T.unsafe(nil), Integer)
# Could be simplified as MAX * 2, but this format mirrors the math in
# {#euclidean_distance_rgba}
#
# @return [Float] The maximum Euclidean distance of two RGBA colors.
#
# source://chunky_png//lib/chunky_png/color.rb#736
ChunkyPNG::Color::MAX_EUCLIDEAN_DISTANCE_RGBA = T.let(T.unsafe(nil), Float)
# @return [Hash<Symbol, Integer>] All the predefined color names in HTML.
#
# source://chunky_png//lib/chunky_png/color.rb#743
ChunkyPNG::Color::PREDEFINED_COLORS = T.let(T.unsafe(nil), Hash)
# @return [Integer] Fully transparent pixel/color
#
# source://chunky_png//lib/chunky_png/color.rb#925
ChunkyPNG::Color::TRANSPARENT = T.let(T.unsafe(nil), Integer)
# @return [Integer] White pixel/color
#
# source://chunky_png//lib/chunky_png/color.rb#922
ChunkyPNG::Color::WHITE = T.let(T.unsafe(nil), Integer)
# The Datastream class represents a PNG formatted datastream. It supports
# both reading from and writing to strings, streams and files.
#
# A PNG datastream begins with the PNG signature, and then contains multiple
# chunks, starting with a header (IHDR) chunk and finishing with an end
# (IEND) chunk.
#
# @see ChunkyPNG::Chunk
#
# source://chunky_png//lib/chunky_png/datastream.rb#12
class ChunkyPNG::Datastream
# Initializes a new Datastream instance.
#
# @return [Datastream] a new instance of Datastream
#
# source://chunky_png//lib/chunky_png/datastream.rb#45
def initialize; end
# Returns an enumerator instance for this datastream's chunks.
#
# @return [Enumerable::Enumerator] An enumerator for the :each_chunk method.
# @see ChunkyPNG::Datastream#each_chunk
#
# source://chunky_png//lib/chunky_png/datastream.rb#137
def chunks; end
# The chunks that together compose the images pixel data.
#
# @return [Array<ChunkyPNG::Chunk::ImageData>]
#
# source://chunky_png//lib/chunky_png/datastream.rb#38
def data_chunks; end
# The chunks that together compose the images pixel data.
#
# @return [Array<ChunkyPNG::Chunk::ImageData>]
#
# source://chunky_png//lib/chunky_png/datastream.rb#38
def data_chunks=(_arg0); end
# Enumerates the chunks in this datastream.
#
# This will iterate over the chunks using the order in which the chunks
# should appear in the PNG file.
#
# @see ChunkyPNG::Datastream#chunks
# @yield [chunk] Yields the chunks in this datastream, one by one in the correct order.
# @yieldparam chunk [ChunkyPNG::Chunk::Base] A chunk in this datastream.
#
# source://chunky_png//lib/chunky_png/datastream.rb#124
def each_chunk; end
# The empty chunk that signals the end of this datastream
#
# @return [ChunkyPNG::Chunk::Header]
#
# source://chunky_png//lib/chunky_png/datastream.rb#42
def end_chunk; end
# The empty chunk that signals the end of this datastream
#
# @return [ChunkyPNG::Chunk::Header]
#
# source://chunky_png//lib/chunky_png/datastream.rb#42
def end_chunk=(_arg0); end
# The header chunk of this datastream.
#
# @return [ChunkyPNG::Chunk::Header]
#
# source://chunky_png//lib/chunky_png/datastream.rb#18
def header_chunk; end
# The header chunk of this datastream.
#
# @return [ChunkyPNG::Chunk::Header]
#
# source://chunky_png//lib/chunky_png/datastream.rb#18
def header_chunk=(_arg0); end
# Returns the uncompressed image data, combined from all the IDAT chunks
#
# @return [String] The uncompressed image data for this datastream
#
# source://chunky_png//lib/chunky_png/datastream.rb#153
def imagedata; end
# Returns all the textual metadata key/value pairs as hash.
#
# @return [Hash] A hash containing metadata fields and their values.
#
# source://chunky_png//lib/chunky_png/datastream.rb#143
def metadata; end
# All other chunks in this PNG file.
#
# @return [Array<ChunkyPNG::Chunk::Generic>]
#
# source://chunky_png//lib/chunky_png/datastream.rb#22
def other_chunks; end
# All other chunks in this PNG file.
#
# @return [Array<ChunkyPNG::Chunk::Generic>]
#
# source://chunky_png//lib/chunky_png/datastream.rb#22
def other_chunks=(_arg0); end
# The chunk containing the image's palette.
#
# @return [ChunkyPNG::Chunk::Palette]
#
# source://chunky_png//lib/chunky_png/datastream.rb#26
def palette_chunk; end
# The chunk containing the image's palette.
#
# @return [ChunkyPNG::Chunk::Palette]
#
# source://chunky_png//lib/chunky_png/datastream.rb#26
def palette_chunk=(_arg0); end
# The chunk containing the physical dimensions of the PNG's pixels.
#
# @return [ChunkyPNG::Chunk::Physical]
#
# source://chunky_png//lib/chunky_png/datastream.rb#34
def physical_chunk; end
# The chunk containing the physical dimensions of the PNG's pixels.
#
# @return [ChunkyPNG::Chunk::Physical]
#
# source://chunky_png//lib/chunky_png/datastream.rb#34
def physical_chunk=(_arg0); end
# Saves this datastream as a PNG file.
#
# @param filename [String] The filename to use.
#
# source://chunky_png//lib/chunky_png/datastream.rb#170
def save(filename); end
# Encodes this datastream into a string.
#
# @return [String] The encoded PNG datastream.
#
# source://chunky_png//lib/chunky_png/datastream.rb#176
def to_blob; end
# Encodes this datastream into a string.
#
# @return [String] The encoded PNG datastream.
#
# source://chunky_png//lib/chunky_png/datastream.rb#176
def to_s; end
# Encodes this datastream into a string.
#
# @return [String] The encoded PNG datastream.
#
# source://chunky_png//lib/chunky_png/datastream.rb#176
def to_string; end
# The chunk containing the transparency information of the palette.
#
# @return [ChunkyPNG::Chunk::Transparency]
#
# source://chunky_png//lib/chunky_png/datastream.rb#30
def transparency_chunk; end
# The chunk containing the transparency information of the palette.
#
# @return [ChunkyPNG::Chunk::Transparency]
#
# source://chunky_png//lib/chunky_png/datastream.rb#30
def transparency_chunk=(_arg0); end
# Writes the datastream to the given output stream.
#
# @param io [IO] The output stream to write to.
#
# source://chunky_png//lib/chunky_png/datastream.rb#163
def write(io); end
class << self
# Reads a PNG datastream from a string.
#
# @param str [String] The PNG encoded string to load from.
# @return [ChunkyPNG::Datastream] The loaded datastream instance.
#
# source://chunky_png//lib/chunky_png/datastream.rb#58
def from_blob(str); end
# Reads a PNG datastream from a file.
#
# @param filename [String] The path of the file to load from.
# @return [ChunkyPNG::Datastream] The loaded datastream instance.
#
# source://chunky_png//lib/chunky_png/datastream.rb#67
def from_file(filename); end
# Reads a PNG datastream from an input stream
#
# @param io [IO] The stream to read from.
# @return [ChunkyPNG::Datastream] The loaded datastream instance.
#
# source://chunky_png//lib/chunky_png/datastream.rb#76
def from_io(io); end
# Reads a PNG datastream from a string.
#
# @param str [String] The PNG encoded string to load from.
# @return [ChunkyPNG::Datastream] The loaded datastream instance.
#
# source://chunky_png//lib/chunky_png/datastream.rb#58
def from_string(str); end
# Verifies that the current stream is a PNG datastream by checking its signature.
#
# This method reads the PNG signature from the stream, setting the current position
# of the stream directly after the signature, where the IHDR chunk should begin.
#
# @param io [IO] The stream to read the PNG signature from.
# @raise [RuntimeError] An exception is raised if the PNG signature is not found at
# the beginning of the stream.
#
# source://chunky_png//lib/chunky_png/datastream.rb#104
def verify_signature!(io); end
end
end
# The signature that each PNG file or stream should begin with.
#
# source://chunky_png//lib/chunky_png/datastream.rb#14
ChunkyPNG::Datastream::SIGNATURE = T.let(T.unsafe(nil), String)
# Class that represents the dimension of something, e.g. a {ChunkyPNG::Canvas}.
#
# This class contains some methods to simplify performing dimension related checks.
#
# source://chunky_png//lib/chunky_png/dimension.rb#68
class ChunkyPNG::Dimension
# Initializes a new dimension instance.
#
# @param width [Integer] The width-component of the new dimension.
# @param height [Integer] The height-component of the new dimension.
# @return [Dimension] a new instance of Dimension
#
# source://chunky_png//lib/chunky_png/dimension.rb#82
def initialize(width, height); end
# Compares the size of 2 dimensions.
#
# @param other [ChunkyPNG::Dimension] The dimension to compare with.
# @return [-1, 0, 1] -1 if the other dimension has a larger area, 1 of this
# dimension is larger, 0 if both are identical in size.
#
# source://chunky_png//lib/chunky_png/dimension.rb#121
def <=>(other); end
# Checks whether 2 dimensions are identical.
#
# @param other [ChunkyPNG::Dimension] The dimension to compare with.
# @return [true, false] <tt>true</tt> iff width and height match.
#
# source://chunky_png//lib/chunky_png/dimension.rb#104
def ==(other); end
# Returns the area of this dimension.
#
# @return [Integer] The area in number of pixels.
#
# source://chunky_png//lib/chunky_png/dimension.rb#88
def area; end
# Checks whether 2 dimensions are identical.
#
# @param other [ChunkyPNG::Dimension] The dimension to compare with.
# @return [true, false] <tt>true</tt> iff width and height match.
#
# source://chunky_png//lib/chunky_png/dimension.rb#104
def eql?(other); end
# Calculates a hash for the dimension object, based on width and height
#
# @return [Integer] A hashed value of the dimensions
#
# source://chunky_png//lib/chunky_png/dimension.rb#113
def hash; end
# @return [Integer] The height-component of this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#77
def height; end
# @return [Integer] The height-component of this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#77
def height=(_arg0); end
# Checks whether a point is within bounds of this dimension.
#
# @param point_like [ChunkyPNG::Point, ...] A point-like to bounds-check.
# @return [true, false] True iff the x and y coordinate fall in this dimension.
# @see ChunkyPNG.Point
#
# source://chunky_png//lib/chunky_png/dimension.rb#96
def include?(*point_like); end
# Casts this dimension into an array.
#
# @return [Array<Integer>] <tt>[width, height]</tt> for this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#127
def to_a; end
# Casts this dimension into an array.
#
# @return [Array<Integer>] <tt>[width, height]</tt> for this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#127
def to_ary; end
# @return [Integer] The width-component of this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#74
def width; end
# @return [Integer] The width-component of this dimension.
#
# source://chunky_png//lib/chunky_png/dimension.rb#74
def width=(_arg0); end
end
# @private
# @return [Regexp] The regexp to parse dimensions from a string.
#
# source://chunky_png//lib/chunky_png/dimension.rb#71
ChunkyPNG::Dimension::DIMENSION_REGEXP = T.let(T.unsafe(nil), Regexp)
# Null-byte, with the encoding set correctly to ASCII-8BIT (binary) in Ruby 1.9.
#
# @private
# @return [String] A binary string, consisting of one NULL-byte.
#
# source://chunky_png//lib/chunky_png.rb#146
ChunkyPNG::EXTRA_BYTE = T.let(T.unsafe(nil), String)
# Default exception class for ChunkyPNG
#
# source://chunky_png//lib/chunky_png.rb#110
class ChunkyPNG::Exception < ::StandardError; end
# Exception that is raised if an expectation fails.
#
# source://chunky_png//lib/chunky_png.rb#131
class ChunkyPNG::ExpectationFailed < ::ChunkyPNG::Exception; end
# Indicates that the PNG specification's default filtering are
# being used in the image.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#83
ChunkyPNG::FILTERING_DEFAULT = T.let(T.unsafe(nil), Integer)
# Indicates that AVERAGE filtering is used for the scanline.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#99
ChunkyPNG::FILTER_AVERAGE = T.let(T.unsafe(nil), Integer)
# Indicates that no filtering is used for the scanline.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#87
ChunkyPNG::FILTER_NONE = T.let(T.unsafe(nil), Integer)
# Indicates that PAETH filtering is used for the scanline.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#103
ChunkyPNG::FILTER_PAETH = T.let(T.unsafe(nil), Integer)
# Indicates that SUB filtering is used for the scanline.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#91
ChunkyPNG::FILTER_SUB = T.let(T.unsafe(nil), Integer)
# Indicates that UP filtering is used for the scanline.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#95
ChunkyPNG::FILTER_UP = T.let(T.unsafe(nil), Integer)
# Indicates that the image uses Adam7 interlacing.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#76
ChunkyPNG::INTERLACING_ADAM7 = T.let(T.unsafe(nil), Integer)
# Indicates that the image does not use interlacing.
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#72
ChunkyPNG::INTERLACING_NONE = T.let(T.unsafe(nil), Integer)
# ChunkyPNG::Image is an extension of the {ChunkyPNG::Canvas} class, that
# also includes support for metadata.
#
# @see ChunkyPNG::Canvas
#
# source://chunky_png//lib/chunky_png/image.rb#10
class ChunkyPNG::Image < ::ChunkyPNG::Canvas
# Initializes a new ChunkyPNG::Image instance.
#
# @param width [Integer] The width of the new image.
# @param height [Integer] The height of the new image.
# @param bg_color [Integer] The background color of the new image.
# @param metadata [Hash] A hash of metadata fields and values for this image.
# @return [Image] a new instance of Image
# @see ChunkyPNG::Canvas#initialize
#
# source://chunky_png//lib/chunky_png/image.rb#22
def initialize(width, height, bg_color = T.unsafe(nil), metadata = T.unsafe(nil)); end
# @return [Hash] The hash of metadata fields for this PNG image.
#
# source://chunky_png//lib/chunky_png/image.rb#14
def metadata; end
# @return [Hash] The hash of metadata fields for this PNG image.
#
# source://chunky_png//lib/chunky_png/image.rb#14
def metadata=(_arg0); end
# Returns the metadata for this image as PNG chunks.
#
# Chunks will either be of the {ChunkyPNG::Chunk::Text} type for small
# values (in bytes), or of the {ChunkyPNG::Chunk::CompressedText} type
# for values that are larger in size.
#
# @return [Array<ChunkyPNG::Chunk>] An array of metadata chunks.
# @see ChunkyPNG::Image::METADATA_COMPRESSION_TRESHOLD
#
# source://chunky_png//lib/chunky_png/image.rb#43
def metadata_chunks; end
# Encodes the image to a PNG datastream for saving to disk or writing to an IO stream.
#
# Besides encoding the canvas, it will also encode the metadata fields to text chunks.
#
# @param constraints [Hash] The constraints to use when encoding the canvas.
# @return [ChunkyPNG::Datastream] The datastream that contains this image.
# @see ChunkyPNG::Canvas::PNGEncoding#to_datastream
# @see #metadata_chunks
#
# source://chunky_png//lib/chunky_png/image.rb#61
def to_datastream(constraints = T.unsafe(nil)); end
private
# Initializes a copy of another ChunkyPNG::Image instance.
#
# @param other [ChunkyPNG::Image] The other image to copy.
#
# source://chunky_png//lib/chunky_png/image.rb#30
def initialize_copy(other); end
class << self
# Reads a ChunkyPNG::Image instance from a data stream.
#
# Besides decoding the canvas, this will also read the metadata fields
# from the datastream.
#
# @param ds [ChunkyPNG::Datastream] The datastream to read from.
#
# source://chunky_png//lib/chunky_png/image.rb#73
def from_datastream(ds); end
end
end
# The minimum size of bytes the value of a metadata field should be before compression
# is enabled for the chunk.
#
# source://chunky_png//lib/chunky_png/image.rb#11
ChunkyPNG::Image::METADATA_COMPRESSION_TRESHOLD = T.let(T.unsafe(nil), Integer)
# Exception that is raised if an tTXt chunk does not contain valid UTF-8 data.
#
# source://chunky_png//lib/chunky_png.rb#127
class ChunkyPNG::InvalidUTF8 < ::ChunkyPNG::Exception; end
# Exception that is raised for an unsupported PNG image.
#
# source://chunky_png//lib/chunky_png.rb#114
class ChunkyPNG::NotSupported < ::ChunkyPNG::Exception; end
# Exception that when provided coordinates are out of bounds for the canvas
#
# source://chunky_png//lib/chunky_png.rb#135
class ChunkyPNG::OutOfBounds < ::ChunkyPNG::ExpectationFailed; end
# A palette describes the set of colors that is being used for an image.
#
# A PNG image can contain an explicit palette which defines the colors of
# that image, but can also use an implicit palette, e.g. all truecolor colors
# or all grayscale colors.
#
# This palette supports decoding colors from a palette if an explicit palette
# is provided in a PNG datastream, and it supports encoding colors to an
# explicit palette (stores as PLTE & tRNS chunks in a PNG file).
#
# @see ChunkyPNG::Color
#
# source://chunky_png//lib/chunky_png/palette.rb#22
class ChunkyPNG::Palette < ::Set
# Builds a new palette given a set (Enumerable instance) of colors.
#
# @param enum [Enumerable<Integer>] The set of colors to include in this
# palette.This Enumerable can contain duplicates.
# @param decoding_map [Array] 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.
# @return [Palette] a new instance of Palette
#
# source://chunky_png//lib/chunky_png/palette.rb#23
def initialize(enum, decoding_map = T.unsafe(nil)); end
# Returns a color, given the position in the original palette chunk.
#
# @param index [Integer] The 0-based position of the color in the palette.
# @return [ChunkyPNG::Color] The color that is stored in the palette under
# the given index
# @see ChunkyPNG::Palette#can_decode?
#
# source://chunky_png//lib/chunky_png/palette.rb#148
def [](index); end
# Determines the most suitable colormode for this palette.
#
# @return [Integer] The colormode which would create the smallest possible
# file for images that use this exact palette.
#
# source://chunky_png//lib/chunky_png/palette.rb#195
def best_color_settings; end
# Check whether this palette only contains bacl and white.
#
# @return [true, false] True if all colors in this palette are grayscale
# teints.
# @see ChunkyPNG::Color#grayscale??
#
# source://chunky_png//lib/chunky_png/palette.rb#104
def black_and_white?; end
# Checks whether this palette is suitable for decoding an image from a
# datastream.
#
# This requires that the positions of the colors in the original palette
# chunk is known, which is stored as an array in the +@decoding_map+
# instance variable.
#
# @return [true, false] True if a decoding map was built when this palette
# was loaded.
#
# source://chunky_png//lib/chunky_png/palette.rb#126
def can_decode?; end
# Checks whether this palette is suitable for encoding an image from to
# datastream.
#
# This requires that the position of the color in the future palette chunk
# is known, which is stored as a hash in the +@encoding_map+ instance
# variable.
#
# @return [true, false] True if a encoding map was built when this palette
# was loaded.
#
# source://chunky_png//lib/chunky_png/palette.rb#139
def can_encode?; end
# Determines the minimal bit depth required for an indexed image
#
# @return [Integer] Number of bits per pixel, i.e. 1, 2, 4 or 8, or nil if
# this image cannot be saved as an indexed image.
#
# source://chunky_png//lib/chunky_png/palette.rb#216
def determine_bit_depth; end
# Check whether this palette only contains grayscale colors.
#
# @return [true, false] True if all colors in this palette are grayscale
# teints.
# @see ChunkyPNG::Color#grayscale??
#
# source://chunky_png//lib/chunky_png/palette.rb#96
def grayscale?; end
# Returns the position of a color in the palette
#
# @param color [ChunkyPNG::Color] The color for which to look up the index.
# @return [Integer] The 0-based position of the color in the palette.
# @see ChunkyPNG::Palette#can_encode?
#
# source://chunky_png//lib/chunky_png/palette.rb#156
def index(color); end
# Checks whether the size of this palette is suitable for indexed storage.
#
# @return [true, false] True if the number of colors in this palette is at
# most 256.
#
# source://chunky_png//lib/chunky_png/palette.rb#81
def indexable?; end
# Check whether this palette only contains opaque colors.
#
# @return [true, false] True if all colors in this palette are opaque.
# @see ChunkyPNG::Color#opaque?
#
# source://chunky_png//lib/chunky_png/palette.rb#88
def opaque?; end
# Returns a palette with all the opaque variants of the colors in this
# palette.
#
# @return [ChunkyPNG::Palette] A new Palette instance with only opaque
# colors.
# @see ChunkyPNG::Color#opaque!
#
# source://chunky_png//lib/chunky_png/palette.rb#113
def opaque_palette; end
# Creates a PLTE chunk that corresponds with this palette to store the r,
# g, and b channels of all colors.
#
# @note A PLTE chunk should only be included if the image is encoded using
# index colors. After this chunk has been built, the palette becomes
# suitable for encoding an image.
# @return [ChunkyPNG::Chunk::Palette] The PLTE chunk.
# @see ChunkyPNG::Palette#can_encode?
#
# source://chunky_png//lib/chunky_png/palette.rb#180
def to_plte_chunk; end
# Creates a tRNS chunk that corresponds with this palette to store the
# alpha channel of all colors.
#
# Note that this chunk can be left out of every color in the palette is
# opaque, and the image is encoded using indexed colors.
#
# @return [ChunkyPNG::Chunk::Transparency] The tRNS chunk.
#
# source://chunky_png//lib/chunky_png/palette.rb#167
def to_trns_chunk; end
class << self
# Builds a palette instance from a given canvas.
#
# @param canvas [ChunkyPNG::Canvas] The canvas to create a palette for.
# @return [ChunkyPNG::Palette] The palette instance.
#
# source://chunky_png//lib/chunky_png/palette.rb#63
def from_canvas(canvas); end
# Builds a palette instance from a PLTE chunk and optionally a tRNS chunk
# from a PNG datastream.
#
# This method will cerate a palette that is suitable for decoding an image.
#
# @param palette_chunk [ChunkyPNG::Chunk::Palette] The palette chunk to
# load from
# @param transparency_chunk [ChunkyPNG::Chunk::Transparency, nil] The
# optional transparency chunk.
# @return [ChunkyPNG::Palette] The loaded palette instance.
# @see ChunkyPNG::Palette#can_decode?
#
# source://chunky_png//lib/chunky_png/palette.rb#41
def from_chunks(palette_chunk, transparency_chunk = T.unsafe(nil)); end
# Builds a palette instance from a given set of pixels.
#
# @param pixels [Enumerable<Integer>] An enumeration of pixels to create a
# palette for
# @return [ChunkyPNG::Palette] The palette instance.
#
# source://chunky_png//lib/chunky_png/palette.rb#74
def from_pixels(pixels); end
end
end
# Simple class that represents a point on a canvas using an x and y coordinate.
#
# This class implements some basic methods to handle comparison, the splat operator and
# bounds checking that make it easier to work with coordinates.
#
# @see ChunkyPNG.Point
#
# source://chunky_png//lib/chunky_png/point.rb#73
class ChunkyPNG::Point
# Initializes a new point instance.
#
# @param x [Integer, :to_i] The x-coordinate.
# @param y [Integer, :to_i] The y-coordinate.
# @return [Point] a new instance of Point
#
# source://chunky_png//lib/chunky_png/point.rb#87
def initialize(x, y); end
# Compares 2 points.
#
# It will first compare the y coordinate, and it only takes the x-coordinate into
# account if the y-coordinates of the points are identical. This way, an array of
# points will be sorted into the order in which they would occur in the pixels
# array returned by {ChunkyPNG::Canvas#pixels}.
#
# @param other [ChunkyPNG::Point] The point to compare this point with.
# @return [-1, 0, 1] <tt>-1</tt> If this point comes before the other one, <tt>1</tt>
# if after, and <tt>0</tt> if the points are identical.
#
# source://chunky_png//lib/chunky_png/point.rb#109
def <=>(other); end
# Checks whether 2 points are identical.
#
# @return [true, false] <tt>true</tt> iff the x and y coordinates match
#
# source://chunky_png//lib/chunky_png/point.rb#93
def ==(other); end
# Checks whether 2 points are identical.
#
# @return [true, false] <tt>true</tt> iff the x and y coordinates match
#
# source://chunky_png//lib/chunky_png/point.rb#93
def eql?(other); end
# Converts the point instance to an array.
#
# @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
#
# source://chunky_png//lib/chunky_png/point.rb#115
def to_a; end
# Converts the point instance to an array.
#
# @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
#
# source://chunky_png//lib/chunky_png/point.rb#115
def to_ary; end
# Checks whether the point falls into a dimension
#
# @param dimension_like [ChunkyPNG::Dimension, ...] The dimension of which the bounds
# should be taken for the check.
# @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width
# and height of the dimension.
#
# source://chunky_png//lib/chunky_png/point.rb#126
def within_bounds?(*dimension_like); end
# @return [Integer] The x-coordinate of the point.
#
# source://chunky_png//lib/chunky_png/point.rb#79
def x; end
# @return [Integer] The x-coordinate of the point.
#
# source://chunky_png//lib/chunky_png/point.rb#79
def x=(_arg0); end
# @return [Integer] The y-coordinate of the point.
#
# source://chunky_png//lib/chunky_png/point.rb#82
def y; end
# @return [Integer] The y-coordinate of the point.
#
# source://chunky_png//lib/chunky_png/point.rb#82
def y=(_arg0); end
end
# @private
# @return [Regexp] The regexp to parse points from a string.
#
# source://chunky_png//lib/chunky_png/point.rb#76
ChunkyPNG::Point::POINT_REGEXP = T.let(T.unsafe(nil), Regexp)
# Exception that is raised if the PNG signature is not encountered at the
# beginning of the file.
#
# source://chunky_png//lib/chunky_png.rb#119
class ChunkyPNG::SignatureMismatch < ::ChunkyPNG::Exception; end
# Indicates that the PNG chunk content is not compressed
# flag used in iTXt chunk
#
# @private
#
# source://chunky_png//lib/chunky_png.rb#63
ChunkyPNG::UNCOMPRESSED_CONTENT = T.let(T.unsafe(nil), Integer)
# Exception that is raised when requesting the DPI of a PNG that doesn't
# specify the units of its physical pixel dimensions.
#
# source://chunky_png//lib/chunky_png.rb#140
class ChunkyPNG::UnitsUnknown < ::ChunkyPNG::Exception; end
# The current version of ChunkyPNG.
# Set it and commit the change this before running rake release.
#
# source://chunky_png//lib/chunky_png/version.rb#6
ChunkyPNG::VERSION = T.let(T.unsafe(nil), String)
# Class that represents a vector of points, i.e. a list of {ChunkyPNG::Point} instances.
#
# Vectors can be created quite flexibly. See the {ChunkyPNG.Vector} factory methods for
# more information on how to construct vectors.
#
# source://chunky_png//lib/chunky_png/vector.rb#34
class ChunkyPNG::Vector
include ::Enumerable
# 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.
#
# @param points [Array<ChunkyPNG::Point>]
# @return [Vector] a new instance of Vector
# @see ChunkyPNG.Vector
#
# source://chunky_png//lib/chunky_png/vector.rb#46
def initialize(points = T.unsafe(nil)); end
# Comparison between two vectors for quality.
#
# @param other [ChunkyPNG::Vector] The vector to compare with.
# @return [true, false] true if the list of points are identical
#
# source://chunky_png//lib/chunky_png/vector.rb#98
def ==(other); end
# Returns the point with the given indexof this vector.
#
# @param index [Integer] The 0-based index of the point in this vector.
# @return [ChunkyPNG::Point] The point instance.
#
# source://chunky_png//lib/chunky_png/vector.rb#69
def [](index); end
# Returns the dimension of the minimal bounding rectangle of the points in this vector.
#
# @return [ChunkyPNG::Dimension] The dimension instance with the width and height
#
# source://chunky_png//lib/chunky_png/vector.rb#162
def dimension; end
# Iterates over all the points in this vector
#
# @return [void]
# @yield [ChunkyPNG::Point] The points in the correct order.
#
# source://chunky_png//lib/chunky_png/vector.rb#91
def each(&block); end
# Iterates over all the edges in this vector.
#
# An edge is a combination of two subsequent points in the vector. Together, they will form
# a path from the first point to the last point
#
# @param close [true, false] Whether to close the path, i.e. return an edge that connects the last
# point in the vector back to the first point.
# @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
# @return [void]
# @see #edges
# @yield [points.last, points.first]
#
# source://chunky_png//lib/chunky_png/vector.rb#60
def each_edge(close = T.unsafe(nil)); end
# Returns an enumerator that will iterate over all the edges in this vector.
#
# @param close [true, false] Whether to close the path, i.e. return an edge that connects the last
# point in the vector back to the first point.
# @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
# @return [Enumerator] The enumerator that iterates over the edges.
# @see #each_edge
#
# source://chunky_png//lib/chunky_png/vector.rb#78
def edges(close = T.unsafe(nil)); end
# Comparison between two vectors for quality.
#
# @param other [ChunkyPNG::Vector] The vector to compare with.
# @return [true, false] true if the list of points are identical
#
# source://chunky_png//lib/chunky_png/vector.rb#98
def eql?(other); end
# Returns the height of the minimal bounding box of all the points in this vector.
#
# @return [Integer] The y-distance between the points that are farthest from each other.
#
# source://chunky_png//lib/chunky_png/vector.rb#156
def height; end
# Returns the number of points in this vector.
#
# @return [Integer] The length of the points array.
#
# source://chunky_png//lib/chunky_png/vector.rb#84
def length; end
# Finds the highest x-coordinate in this vector.
#
# @return [Integer] The highest x-coordinate of all the points in the vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#124
def max_x; end
# Finds the highest y-coordinate in this vector.
#
# @return [Integer] The highest y-coordinate of all the points in the vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#136
def max_y; end
# Finds the lowest x-coordinate in this vector.
#
# @return [Integer] The lowest x-coordinate of all the points in the vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#118
def min_x; end
# Finds the lowest y-coordinate in this vector.
#
# @return [Integer] The lowest y-coordinate of all the points in the vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#130
def min_y; end
# Returns the offset from (0,0) of the minimal bounding box of all the
# points in this vector
#
# @return [ChunkyPNG::Point] A point that describes the top left corner if a
# minimal bounding box would be drawn around all the points in the vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#144
def offset; end
# @return [Array<ChunkyPNG::Point>] The array that holds all the points in this vector.
#
# source://chunky_png//lib/chunky_png/vector.rb#38
def points; end
# Returns the width of the minimal bounding box of all the points in this vector.
#
# @return [Integer] The x-distance between the points that are farthest from each other.
#
# source://chunky_png//lib/chunky_png/vector.rb#150
def width; end
# Returns the range in x-coordinates for all the points in this vector.
#
# @return [Range] The (inclusive) range of x-coordinates.
#
# source://chunky_png//lib/chunky_png/vector.rb#106
def x_range; end
# Returns the range in y-coordinates for all the points in this vector.
#
# @return [Range] The (inclusive) range of y-coordinates.
#
# source://chunky_png//lib/chunky_png/vector.rb#112
def y_range; end
class << self
# @return [Array<ChunkyPNG::Point>] The list of points interpreted from the input array.
#
# source://chunky_png//lib/chunky_png/vector.rb#167
def multiple_from_array(source); end
# @return [Array<ChunkyPNG::Point>] The list of points parsed from the string.
#
# source://chunky_png//lib/chunky_png/vector.rb#181
def multiple_from_string(source_str); end
end
end