expand a constant into an image

Create a new Image from a 1D or 2D array. A 1D array becomes an image with height 1. Use #scale and #offset to set the scale and offset fields in the header. These are useful for integer convolutions.

For example:

image = Vips::Image.new_from_array [1, 2, 3]

or

image = Vips::Image.new_from_array [
  [-1, -1, -1],
  [-1, 16, -1],
  [-1, -1, -1],
], 8

for a simple sharpening mask.

Create a new Image for an image encoded in a format such as JPEG in a binary String, Bytes or IO. Load options may be passed as strings or appended as a keyword arguments. For example:

image = Vips::Image.new_from_buffer memory_buffer, "shrink=2"

or alternatively:

image = Vips::Image.new_from_buffer memory_buffer, "", shrink: 2

The options available depend on the file format. Try something like:

$ vips jpegload_buffer

at the command-line to see the available options. Not all loaders support load from buffer, but at least JPEG, PNG and TIFF images will work.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be decompressed when they are needed.

Return a new Image for a file on disc. This method can load images in any format supported by vips. The filename can include load options, for example:

image = Vips::Image.new_from_file "fred.jpg[shrink=2]"

You can also supply options as keyword arguments (NamedTuple), for example:

image = Vips::Image.new_from_file "fred.jpg", shrink: 2

The full set of options available depend upon the load operation that will be executed. Try something like:

$ vips jpegload

at the command-line to see a summary of the available options for the JPEG loader.

Loading is fast: only enough of the image is loaded to be able to fill out the header. Pixels will only be decompressed when they are needed.

Wraps an Image around an area of memory containing a C-style array. For example, if the data memory array contains four bytes with the values 1, 2, 3, 4, you can make a one-band, 2x2 uchar image from it like this:

image = Image.new_from_memory(data, 2, 2, 1, Enums::BandFormat::Uchar)

A reference is kept to the data object, so it will not be garbage-collected until the returned image is garbage-collected.

This method is useful for efficiently transferring images from GDI+ into libvips.

Create a new Image from memory and copies the memory area. See .new_from_memory for a version of this method which does not copy the memory area.

Create a new Image from a source. Load options may be passed as strings or appended as a hash. For example:

source = Vips::Source.new_from_file("k2.jpg")
image = Vips::Image.new_from_source source, "shrink=2"

or alternatively:

image = Vips::Image.new_from_source source, shrink: 2

The options available depend on the file format. Try something like:

$ vips jpegload_source

at the command-line to see the available options. Not all loaders support load from source, but at least JPEG, PNG and TIFF images will work.

Loading is fast: only enough data is read to be able to fill out the header. Pixels will only be read and decompressed when they are needed.

Load a formatted image from a stream This behaves exactly as .new_from_source, but the image is loaded from a stream rathar than from a source. Note: AT least libvips 8.9 is needed

Make a new temporary image. Returns an image backed by a temporary file. When written to with #write, a temporary file will be created on disc in the specified format. When the image is closed, the file will be deleted automatically.

The file is created in the temporary directory. This is set with the environment variable TMPDIR. If this is not set, then on Unix systems, vips will default to /tmp. On Windows, vips uses GetTempPath() to find the temporary director.

vips uses g_mkstemp() to make the temporary filename. They generally look something like vips-12-EJKFGH.v format is the format for the temp file, for example %s.v for a vips format file. The %s is subsituted by the file path.

Note: VipsException is raised, if unable to make temp file from format

Load an analyze6 image

# out_, flags = Vips::Image.analyzeload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Join an array of images

# out_ = Vips::Image.arrayjoin(in_, {across: Int32, shim: Int32, background: Array(Float64), halign: Enums::Align, valign: Enums::Align, hspacing: Int32, vspacing: Int32})

Input Parameters

Required

in : Array(Image) - Array of input images

Optionals

across : Int32 - Number of images across grid

shim : Int32 - Pixels between images

background : Array(Float64) - Colour for new pixels

halign : Enums::Align - Align on the left, centre or right

valign : Enums::Align - Align on the top, centre or bottom

hspacing : Int32 - Horizontal spacing between images

vspacing : Int32 - Vertical spacing between images

Returns

Output image

Make a black image

# out_ = Vips::Image.black(width, height, {bands: Int32})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

bands : Int32 - Number of bands in image

Returns

Output image

Load csv

# out_, flags = Vips::Image.csvload(filename, {skip: Int32, lines: Int32, whitespace: String, separator: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

skip : Int32 - Skip this many lines at the start of the file

lines : Int32 - Read this many lines from the file

whitespace : String - Set of whitespace characters

separator : String - Set of separator characters

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load csv

# out_, flags = Vips::Image.csvload_source(source, {skip: Int32, lines: Int32, whitespace: String, separator: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

skip : Int32 - Skip this many lines at the start of the file

lines : Int32 - Read this many lines from the file

whitespace : String - Set of whitespace characters

separator : String - Set of separator characters

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load csv

# out_, flags = Vips::Image.csvload_stream(stream, {skip: Int32, lines: Int32, whitespace: String, separator: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

skip : Int32 - Skip this many lines at the start of the file

lines : Int32 - Read this many lines from the file

whitespace : String - Set of whitespace characters

separator : String - Set of separator characters

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make an image showing the eye's spatial response

# out_ = Vips::Image.eye(width, height, {uchar: Bool, factor: Float64})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

uchar : Bool - Output an unsigned char image

factor : Float64 - Maximum spatial frequency

Returns

Output image

Find the name of the load operation vips will use to load a file. For example "VipsForeignLoadJpegFile". You can use this to work out what options to pass to .new_from_file

Find the name of the load operation vips will use to load a buffer. For example "VipsForeignLoadJpegBuffer". You can use this to work out what options to pass to .new_from_buffer

Find the name of the load operation vips will use to load a buffer. For example "VipsForeignLoadJpegBuffer". You can use this to work out what options to pass to .new_from_buffer

Find the name of the load operation vips will use to load a source. For example "VipsForeignLoadJpegSource". You can use this to work out what options to pass to .new_from_source

Find the name of the load operation vips will use to load a stream. For example "VipsForeignLoadJpegSource". You can use this to work out what options to pass to .new_from_stream

Load a fits image

# out_, flags = Vips::Image.fitsload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load fits from a source

# out_, flags = Vips::Image.fitsload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load fits from a stream

# out_, flags = Vips::Image.fitsload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a fractal surface

# out_ = Vips::Image.fractsurf(width, height, fractal_dimension)

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

fractal_dimension : Float64 - Fractal dimension

Returns

Output image

Make a gaussian image

# out_ = Vips::Image.gaussmat(sigma, min_ampl, {separable: Bool, precision: Enums::Precision})

Input Parameters

Required

sigma : Float64 - Sigma of Gaussian

min_ampl : Float64 - Minimum amplitude of Gaussian

Optionals

separable : Bool - Generate separable Gaussian

precision : Enums::Precision - Generate with this precision

Returns

Output image

Make a gaussnoise image

# out_ = Vips::Image.gaussnoise(width, height, {sigma: Float64, mean: Float64, seed: Int32})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

sigma : Float64 - Standard deviation of pixels in generated image

mean : Float64 - Mean of pixels in generated image

seed : Int32 - Random number seed

Returns

Output image

Load gif with libnsgif

# out_, flags = Vips::Image.gifload(filename, {n: Int32, page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

n : Int32 - Number of pages to load, -1 for all

page : Int32 - First page to load

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load gif with libnsgif

# out_, flags = Vips::Image.gifload_buffer(buffer, {n: Int32, page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

n : Int32 - Number of pages to load, -1 for all

page : Int32 - First page to load

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load gif from source

# out_, flags = Vips::Image.gifload_source(source, {n: Int32, page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

n : Int32 - Number of pages to load, -1 for all

page : Int32 - First page to load

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load gif from stream

# out_, flags = Vips::Image.gifload_stream(stream, {n: Int32, page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

n : Int32 - Number of pages to load, -1 for all

page : Int32 - First page to load

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a grey ramp image

# out_ = Vips::Image.grey(width, height, {uchar: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

uchar : Bool - Output an unsigned char image

Returns

Output image

Load a heif image

# out_, flags = Vips::Image.heifload(filename, {page: Int32, n: Int32, thumbnail: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

thumbnail : Bool - Fetch thumbnail image

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load a heif image

# out_, flags = Vips::Image.heifload_buffer(buffer, {page: Int32, n: Int32, thumbnail: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

thumbnail : Bool - Fetch thumbnail image

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load a heif image

# out_, flags = Vips::Image.heifload_source(source, {page: Int32, n: Int32, thumbnail: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

thumbnail : Bool - Fetch thumbnail image

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load a heif image

# out_, flags = Vips::Image.heifload_stream(stream, {page: Int32, n: Int32, thumbnail: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

thumbnail : Bool - Fetch thumbnail image

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a 1d image where pixel values are indexes

# out_ = Vips::Image.identity({bands: Int32, ushort: Bool, size: Int32})

Input Parameters

Optionals

bands : Int32 - Number of bands in LUT

ushort : Bool - Create a 16-bit LUT

size : Int32 - Size of 16-bit LUT

Returns

Output image

Load jpeg2000 image

# out_, flags = Vips::Image.jp2kload(filename, {page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

page : Int32 - Load this page from the image

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg2000 image

# out_, flags = Vips::Image.jp2kload_buffer(buffer, {page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

page : Int32 - Load this page from the image

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg2000 image

# out_, flags = Vips::Image.jp2kload_source(source, {page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

page : Int32 - Load this page from the image

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg2000 image

# out_, flags = Vips::Image.jp2kload_stream(stream, {page: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

page : Int32 - Load this page from the image

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg from file

# out_, flags = Vips::Image.jpegload(filename, {shrink: Int32, autorotate: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

shrink : Int32 - Shrink factor on load

autorotate : Bool - Rotate image using exif orientation

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg from buffer

# out_, flags = Vips::Image.jpegload_buffer(buffer, {shrink: Int32, autorotate: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

shrink : Int32 - Shrink factor on load

autorotate : Bool - Rotate image using exif orientation

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load image from jpeg source

# out_, flags = Vips::Image.jpegload_source(source, {shrink: Int32, autorotate: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

shrink : Int32 - Shrink factor on load

autorotate : Bool - Rotate image using exif orientation

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load image from jpeg stream

# out_, flags = Vips::Image.jpegload_stream(stream, {shrink: Int32, autorotate: Bool, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

shrink : Int32 - Shrink factor on load

autorotate : Bool - Rotate image using exif orientation

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg-xl image

# out_, flags = Vips::Image.jxlload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg-xl image

# out_, flags = Vips::Image.jxlload_buffer(buffer, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg-xl image

# out_, flags = Vips::Image.jxlload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load jpeg-xl image

# out_, flags = Vips::Image.jxlload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a laplacian of gaussian image

# out_ = Vips::Image.logmat(sigma, min_ampl, {separable: Bool, precision: Enums::Precision})

Input Parameters

Required

sigma : Float64 - Radius of Gaussian

min_ampl : Float64 - Minimum amplitude of Gaussian

Optionals

separable : Bool - Generate separable Gaussian

precision : Enums::Precision - Generate with this precision

Returns

Output image

Load file with imagemagick7

# out_, flags = Vips::Image.magickload(filename, {density: String, page: Int32, n: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

density : String - Canvas resolution for rendering vector formats like SVG

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load buffer with imagemagick7

# out_, flags = Vips::Image.magickload_buffer(buffer, {density: String, page: Int32, n: Int32, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

density : String - Canvas resolution for rendering vector formats like SVG

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a butterworth filter

# out_ = Vips::Image.mask_butterworth(width, height, order, frequency_cutoff, amplitude_cutoff, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

order : Float64 - Filter order

frequency_cutoff : Float64 - Frequency cutoff

amplitude_cutoff : Float64 - Amplitude cutoff

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make a butterworth_band filter

# out_ = Vips::Image.mask_butterworth_band(width, height, order, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

order : Float64 - Filter order

frequency_cutoff_x : Float64 - Frequency cutoff x

frequency_cutoff_y : Float64 - Frequency cutoff y

radius : Float64 - Radius of circle

amplitude_cutoff : Float64 - Amplitude cutoff

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make a butterworth ring filter

# out_ = Vips::Image.mask_butterworth_ring(width, height, order, frequency_cutoff, amplitude_cutoff, ringwidth, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

order : Float64 - Filter order

frequency_cutoff : Float64 - Frequency cutoff

amplitude_cutoff : Float64 - Amplitude cutoff

ringwidth : Float64 - Ringwidth

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make fractal filter

# out_ = Vips::Image.mask_fractal(width, height, fractal_dimension, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

fractal_dimension : Float64 - Fractal dimension

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make a gaussian filter

# out_ = Vips::Image.mask_gaussian(width, height, frequency_cutoff, amplitude_cutoff, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff : Float64 - Frequency cutoff

amplitude_cutoff : Float64 - Amplitude cutoff

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make a gaussian filter

# out_ = Vips::Image.mask_gaussian_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, amplitude_cutoff, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff_x : Float64 - Frequency cutoff x

frequency_cutoff_y : Float64 - Frequency cutoff y

radius : Float64 - Radius of circle

amplitude_cutoff : Float64 - Amplitude cutoff

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make a gaussian ring filter

# out_ = Vips::Image.mask_gaussian_ring(width, height, frequency_cutoff, amplitude_cutoff, ringwidth, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff : Float64 - Frequency cutoff

amplitude_cutoff : Float64 - Amplitude cutoff

ringwidth : Float64 - Ringwidth

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make an ideal filter

# out_ = Vips::Image.mask_ideal(width, height, frequency_cutoff, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff : Float64 - Frequency cutoff

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make an ideal band filter

# out_ = Vips::Image.mask_ideal_band(width, height, frequency_cutoff_x, frequency_cutoff_y, radius, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff_x : Float64 - Frequency cutoff x

frequency_cutoff_y : Float64 - Frequency cutoff y

radius : Float64 - Radius of circle

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Make an ideal ring filter

# out_ = Vips::Image.mask_ideal_ring(width, height, frequency_cutoff, ringwidth, {uchar: Bool, nodc: Bool, reject: Bool, optical: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

frequency_cutoff : Float64 - Frequency cutoff

ringwidth : Float64 - Ringwidth

Optionals

uchar : Bool - Output an unsigned char image

nodc : Bool - Remove DC component

reject : Bool - Invert the sense of the filter

optical : Bool - Rotate quadrants to optical space

Returns

Output image

Load mat from file

# out_, flags = Vips::Image.matload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load matrix

# out_, flags = Vips::Image.matrixload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load matrix

# out_, flags = Vips::Image.matrixload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load matrix

# out_, flags = Vips::Image.matrixload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load an openexr image

# out_, flags = Vips::Image.openexrload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load file with openslide

# out_, flags = Vips::Image.openslideload(filename, {level: Int32, autocrop: Bool, associated: String, attach_associated: Bool, rgb: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

level : Int32 - Load this level from the file

autocrop : Bool - Crop to image bounds

associated : String - Load this associated image

attach_associated : Bool - Attach all associated images

rgb : Bool - Output RGB (not RGBA)

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load source with openslide

# out_, flags = Vips::Image.openslideload_source(source, {level: Int32, autocrop: Bool, associated: String, attach_associated: Bool, rgb: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

level : Int32 - Load this level from the file

autocrop : Bool - Crop to image bounds

associated : String - Load this associated image

attach_associated : Bool - Attach all associated images

rgb : Bool - Output RGB (not RGBA)

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load stream with openslide

# out_, flags = Vips::Image.openslideload_stream(stream, {level: Int32, autocrop: Bool, associated: String, attach_associated: Bool, rgb: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

level : Int32 - Load this level from the file

autocrop : Bool - Crop to image bounds

associated : String - Load this associated image

attach_associated : Bool - Attach all associated images

rgb : Bool - Output RGB (not RGBA)

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load pdf from file

# out_, flags = Vips::Image.pdfload(filename, {page: Int32, n: Int32, dpi: Float64, scale: Float64, background: Array(Float64), password: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

dpi : Float64 - DPI to render at

scale : Float64 - Factor to scale by

background : Array(Float64) - Background colour

password : String - Password to decrypt with

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load pdf from buffer

# out_, flags = Vips::Image.pdfload_buffer(buffer, {page: Int32, n: Int32, dpi: Float64, scale: Float64, background: Array(Float64), password: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

dpi : Float64 - DPI to render at

scale : Float64 - Factor to scale by

background : Array(Float64) - Background colour

password : String - Password to decrypt with

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load pdf from source

# out_, flags = Vips::Image.pdfload_source(source, {page: Int32, n: Int32, dpi: Float64, scale: Float64, background: Array(Float64), password: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

dpi : Float64 - DPI to render at

scale : Float64 - Factor to scale by

background : Array(Float64) - Background colour

password : String - Password to decrypt with

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load pdf from stream

# out_, flags = Vips::Image.pdfload_stream(stream, {page: Int32, n: Int32, dpi: Float64, scale: Float64, background: Array(Float64), password: String, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

dpi : Float64 - DPI to render at

scale : Float64 - Factor to scale by

background : Array(Float64) - Background colour

password : String - Password to decrypt with

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a perlin noise image

# out_ = Vips::Image.perlin(width, height, {cell_size: Int32, uchar: Bool, seed: Int32})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

cell_size : Int32 - Size of Perlin cells

uchar : Bool - Output an unsigned char image

seed : Int32 - Random number seed

Returns

Output image

Load png from file

# out_, flags = Vips::Image.pngload(filename, {unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load png from buffer

# out_, flags = Vips::Image.pngload_buffer(buffer, {unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load png from source

# out_, flags = Vips::Image.pngload_source(source, {unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load png from stream

# out_, flags = Vips::Image.pngload_stream(stream, {unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

unlimited : Bool - Remove all denial of service limits

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load ppm from file

# out_, flags = Vips::Image.ppmload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load ppm base class

# out_, flags = Vips::Image.ppmload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load ppm base class

# out_, flags = Vips::Image.ppmload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load named icc profile

# profile = Vips::Image.profile_load(name)

Input Parameters

Required

name : String - Profile name

Returns

Loaded profile

Load a radiance image from a file

# out_, flags = Vips::Image.radload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load rad from buffer

# out_, flags = Vips::Image.radload_buffer(buffer, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load rad from source

# out_, flags = Vips::Image.radload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load rad from stream

# out_, flags = Vips::Image.radload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load raw data from a file

# out_, flags = Vips::Image.rawload(filename, width, height, bands, {offset: UInt32, format: Enums::BandFormat, interpretation: Enums::Interpretation, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

bands : Int32 - Number of bands in image

Optionals

offset : UInt32 - Offset in bytes from start of file

format : Enums::BandFormat - Pixel format in image

interpretation : Enums::Interpretation - Pixel interpretation

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

run a complex operation on a complex image, or an image with an even number of bands ... handy for things like running .polar on .index images

Make a 2d sine wave

# out_ = Vips::Image.sines(width, height, {uchar: Bool, hfreq: Float64, vfreq: Float64})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

uchar : Bool - Output an unsigned char image

hfreq : Float64 - Horizontal spatial frequency

vfreq : Float64 - Vertical spatial frequency

Returns

Output image

Sum an array of images

# out_ = Vips::Image.sum(in_)

Input Parameters

Required

in : Array(Image) - Array of input images

Returns

Output image

Load svg with rsvg

# out_, flags = Vips::Image.svgload(filename, {dpi: Float64, scale: Float64, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

dpi : Float64 - Render at this DPI

scale : Float64 - Scale output by this factor

unlimited : Bool - Allow SVG of any size

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load svg with rsvg

# out_, flags = Vips::Image.svgload_buffer(buffer, {dpi: Float64, scale: Float64, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

dpi : Float64 - Render at this DPI

scale : Float64 - Scale output by this factor

unlimited : Bool - Allow SVG of any size

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load svg from source

# out_, flags = Vips::Image.svgload_source(source, {dpi: Float64, scale: Float64, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

dpi : Float64 - Render at this DPI

scale : Float64 - Scale output by this factor

unlimited : Bool - Allow SVG of any size

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load svg from stream

# out_, flags = Vips::Image.svgload_stream(stream, {dpi: Float64, scale: Float64, unlimited: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

dpi : Float64 - Render at this DPI

scale : Float64 - Scale output by this factor

unlimited : Bool - Allow SVG of any size

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Find the index of the first non-zero pixel in tests

# out_ = Vips::Image.switch(tests)

Input Parameters

Required

tests : Array(Image) - Table of images to test

Returns

Output image

Run an external command

, out_, log = Vips::Image.system(cmd_format, {in_: Array(Image), out_format: String, in_format: String})

Input Parameters

Required

cmd_format : String - Command to run

Optionals

in : Array(Image) - Array of input images

out_format : String - Format for output filename

in_format : String - Format for input filename

Returns

Optionals

out : Image? - Output image

log : String? - Command log

Generate thumbnail from file

# out_ = Vips::Image.thumbnail(filename, width, {height: Int32, size: Enums::Size, no_rotate: Bool, crop: Enums::Interesting, linear: Bool, import_profile: String, export_profile: String, intent: Enums::Intent, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to read from

width : Int32 - Size to this width

Optionals

height : Int32 - Size to this height

size : Enums::Size - Only upsize, only downsize, or both

no_rotate : Bool - Don't use orientation tags to rotate image upright

crop : Enums::Interesting - Reduce to fill target rectangle, then crop

linear : Bool - Reduce in linear light

import_profile : String - Fallback import profile

export_profile : String - Fallback export profile

intent : Enums::Intent - Rendering intent

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Generate thumbnail from buffer

# out_ = Vips::Image.thumbnail_buffer(buffer, width, {option_string: String, height: Int32, size: Enums::Size, no_rotate: Bool, crop: Enums::Interesting, linear: Bool, import_profile: String, export_profile: String, intent: Enums::Intent, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

width : Int32 - Size to this width

Optionals

option_string : String - Options that are passed on to the underlying loader

height : Int32 - Size to this height

size : Enums::Size - Only upsize, only downsize, or both

no_rotate : Bool - Don't use orientation tags to rotate image upright

crop : Enums::Interesting - Reduce to fill target rectangle, then crop

linear : Bool - Reduce in linear light

import_profile : String - Fallback import profile

export_profile : String - Fallback export profile

intent : Enums::Intent - Rendering intent

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Generate thumbnail from source

# out_ = Vips::Image.thumbnail_source(source, width, {option_string: String, height: Int32, size: Enums::Size, no_rotate: Bool, crop: Enums::Interesting, linear: Bool, import_profile: String, export_profile: String, intent: Enums::Intent, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

width : Int32 - Size to this width

Optionals

option_string : String - Options that are passed on to the underlying loader

height : Int32 - Size to this height

size : Enums::Size - Only upsize, only downsize, or both

no_rotate : Bool - Don't use orientation tags to rotate image upright

crop : Enums::Interesting - Reduce to fill target rectangle, then crop

linear : Bool - Reduce in linear light

import_profile : String - Fallback import profile

export_profile : String - Fallback export profile

intent : Enums::Intent - Rendering intent

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Generate thumbnail from stream

# out_ = Vips::Image.thumbnail_stream(stream, width, {option_string: String, height: Int32, size: Enums::Size, no_rotate: Bool, crop: Enums::Interesting, linear: Bool, import_profile: String, export_profile: String, intent: Enums::Intent, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from

width : Int32 - Size to this width Optionals

option_string : String - Options that are passed on to the underlying loader

height : Int32 - Size to this height

size : Enums::Size - Only upsize, only downsize, or both

no_rotate : Bool - Don't use orientation tags to rotate image upright

crop : Enums::Interesting - Reduce to fill target rectangle, then crop

linear : Bool - Reduce in linear light

import_profile : String - Fallback import profile

export_profile : String - Fallback export profile

intent : Enums::Intent - Rendering intent

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

Load tiff from file

# out_, flags = Vips::Image.tiffload(filename, {page: Int32, subifd: Int32, n: Int32, autorotate: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

page : Int32 - First page to load

subifd : Int32 - Subifd index

n : Int32 - Number of pages to load, -1 for all

autorotate : Bool - Rotate image using orientation tag

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load tiff from buffer

# out_, flags = Vips::Image.tiffload_buffer(buffer, {page: Int32, subifd: Int32, n: Int32, autorotate: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

page : Int32 - First page to load

subifd : Int32 - Subifd index

n : Int32 - Number of pages to load, -1 for all

autorotate : Bool - Rotate image using orientation tag

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load tiff from source

# out_, flags = Vips::Image.tiffload_source(source, {page: Int32, subifd: Int32, n: Int32, autorotate: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

page : Int32 - First page to load

subifd : Int32 - Subifd index

n : Int32 - Number of pages to load, -1 for all

autorotate : Bool - Rotate image using orientation tag

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load tiff from stream

# out_, flags = Vips::Image.tiffload_stream(stream, {page: Int32, subifd: Int32, n: Int32, autorotate: Bool, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

page : Int32 - First page to load

subifd : Int32 - Subifd index

n : Int32 - Number of pages to load, -1 for all

autorotate : Bool - Rotate image using orientation tag

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Build a look-up table

# out_ = Vips::Image.tonelut({in_max: Int32, out_max: Int32, lb: Float64, lw: Float64, ps: Float64, pm: Float64, ph: Float64, s: Float64, m: Float64, h: Float64})

Input Parameters

Optionals

in_max : Int32 - Size of LUT to build

out_max : Int32 - Maximum value in output LUT

lb : Float64 - Lowest value in output

lw : Float64 - Highest value in output

ps : Float64 - Position of shadow

pm : Float64 - Position of mid-tones

ph : Float64 - Position of highlights

s : Float64 - Adjust shadows by this much

m : Float64 - Adjust mid-tones by this much

h : Float64 - Adjust highlights by this much

Returns

Output image

Load vips from file

# out_, flags = Vips::Image.vipsload(filename, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load vips from source

# out_, flags = Vips::Image.vipsload_source(source, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load vips from stream

# out_, flags = Vips::Image.vipsload_stream(stream, {memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load webp from file

# out_, flags = Vips::Image.webpload(filename, {page: Int32, n: Int32, scale: Float64, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

filename : String - Filename to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

scale : Float64 - Factor to scale by

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load webp from buffer

# out_, flags = Vips::Image.webpload_buffer(buffer, {page: Int32, n: Int32, scale: Float64, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

buffer : Bytes - Buffer to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

scale : Float64 - Factor to scale by

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load webp from source

# out_, flags = Vips::Image.webpload_source(source, {page: Int32, n: Int32, scale: Float64, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

source : Source - Source to load from

Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

scale : Float64 - Factor to scale by

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

Output image

Optionals

flags : Enums::ForeignFlags? - Flags for this file

Load webp from stream

# out_, flags = Vips::Image.webpload_stream(stream, {page: Int32, n: Int32, scale: Float64, memory: Bool, access: Enums::Access, fail_on: Enums::FailOn})

Input Parameters

Required

stream : IO - Stream to load from Optionals

page : Int32 - First page to load

n : Int32 - Number of pages to load, -1 for all

scale : Float64 - Factor to scale by

memory : Bool - Force open via memory

access : Enums::Access - Required access pattern for this file

fail_on : Enums::FailOn - Error level to fail on

Returns

out : Image - Output image Optionals

flags : Enums::ForeignFlags? - Flags for this file

Make a worley noise image

# out_ = Vips::Image.worley(width, height, {cell_size: Int32, seed: Int32})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

cell_size : Int32 - Size of Worley cells

seed : Int32 - Random number seed

Returns

Output image

Make an image where pixel values are coordinates

# out_ = Vips::Image.xyz(width, height, {csize: Int32, dsize: Int32, esize: Int32})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

csize : Int32 - Size of third dimension

dsize : Int32 - Size of fourth dimension

esize : Int32 - Size of fifth dimension

Returns

Output image

Make a zone plate

# out_ = Vips::Image.zone(width, height, {uchar: Bool})

Input Parameters

Required

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

Optionals

uchar : Bool - Output an unsigned char image

Returns

Output image

Returns true if this object is not equal to other.

By default this method is implemented as !(self == other) so there's no need to override this unless there's a more efficient way to do it.

Raise to the power of an image

Raise to the power of a constant or an array of constants

Arc tangent of a constant or an array of constants in degrees

Returns false (other can only be a Value here).

A synonym for #getpoint

pull out band elements from an image

Fetch bands using a range

Return the inverse hyperbolic cosine of an image in degrees.

Return the inverse hyperbolic sine of an image in degrees.

Arc tangent of an image in degrees.

Return the inverse hyperbolic tangent of an image in degrees.

Absolute value of an image

# out_ = in.abs()

Returns

Output image

Return the inverse cosine of an image in degrees.

Add two images

# out_ = left.add(right)

Input Parameters

Required

right : Image - Right-hand image argument

Returns

Output image

Append an alpha channel to an image.

Affine transform of an image

# out_ = in.affine(matrix, {interpolate: Interpolate, oarea: Array(Int32), odx: Float64, ody: Float64, idx: Float64, idy: Float64, background: Array(Float64), premultiplied: Bool, extend: Enums::Extend})

Input Parameters

Required

matrix : Array(Float64) - Transformation matrix

Optionals

interpolate : Interpolate - Interpolate pixels with this

oarea : Array(Int32) - Area of output to generate

odx : Float64 - Horizontal output displacement

ody : Float64 - Vertical output displacement

idx : Float64 - Horizontal input displacement

idy : Float64 - Vertical input displacement

background : Array(Float64) - Background value

premultiplied : Bool - Images have premultiplied alpha

extend : Enums::Extend - How to generate the extra pixels

Returns

Output image

Return the inverse sine of an image in degrees.

Return the inverse tangent of an image in degrees.

Autorotate image by exif tag

# out_, angle, flip = in.autorot()

Returns

Output image

Optionals

angle : Enums::Angle? - Angle image was rotated by

flip : Bool? - Whether the image was flipped or not

Find image average

# out_ = in.avg()

Returns

Output value

Does band exist in image.

AND the bands of an image together

Boolean operation across image bands

# out_ = in.bandbool(boolean)

Input Parameters

Required

boolean : Enums::OperationBoolean - Boolean to perform

Returns

Output image

EOR the bands of an image together

Fold up x axis into bands

# out_ = in.bandfold({factor: Int32})

Input Parameters

Optionals

factor : Int32 - Fold by this factor

Returns

Output image

Append a set of constants bandwise

Append a set of constants bandwise

Append a set of images bandwise

Append a set of mixed images and constants bandwise

Append a constant band to an image

# out_ = in.bandjoin_const(c)

Input Parameters

Required

c : Array(Float64) - Array of constants to add

Returns

Output image

Band-wise average

# out_ = in.bandmean()

Returns

Output image

OR the bands of an image together

Band-wise rank a set of constants.

Optionals

index : Int32 - Select this band element from sorted list

Band-wise rank a set of constants.

Optionals

index : Int32 - Select this band element from sorted list

Band-wise rank a set of images.

Optionals

index : Int32 - Select this band element from sorted list

Band-wise rank a set of mixed images and constants.

Optionals

index : Int32 - Select this band element from sorted list

Number of bands in image

Split an n-band image into n separate images.

Unfold image bands into x axis

# out_ = in.bandunfold({factor: Int32})

Input Parameters

Optionals

factor : Int32 - Unfold by this factor

Returns

Output image

Boolean operation on two images

# out_ = left.boolean(right, boolean)

Input Parameters

Required

right : Image - Right-hand image argument

boolean : Enums::OperationBoolean - Boolean to perform

Returns

Output image

Boolean operations against a constant

# out_ = in.boolean_const(boolean, c)

Input Parameters

Required

boolean : Enums::OperationBoolean - Boolean to perform

c : Array(Float64) - Array of constants

Returns

Output image

Build a look-up table

# out_ = in.buildlut()

Returns

Output image

Byteswap an image

# out_ = in.byteswap()

Returns

Output image

Cache an image

# out_ = in.cache({max_tiles: Int32, tile_height: Int32, tile_width: Int32})

Input Parameters

Optionals

max_tiles : Int32 - Maximum number of tiles to cache

tile_height : Int32 - Tile height in pixels

tile_width : Int32 - Tile width in pixels

Returns

Output image

Canny edge detector

# out_ = in.canny({sigma: Float64, precision: Enums::Precision})

Input Parameters

Optionals

sigma : Float64 - Sigma of Gaussian

precision : Enums::Precision - Convolve with this precision

Returns

Output image

Use pixel values to pick cases from an array of constants

Use pixel values to pick cases from an array of constants

Use pixel values to pick cases from an array of images.

Use pixel values to pick cases from an a set of mixed images and constants.

Cast an image

# out_ = in.cast(format, {shift: Bool})

Input Parameters

Required

format : Enums::BandFormat - Format to cast to

Optionals

shift : Bool - Shift integer values up and down

Returns

Output image

Return the smallest integral value not less than the argument.

Transform lch to cmc

# out_ = in.cmc2lch()

Returns

Output image

Transform cmyk to xyz

# out_ = in.cmyk2xyz()

Returns

Output image

Pixel coding

Convert to a new colorspace

# out_ = in.colourspace(space, {source_space: Enums::Interpretation})

Input Parameters

Required

space : Enums::Interpretation - Destination color space

Optionals

source_space : Enums::Interpretation - Source color space

Returns

Output image

Convolve with rotating mask

# out_ = in.compass(mask, {times: Int32, angle: Enums::Angle45, combine: Enums::Combine, precision: Enums::Precision, layers: Int32, cluster: Int32})

Input Parameters

Required

mask : Image - Input matrix image

Optionals

times : Int32 - Rotate and convolve this many times

angle : Enums::Angle45 - Rotate mask by this much between convolutions

combine : Enums::Combine - Combine convolution results like this

precision : Enums::Precision - Convolve with this precision

layers : Int32 - Use this many layers in approximation

cluster : Int32 - Cluster lines closer than this in approximation

Returns

Output image

Perform a complex operation on an image

# out_ = in.complex(cmplx)

Input Parameters

Required

cmplx : Enums::OperationComplex - Complex to perform

Returns

Output image

Complex binary operations on two images

# out_ = left.complex2(right, cmplx)

Input Parameters

Required

right : Image - Right-hand image argument

cmplx : Enums::OperationComplex2 - Binary complex operation to perform

Returns

Output image

Form a complex image from two real images

# out_ = left.complexform(right)

Input Parameters

Required

right : Image - Right-hand image argument

Returns

Output image

Get a component from a complex image

# out_ = in.complexget(get)

Input Parameters

Required

get : Enums::OperationComplexget - Complex to perform

Returns

Output image

Blend an array of images with an array of blend modes

# out_ = Vips::Image.composite(images, modes, {x: Array(Int32), y: Array(Int32), compositing_space: Enums::Interpretation, premultiplied: Bool})

Input Parameters

Required

images : Array(Image) - Array of input images

modes : Array(Enums::BlendMode) - Array of Enums::BlendMode to join with

Optionals

x : Array(Int32) - Array of x coordinates to join at

y : Array(Int32) - Array of y coordinates to join at

compositing_space : Enums::Interpretation - Composite images in this colour space

premultiplied : Bool - Images have premultiplied alpha

Returns

Output Image

A synonym for #composite2

# out_ = Vips::Image.composite(overlay, mode, {x: Array(Int32), y: Array(Int32), compositing_space: Enums::Interpretation, premultiplied: Bool})

Input Parameters

Required

overlay : Image - Overlay image

*modes : Enums::BlendMode - VipsBlendMode to join with

Optionals

x : Int32 - x position of overlay

y : Int32 - y position of overlay

compositing_space : Enums::Interpretation - Composite images in this colour space

premultiplied : Bool - Images have premultiplied alpha

Returns

Output image

Blend a pair of images with a blend mode

# out_ = base.composite2(overlay, mode, {x: Int32, y: Int32, compositing_space: Enums::Interpretation, premultiplied: Bool})

Input Parameters

Required

overlay : Image - Overlay image

mode : Enums::BlendMode - VipsBlendMode to join with

Optionals

x : Int32 - x position of overlay

y : Int32 - y position of overlay

compositing_space : Enums::Interpretation - Composite images in this colour space

premultiplied : Bool - Images have premultiplied alpha

Returns

Output image

Return the complex conjugate of an image.

Check if the underlying image contains an property of metadata.

Convolution operation

# out_ = in.conv(mask, {precision: Enums::Precision, layers: Int32, cluster: Int32})

Input Parameters

Required

mask : Image - Input matrix image

Optionals

precision : Enums::Precision - Convolve with this precision

layers : Int32 - Use this many layers in approximation

cluster : Int32 - Cluster lines closer than this in approximation

Returns

Output image

Approximate integer convolution

# out_ = in.conva(mask, {layers: Int32, cluster: Int32})

Input Parameters

Required

mask : Image - Input matrix image

Optionals

layers : Int32 - Use this many layers in approximation

cluster : Int32 - Cluster lines closer than this in approximation

Returns

Output image

Approximate separable integer convolution

# out_ = in.convasep(mask, {layers: Int32})

Input Parameters

Required

mask : Image - Input matrix image

Optionals

layers : Int32 - Use this many layers in approximation

Returns

Output image

Float convolution operation

# out_ = in.convf(mask)

Input Parameters

Required

mask : Image - Input matrix image

Returns

Output image

Int convolution operation

# out_ = in.convi(mask)

Input Parameters

Required

mask : Image - Input matrix image

Returns

Output image

Seperable convolution operation

# out_ = in.convsep(mask, {precision: Enums::Precision, layers: Int32, cluster: Int32})

Input Parameters

Required

mask : Image - Input matrix image

Optionals

precision : Enums::Precision - Convolve with this precision

layers : Int32 - Use this many layers in approximation

cluster : Int32 - Cluster lines closer than this in approximation

Returns

Output image

Copy an image

# out_ = in.copy({width: Int32, height: Int32, bands: Int32, format: Enums::BandFormat, coding: Enums::Coding, interpretation: Enums::Interpretation, xres: Float64, yres: Float64, xoffset: Int32, yoffset: Int32})

Input Parameters

Optionals

width : Int32 - Image width in pixels

height : Int32 - Image height in pixels

bands : Int32 - Number of bands in image

format : Enums::BandFormat - Pixel format in image

coding : Enums::Coding - Pixel coding

interpretation : Enums::Interpretation - Pixel interpretation

xres : Float64 - Horizontal resolution in pixels/mm

yres : Float64 - Vertical resolution in pixels/mm

xoffset : Int32 - Horizontal offset of origin

yoffset : Int32 - Vertical offset of origin

Returns

Output image

Copy an image to a memory area.

This can be useful for reusing results, but can obviously use a lot of memory for large images. See {Image#tilecache} for a way of caching parts of an image.

Returns new memory Image

Return the cosine of an image in degrees.

Return the hyperbolic cosine of an image in degrees.

Count lines in an image

# nolines = in.countlines(direction)

Input Parameters

Required

direction : Enums::Direction - Countlines left-right or up-down

Returns

Number of lines

A synonym for #extract_area

Save image to csv

in.csvsave(filename, {separator: String, strip: Bool, background: Array(Float64), page_height: Int32})

Input Parameters

Required

filename : String - Filename to save to

Optionals

separator : String - Separator characters

strip : Bool - Strip all metadata from image

background : Array(Float64) - Background value

page_height : Int32 - Set page height for multipage save

Save image to csv

in.csvsave_stream(stream, {separator: String, strip: Bool, background: Array(Float64), page_height: Int32})

Input Parameters

Required

stream : IO - Stream to save to Optionals

separator : String - Separator characters

strip : Bool - Strip all metadata from image

background : Array(Float64) - Background value

page_height : Int32 - Set page height for multipage save