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

copyMatAndDumpNamedArguments

Positional Arguments

• src: Evision.Mat.t()

Keyword Arguments

• params: FunctionParams.

Return

• retval: String
• dst: Evision.Mat.t().

Python prototype (for reference only):

copyMatAndDumpNamedArguments(src[, dst[, params]]) -> retval, dst

@spec copyMatAndDumpNamedArguments(
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  {binary(), Evision.Mat.t()} | {:error, String.t()}

copyMatAndDumpNamedArguments

Positional Arguments

• src: Evision.Mat.t()

Keyword Arguments

• params: FunctionParams.

Return

• retval: String
• dst: Evision.Mat.t().

Python prototype (for reference only):

copyMatAndDumpNamedArguments(src[, dst[, params]]) -> retval, dst

@spec dumpBool(boolean()) :: binary() | {:error, String.t()}

dumpBool

Positional Arguments

• argument: bool

Return

• retval: String

Python prototype (for reference only):

dumpBool(argument) -> retval

@spec dumpCString(binary()) :: binary() | {:error, String.t()}

dumpCString

Positional Arguments

• argument: c_string

Return

• retval: String

Python prototype (for reference only):

dumpCString(argument) -> retval

@spec dumpDouble(number()) :: binary() | {:error, String.t()}

dumpDouble

Positional Arguments

• argument: double

Return

• retval: String

Python prototype (for reference only):

dumpDouble(argument) -> retval

@spec dumpFloat(number()) :: binary() | {:error, String.t()}

dumpFloat

Positional Arguments

• argument: float

Return

• retval: String

Python prototype (for reference only):

dumpFloat(argument) -> retval

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

dumpInputArray

Positional Arguments

• argument: Evision.Mat.t()

Return

• retval: String

Python prototype (for reference only):

dumpInputArray(argument) -> retval

@spec dumpInputArrayOfArrays([Evision.Mat.maybe_mat_in()]) ::
  binary() | {:error, String.t()}

dumpInputArrayOfArrays

Positional Arguments

• argument: [Evision.Mat]

Return

• retval: String

Python prototype (for reference only):

dumpInputArrayOfArrays(argument) -> retval

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

dumpInputOutputArray

Return

• retval: String
• argument: Evision.Mat.t()

Python prototype (for reference only):

dumpInputOutputArray(argument) -> retval, argument

@spec dumpInputOutputArrayOfArrays([Evision.Mat.maybe_mat_in()]) ::
  {binary(), [Evision.Mat.t()]} | {:error, String.t()}

dumpInputOutputArrayOfArrays

Return

• retval: String
• argument: [Evision.Mat]

Python prototype (for reference only):

dumpInputOutputArrayOfArrays(argument) -> retval, argument

@spec dumpInt64(integer()) :: binary() | {:error, String.t()}

dumpInt64

Positional Arguments

• argument: int64

Return

• retval: String

Python prototype (for reference only):

dumpInt64(argument) -> retval

@spec dumpInt(integer()) :: binary() | {:error, String.t()}

dumpInt

Positional Arguments

• argument: int

Return

• retval: String

Python prototype (for reference only):

dumpInt(argument) -> retval

@spec dumpRange({integer(), integer()} | :all) :: binary() | {:error, String.t()}

dumpRange

Positional Arguments

• argument: Range

Return

• retval: String

Python prototype (for reference only):

dumpRange(argument) -> retval

@spec dumpRect({number(), number(), number(), number()}) ::
  binary() | {:error, String.t()}

dumpRect

Positional Arguments

• argument: Rect

Return

• retval: String

Python prototype (for reference only):

dumpRect(argument) -> retval

@spec dumpRotatedRect(Evision.RotatedRect.t()) :: binary() | {:error, String.t()}

dumpRotatedRect

Positional Arguments

• argument: {centre={x, y}, size={s1, s2}, angle}

Return

• retval: String

Python prototype (for reference only):

dumpRotatedRect(argument) -> retval

@spec dumpSizeT(integer()) :: binary() | {:error, String.t()}

dumpSizeT

Positional Arguments

• argument: size_t

Return

• retval: String

Python prototype (for reference only):

dumpSizeT(argument) -> retval

@spec dumpString(binary()) :: binary() | {:error, String.t()}

dumpString

Positional Arguments

• argument: String

Return

• retval: String

Python prototype (for reference only):

dumpString(argument) -> retval

@spec dumpTermCriteria({integer(), integer(), number()}) ::
  binary() | {:error, String.t()}

dumpTermCriteria

Positional Arguments

• argument: TermCriteria

Return

• retval: String

Python prototype (for reference only):

dumpTermCriteria(argument) -> retval

@spec dumpVec2i() :: binary() | {:error, String.t()}

dumpVec2i

Keyword Arguments

• value: Vec2i.

Return

• retval: String

Python prototype (for reference only):

dumpVec2i([, value]) -> retval

@spec dumpVec2i([{atom(), term()}, ...] | nil) :: binary() | {:error, String.t()}

dumpVec2i

Keyword Arguments

• value: Vec2i.

Return

• retval: String

Python prototype (for reference only):

dumpVec2i([, value]) -> retval

@spec dumpVectorOfDouble([number()]) :: binary() | {:error, String.t()}

dumpVectorOfDouble

Positional Arguments

• vec: [double]

Return

• retval: String

Python prototype (for reference only):

dumpVectorOfDouble(vec) -> retval

@spec dumpVectorOfInt([integer()]) :: binary() | {:error, String.t()}

dumpVectorOfInt

Positional Arguments

• vec: [int]

Return

• retval: String

Python prototype (for reference only):

dumpVectorOfInt(vec) -> retval

@spec dumpVectorOfRect([{number(), number(), number(), number()}]) ::
  binary() | {:error, String.t()}

dumpVectorOfRect

Positional Arguments

• vec: [Rect]

Return

• retval: String

Python prototype (for reference only):

dumpVectorOfRect(vec) -> retval

@spec generateVectorOfInt(integer()) :: [integer()] | {:error, String.t()}

generateVectorOfInt

Positional Arguments

• len: size_t

Return

• vec: [int]

Python prototype (for reference only):

generateVectorOfInt(len) -> vec

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

generateVectorOfMat

Positional Arguments

• len: size_t
• rows: int
• cols: int
• dtype: int

Return

• vec: [Evision.Mat].

Python prototype (for reference only):

generateVectorOfMat(len, rows, cols, dtype[, vec]) -> vec

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

generateVectorOfMat

Positional Arguments

• len: size_t
• rows: int
• cols: int
• dtype: int

Return

• vec: [Evision.Mat].

Python prototype (for reference only):

generateVectorOfMat(len, rows, cols, dtype[, vec]) -> vec

@spec generateVectorOfRect(integer()) ::
  [{number(), number(), number(), number()}] | {:error, String.t()}

generateVectorOfRect

Positional Arguments

• len: size_t

Return

• vec: [Rect]

Python prototype (for reference only):

generateVectorOfRect(len) -> vec

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

testAsyncArray

Positional Arguments

• argument: Evision.Mat.t()

Return

• retval: Evision.AsyncArray.t()

Python prototype (for reference only):

testAsyncArray(argument) -> retval

@spec testAsyncException() :: Evision.AsyncArray.t() | {:error, String.t()}

testAsyncException

Return

• retval: Evision.AsyncArray.t()

Python prototype (for reference only):

testAsyncException() -> retval

@spec testOverloadResolution({number(), number(), number(), number()}) ::
  binary() | {:error, String.t()}

@spec testOverloadResolution(integer()) :: binary() | {:error, String.t()}

Variant 1:

testOverloadResolution

Positional Arguments

• rect: Rect

Return

• retval: String

Python prototype (for reference only):

testOverloadResolution(rect) -> retval

Variant 2:

testOverloadResolution

Positional Arguments

• value: int

Keyword Arguments

• point: Point.

Return

• retval: String

Python prototype (for reference only):

testOverloadResolution(value[, point]) -> retval

@spec testOverloadResolution(integer(), [{atom(), term()}, ...] | nil) ::
  binary() | {:error, String.t()}

testOverloadResolution

Positional Arguments

• value: int

Keyword Arguments

• point: Point.

Return

• retval: String

Python prototype (for reference only):

testOverloadResolution(value[, point]) -> retval

@spec testOverwriteNativeMethod(integer()) :: integer() | {:error, String.t()}

testOverwriteNativeMethod

Positional Arguments

• argument: int

Return

• retval: int

Python prototype (for reference only):

testOverwriteNativeMethod(argument) -> retval

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

testRaiseGeneralException

Python prototype (for reference only):

testRaiseGeneralException() -> None

@spec testReservedKeywordConversion(integer()) :: binary() | {:error, String.t()}

testReservedKeywordConversion

Positional Arguments

• positional_argument: int

Keyword Arguments

• lambda: int.
• from: int.

Return

• retval: String

Python prototype (for reference only):

testReservedKeywordConversion(positional_argument[, lambda[, from]]) -> retval

@spec testReservedKeywordConversion(integer(), [{atom(), term()}, ...] | nil) ::
  binary() | {:error, String.t()}

testReservedKeywordConversion

Positional Arguments

• positional_argument: int

Keyword Arguments

• lambda: int.
• from: int.

Return

• retval: String

Python prototype (for reference only):

testReservedKeywordConversion(positional_argument[, lambda[, from]]) -> retval

@spec testRotatedRect(number(), number(), number(), number(), number()) ::
  Evision.RotatedRect.t() | {:error, String.t()}

testRotatedRect

Positional Arguments

• x: float
• y: float
• w: float
• h: float
• angle: float

Return

• retval: {centre={x, y}, size={s1, s2}, angle}

Python prototype (for reference only):

testRotatedRect(x, y, w, h, angle) -> retval

@spec testRotatedRectVector(number(), number(), number(), number(), number()) ::
  [Evision.RotatedRect.t()] | {:error, String.t()}

testRotatedRectVector

Positional Arguments

• x: float
• y: float
• w: float
• h: float
• angle: float

Return

• retval: [{centre={x, y}, size={s1, s2}, angle}]

Python prototype (for reference only):

testRotatedRectVector(x, y, w, h, angle) -> retval