Image.Math (image v0.59.3)

View Source

Implements math operators for images, delegating to the Kernel functions in the cases where the parameters do not include Vix.Vips.Image.t/0.

To override the standard operations in a function or module, add use Image.Math.

To maximise readability and clarity it is recommended that use Image.Math be added to only those functions that require it.

Example 

defmodule MyModule do
  # Not recommended
  use Image.Math

  def my_function(%Vix.Vips.Image{} = image) do
    # Recommended
    use Image.Math

    # Increase the all bands by 20%
    brigher = image * 1.2

    # Or adjust only green by 20%
    bright_green = image * [1, 1.2, 1]
  end
end

Summary

Functions

a &&& b

Matrix bitwise 'and' of two images.

a ** b

Matrix exponent of two images or one image and a constant or vector.

a * b

Matrix multiplation of two images or one image and a constant or vector.

a + b

Matrix addition of two images or one image and a constant or vector.

-a

Matrix unary minues of an image or a number.

a - b

Matrix subtraction of two images or one image and a constant or vector.

a / b

Matrix division of two images or one image and a constant or vector.

a != b

Matrix inequality of two images or one image and a constant or vector.

a < b

Matrix less than of two images or one image and a constant or vector.

a <<< b

Matrix bitwise 'left shift' of two images.

a <= b

Matrix less than or equal of two images or one image and a constant or vector.

a == b

Matrix equality of two images or one image and a constant or vector.

a > b

Matrix greater than of two images or one image and a constant or vector.

a >= b

Matrix greater than or equal of two images or one image and a constant or vector.

a >>> b

Matrix bitwise 'right shift' of two images.

abs(image)
abs!(image)
add(image, image2)
add!(image, value)
boolean_and(image_1, image_2)
boolean_and!(image_1, image_2)
boolean_lshift(image_1, image_2)
boolean_lshift!(image_1, image_2)
boolean_or(image_1, image_2)
boolean_or!(image_1, image_2)
boolean_rshift(image_1, image_2)
boolean_rshift!(image_1, image_2)
boolean_xor(image_1, image_2)
boolean_xor!(image_1, image_2)
cos(image)
cos!(image)
divide(image, image2)
divide!(image, value)
equal(image, other)
equal!(image, value)
exp(image)
exp!(image)
greater_than(image, other)
greater_than!(image, value)
greater_than_or_equal(image, other)
greater_than_or_equal!(image, value)
is_pixel(value)

Guards if a given value might be reasonably interpreted as a pixel.

less_than(image, other)
less_than!(image, value)
less_than_or_equal(image, other)
less_than_or_equal!(image, value)
max(image)
max!(image)
maxpos(image, options \\ [])

Return the image maximum.

min(image)
min!(image)
minpos(image, options \\ [])

Return the image minimum.

multiply(image, image2)
multiply!(image, value)
not_equal(image, other)
not_equal!(image, value)
pow(image, image2)
pow!(image, value)
sin(image)
sin!(image)
subtract(image, image2)
subtract!(image, value)
a ||| b

Matrix bitwise 'or' of two images.

Functions

a &&& b

Matrix bitwise 'and' of two images.

a ** b

Matrix exponent of two images or one image and a constant or vector.

Delegates to Kernel.**/2 if none of the parameters is a Vix.Vips.Image.t/0.

a * b

Matrix multiplation of two images or one image and a constant or vector.

Delegates to Kernel.*/2 if none of the parameters is a Vix.Vips.Image.t/0.

a + b

Matrix addition of two images or one image and a constant or vector.

Delegates to Kernel.+/2 if none of the parameters is a Vix.Vips.Image.t/0.

-a

Matrix unary minues of an image or a number.

a - b

Matrix subtraction of two images or one image and a constant or vector.

Delegates to Kernel.-/2 if none of the parameters is a Vix.Vips.Image.t/0.

a / b

Matrix division of two images or one image and a constant or vector.

Delegates to Kernel.//2 if none of the parameters is a Vix.Vips.Image.t/0.

a != b

Matrix inequality of two images or one image and a constant or vector.

Delegates to Kernel.!=/2 if none of the parameters is a Vix.Vips.Image.t/0.

a < b

Matrix less than of two images or one image and a constant or vector.

Delegates to Kernel.</2 if none of the parameters is a Vix.Vips.Image.t/0.

a <<< b

Matrix bitwise 'left shift' of two images.

a <= b

Matrix less than or equal of two images or one image and a constant or vector.

Delegates to Kernel.<=/2 if none of the parameters is a Vix.Vips.Image.t/0.

a == b

Matrix equality of two images or one image and a constant or vector.

Delegates to Kernel.==/2 if none of the parameters is a Vix.Vips.Image.t/0.

a > b

Matrix greater than of two images or one image and a constant or vector.

Delegates to Kernel.>/2 if none of the parameters is a Vix.Vips.Image.t/0.

a >= b

Matrix greater than or equal of two images or one image and a constant or vector.

Delegates to Kernel.>=/2 if none of the parameters is a Vix.Vips.Image.t/0.

a >>> b

Matrix bitwise 'right shift' of two images.

abs(image)

@spec abs(Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec abs(number()) :: {:ok, number()}

abs!(image)

@spec abs!(Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()

add(image, image2)

@spec add(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec add(Vix.Vips.Image.t(), number()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec add(Vix.Vips.Image.t(), [number(), ...]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec add(number(), number()) :: {:ok, number()}

add!(image, value)

@spec add!(Vix.Vips.Image.t(), Image.pixel() | number()) ::
  Vix.Vips.Image.t() | no_return()
@spec add!(Image.pixel() | number(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()
@spec add!(number(), number()) :: number() | no_return()

boolean_and(image_1, image_2)

@spec boolean_and(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

boolean_and!(image_1, image_2)

@spec boolean_and!(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()

boolean_lshift(image_1, image_2)

@spec boolean_lshift(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

boolean_lshift!(image_1, image_2)

@spec boolean_lshift!(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()

boolean_or(image_1, image_2)

@spec boolean_or(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

boolean_or!(image_1, image_2)

@spec boolean_or!(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()

boolean_rshift(image_1, image_2)

@spec boolean_rshift(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

boolean_rshift!(image_1, image_2)

@spec boolean_rshift!(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()

boolean_xor(image_1, image_2)

@spec boolean_xor(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

boolean_xor!(image_1, image_2)

@spec boolean_xor!(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()

cos(image)

@spec cos(Vix.Vips.Image.t()) :: {:ok, Vix.Vips.Image.t()}
@spec cos(number()) :: {:ok, number()}

cos!(image)

@spec cos!(Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()

divide(image, image2)

@spec divide(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec divide(Vix.Vips.Image.t(), number()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec divide(number(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec divide(Vix.Vips.Image.t(), [number()]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec divide(number(), number()) :: {:ok, number()}

divide!(image, value)

@spec divide!(Vix.Vips.Image.t(), Image.pixel()) :: Vix.Vips.Image.t() | no_return()
@spec divide!(Image.pixel(), Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()
@spec divide!(number(), number()) :: number() | no_return()

equal(image, other)

@spec equal(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec equal(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

equal!(image, value)

@spec equal!(Vix.Vips.Image.t(), Image.pixel()) :: Vix.Vips.Image.t() | no_return()
@spec equal!(number(), number()) :: number() | no_return()

exp(image)

@spec exp(Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

exp!(image)

@spec exp!(Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()

greater_than(image, other)

@spec greater_than(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec greater_than(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

greater_than!(image, value)

@spec greater_than!(Vix.Vips.Image.t(), Vix.Vips.Image.t() | Image.pixel()) ::
  Vix.Vips.Image.t() | no_return()
@spec greater_than!(number(), number()) :: number() | no_return()

greater_than_or_equal(image, other)

@spec greater_than_or_equal(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec greater_than_or_equal(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

greater_than_or_equal!(image, value)

@spec greater_than_or_equal!(Vix.Vips.Image.t(), Image.pixel()) ::
  Vix.Vips.Image.t() | no_return()
@spec greater_than_or_equal!(number(), number()) :: number() | no_return()

is_pixel(value)

(macro)

Guards if a given value might be reasonably interpreted as a pixel.

less_than(image, other)

@spec less_than(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec less_than(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

less_than!(image, value)

@spec less_than!(Vix.Vips.Image.t(), Vix.Vips.Image.t() | Image.pixel()) ::
  Vix.Vips.Image.t() | no_return()
@spec less_than!(number(), number()) :: number() | no_return()

less_than_or_equal(image, other)

@spec less_than_or_equal(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec less_than_or_equal(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

less_than_or_equal!(image, value)

@spec less_than_or_equal!(Vix.Vips.Image.t(), Vix.Vips.Image.t() | Image.pixel()) ::
  Vix.Vips.Image.t() | no_return()
@spec less_than_or_equal!(number(), number()) :: number() | no_return()

max(image)

@spec max(Vix.Vips.Image.t()) :: {:ok, float()} | {:error, Image.error_message()}

max!(image)

@spec max!(Vix.Vips.Image.t()) :: float() | no_return()

maxpos(image, options \\ [])

@spec maxpos(Vix.Vips.Image.t(), Keyword.t()) ::
  {maximum :: float(), x_positiom :: integer(), y_position :: integer()}

Return the image maximum.

Arguments

Options

  • :size is the number of maximums to find. The default is 10.

Returns

  • {:ok, maximum, x_position, y_position}

min(image)

@spec min(Vix.Vips.Image.t()) :: {:ok, float()} | {:error, Image.error_message()}

min!(image)

@spec min!(Vix.Vips.Image.t()) :: float() | no_return()

minpos(image, options \\ [])

@spec minpos(Vix.Vips.Image.t(), Keyword.t()) ::
  {minimum :: float(), x_positiom :: integer(), y_position :: integer()}

Return the image minimum.

Arguments

Options

  • :size is the number of minimums to find. The default is 10.

Returns

  • {:ok, minimum, x_position, y_position}

multiply(image, image2)

@spec multiply(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec multiply(Vix.Vips.Image.t(), number()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec multiply(number(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec multiply(Vix.Vips.Image.t(), list()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec multiply(number(), number()) :: {:ok, number()}

multiply!(image, value)

@spec multiply!(Vix.Vips.Image.t(), Image.pixel() | number()) ::
  Vix.Vips.Image.t() | no_return()
@spec multiply!(Image.pixel() | number(), Vix.Vips.Image.t()) ::
  Vix.Vips.Image.t() | no_return()
@spec multiply!(number(), number()) :: number() | no_return()

not_equal(image, other)

@spec not_equal(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec not_equal(Vix.Vips.Image.t(), Image.pixel()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}

not_equal!(image, value)

@spec not_equal!(Vix.Vips.Image.t(), Image.pixel()) ::
  Vix.Vips.Image.t() | no_return()
@spec not_equal!(number(), number()) :: number() | no_return()

pow(image, image2)

@spec pow(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec pow(Vix.Vips.Image.t(), number()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec pow(number(), number()) :: {:ok, number()}

pow!(image, value)

@spec pow!(Vix.Vips.Image.t(), number()) :: Vix.Vips.Image.t() | no_return()
@spec pow!(number(), number()) :: number() | no_return()

sin(image)

@spec sin(Vix.Vips.Image.t()) :: {:ok, Vix.Vips.Image.t()}
@spec sin(number()) :: {:ok, number()}

sin!(image)

@spec sin!(Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()

subtract(image, image2)

@spec subtract(Vix.Vips.Image.t(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec subtract(Vix.Vips.Image.t(), number()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec subtract(Vix.Vips.Image.t(), [number()]) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec subtract(number(), Vix.Vips.Image.t()) ::
  {:ok, Vix.Vips.Image.t()} | {:error, Image.error_message()}
@spec subtract(number(), number()) :: {:ok, number()}

subtract!(image, value)

@spec subtract!(Vix.Vips.Image.t(), Image.pixel()) :: Vix.Vips.Image.t() | no_return()
@spec subtract!(Image.pixel(), Vix.Vips.Image.t()) :: Vix.Vips.Image.t() | no_return()
@spec subtract!(number(), number()) :: number() | no_return()

a ||| b

Matrix bitwise 'or' of two images.