View Source Evision.UMat (Evision v0.2.9)

Summary

Types

t()

Type that represents an UMat struct.

Functions

context()

context

context(named_args)

get(named_args)

get

get_offset(self)

handle(named_args)

handle(self, accessFlags)

handle

isContinuous(named_args)

isContinuous

isSubmatrix(named_args)

isSubmatrix

queue()

queue

queue(named_args)

set_offset(self, prop)

uMat()

UMat

uMat(named_args)

Variant 1:

UMat

uMat(m, ranges)

Variant 1:

UMat

uMat(m, rowRange, opts)

Variant 1:

UMat

uMat(size, type, s, opts)

Variant 1:

UMat

uMat(rows, cols, type, s, opts)

UMat

Types

t()

@type t() :: %Evision.UMat{ref: reference()}

Type that represents an UMat struct.

ref. reference()
The underlying erlang resource variable.

Functions

context()

@spec context() :: :ok | {:error, String.t()}

context

Return

retval: void*

Python prototype (for reference only):

context() -> retval

context(named_args)

@spec context(Keyword.t()) :: any() | {:error, String.t()}

get(named_args)

@spec get(Keyword.t()) :: any() | {:error, String.t()}

@spec get(Evision.Mat.t()) :: Evision.Mat.t() | {:error, String.t()}

get

Positional Arguments

self: Evision.UMat.t()

Return

retval: Evision.Mat.t()

Python prototype (for reference only):

get() -> retval

get_offset(self)

@spec get_offset(Evision.Mat.maybe_mat_in()) :: integer()

handle(named_args)

@spec handle(Keyword.t()) :: any() | {:error, String.t()}

handle(self, accessFlags)

@spec handle(Evision.Mat.t(), Evision.AccessFlag.enum()) :: :ok | {:error, String.t()}

handle

Positional Arguments

self: Evision.UMat.t()
accessFlags: AccessFlag

Return

retval: void*

Python prototype (for reference only):

handle(accessFlags) -> retval

isContinuous(named_args)

@spec isContinuous(Keyword.t()) :: any() | {:error, String.t()}

@spec isContinuous(Evision.Mat.t()) :: boolean() | {:error, String.t()}

isContinuous

Positional Arguments

self: Evision.UMat.t()

Return

retval: bool

Python prototype (for reference only):

isContinuous() -> retval

isSubmatrix(named_args)

@spec isSubmatrix(Keyword.t()) :: any() | {:error, String.t()}

@spec isSubmatrix(Evision.Mat.t()) :: boolean() | {:error, String.t()}

isSubmatrix

Positional Arguments

self: Evision.UMat.t()

Return

retval: bool

Python prototype (for reference only):

isSubmatrix() -> retval

queue()

@spec queue() :: :ok | {:error, String.t()}

queue

Return

retval: void*

Python prototype (for reference only):

queue() -> retval

queue(named_args)

@spec queue(Keyword.t()) :: any() | {:error, String.t()}

set_offset(self, prop)

@spec set_offset(Evision.Mat.maybe_mat_in(), integer()) :: Evision.Mat.t()

uMat()

@spec uMat() :: Evision.Mat.t() | {:error, String.t()}

UMat

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat([, usageFlags]) -> <UMat object>

uMat(named_args)

@spec uMat(Keyword.t()) :: any() | {:error, String.t()}

@spec uMat([{:usageFlags, term()}] | nil) :: Evision.Mat.t() | {:error, String.t()}

@spec uMat(Evision.Mat.maybe_mat_in()) :: Evision.Mat.t() | {:error, String.t()}

Variant 1:

UMat

Positional Arguments

m: Evision.Mat

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(m) -> <UMat object>

Variant 2:

UMat

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat([, usageFlags]) -> <UMat object>

uMat(m, ranges)

@spec uMat(Evision.Mat.maybe_mat_in(), [{integer(), integer()} | :all]) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(Evision.Mat.maybe_mat_in(), {number(), number(), number(), number()}) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(Evision.Mat.maybe_mat_in(), {integer(), integer()} | :all) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(
  {number(), number()},
  integer()
) :: Evision.Mat.t() | {:error, String.t()}

Variant 1:

UMat

Positional Arguments

m: Evision.Mat
ranges: [Range]

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(m, ranges) -> <UMat object>

Variant 2:

UMat

Positional Arguments

m: Evision.Mat
roi: Rect

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(m, roi) -> <UMat object>

Variant 3:

UMat

Positional Arguments

m: Evision.Mat
rowRange: Range

Keyword Arguments

colRange: Range.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(m, rowRange[, colRange]) -> <UMat object>

Variant 4:

UMat

Positional Arguments

size: Size
type: integer()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(size, type[, usageFlags]) -> <UMat object>

uMat(m, rowRange, opts)

@spec uMat(
  Evision.Mat.maybe_mat_in(),
  {integer(), integer()} | :all,
  [{:colRange, term()}] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat({number(), number()}, integer(), [{:usageFlags, term()}] | nil) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat({number(), number()}, integer(), Evision.scalar()) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(integer(), integer(), integer()) :: Evision.Mat.t() | {:error, String.t()}

Variant 1:

UMat

Positional Arguments

size: Size
type: integer()
s: Evision.scalar()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(size, type, s[, usageFlags]) -> <UMat object>

Variant 2:

UMat

Positional Arguments

rows: integer()
cols: integer()
type: integer()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(rows, cols, type[, usageFlags]) -> <UMat object>

Variant 3:

UMat

Positional Arguments

m: Evision.Mat
rowRange: Range

Keyword Arguments

colRange: Range.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(m, rowRange[, colRange]) -> <UMat object>

Variant 4:

UMat

Positional Arguments

size: Size
type: integer()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(size, type[, usageFlags]) -> <UMat object>

uMat(size, type, s, opts)

@spec uMat(
  {number(), number()},
  integer(),
  Evision.scalar(),
  [{:usageFlags, term()}] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(integer(), integer(), integer(), [{:usageFlags, term()}] | nil) ::
  Evision.Mat.t() | {:error, String.t()}

@spec uMat(integer(), integer(), integer(), Evision.scalar()) ::
  Evision.Mat.t() | {:error, String.t()}

Variant 1:

UMat

Positional Arguments

rows: integer()
cols: integer()
type: integer()
s: Evision.scalar()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(rows, cols, type, s[, usageFlags]) -> <UMat object>

Variant 2:

UMat

Positional Arguments

size: Size
type: integer()
s: Evision.scalar()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(size, type, s[, usageFlags]) -> <UMat object>

Variant 3:

UMat

Positional Arguments

rows: integer()
cols: integer()
type: integer()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(rows, cols, type[, usageFlags]) -> <UMat object>

uMat(rows, cols, type, s, opts)

@spec uMat(
  integer(),
  integer(),
  integer(),
  Evision.scalar(),
  [{:usageFlags, term()}] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

UMat

Positional Arguments

rows: integer()
cols: integer()
type: integer()
s: Evision.scalar()

Keyword Arguments

usageFlags: UMatUsageFlags.

Return

self: Evision.Mat.t()

Python prototype (for reference only):

UMat(rows, cols, type, s[, usageFlags]) -> <UMat object>