maix.image module, image related definition and functions

You can use maix.image to access this module with MaixPy
This module is generated from MaixPy and MaixCDK

Module

No module

Enum

Format

Image formats

item	describe
attention	for MaixPy firmware developers, update this enum will also need to update the fmt_size and fmt_names too !!!
values	FMT_RGB888: RGBRGB...RGB, R at the lowest address FMT_BGR888: BGRBGR...BGR, B at the lowest address FMT_RGBA8888: RGBARGBA...RGBA, R at the lowest address FMT_BGRA8888: BGRABGRA...BGRA, B at the lowest address FMT_RGB565: FMT_BGR565: FMT_YUV422SP: YYY...UVUVUV...UVUV FMT_YUV422P: YYY...UUU...VVV FMT_YVU420SP: YYY...VUVUVU...VUVU, NV21 FMT_YUV420SP: YYY...UVUVUV...UVUV, NV12 FMT_YVU420P: YYY...VVV...UUU FMT_YUV420P: YYY...UUU...VVV FMT_GRAYSCALE: FMT_BGGR6: 6-bit Bayer format with a BGGR pattern. FMT_GBRG6: 6-bit Bayer format with a GBRG pattern. FMT_GRBG6: 6-bit Bayer format with a GRBG pattern. FMT_RGGB6: 6-bit Bayer format with a RGGB pattern. FMT_BGGR8: 8-bit Bayer format with a BGGR pattern. FMT_GBRG8: 8-bit Bayer format with a GBRG pattern. FMT_GRBG8: 8-bit Bayer format with a GRBG pattern. FMT_RGGB8: 8-bit Bayer format with a RGGB pattern. FMT_BGGR10: 10-bit Bayer format with a BGGR pattern. FMT_GBRG10: 10-bit Bayer format with a GBRG pattern. FMT_GRBG10: 10-bit Bayer format with a GRBG pattern. FMT_RGGB10: 10-bit Bayer format with a RGGB pattern. FMT_BGGR12: 12-bit Bayer format with a BGGR pattern. FMT_GBRG12: 12-bit Bayer format with a GBRG pattern. FMT_GRBG12: 12-bit Bayer format with a GRBG pattern. FMT_RGGB12: 12-bit Bayer format with a RGGB pattern. FMT_UNCOMPRESSED_MAX: FMT_COMPRESSED_MIN: FMT_JPEG: FMT_PNG: FMT_COMPRESSED_MAX: FMT_INVALID: format not valid

C++ defination code:

enum Format
    {
        FMT_RGB888 = 0, // RGBRGB...RGB, R at the lowest address
        FMT_BGR888,     // BGRBGR...BGR, B at the lowest address
        FMT_RGBA8888,   // RGBARGBA...RGBA, R at the lowest address
        FMT_BGRA8888,   // BGRABGRA...BGRA, B at the lowest address
        FMT_RGB565,
        FMT_BGR565,
        FMT_YUV422SP, // YYY...UVUVUV...UVUV
        FMT_YUV422P,  // YYY...UUU...VVV
        FMT_YVU420SP, // YYY...VUVUVU...VUVU, NV21
        FMT_YUV420SP, // YYY...UVUVUV...UVUV, NV12
        FMT_YVU420P,  // YYY...VVV...UUU
        FMT_YUV420P,  // YYY...UUU...VVV
        FMT_GRAYSCALE,
        FMT_BGGR6,      // 6-bit Bayer format with a BGGR pattern.
        FMT_GBRG6,      // 6-bit Bayer format with a GBRG pattern.
        FMT_GRBG6,      // 6-bit Bayer format with a GRBG pattern.
        FMT_RGGB6,      // 6-bit Bayer format with a RGGB pattern.
        FMT_BGGR8,      // 8-bit Bayer format with a BGGR pattern.
        FMT_GBRG8,      // 8-bit Bayer format with a GBRG pattern.
        FMT_GRBG8,      // 8-bit Bayer format with a GRBG pattern.
        FMT_RGGB8,      // 8-bit Bayer format with a RGGB pattern.
        FMT_BGGR10,     // 10-bit Bayer format with a BGGR pattern.
        FMT_GBRG10,     // 10-bit Bayer format with a GBRG pattern.
        FMT_GRBG10,     // 10-bit Bayer format with a GRBG pattern.
        FMT_RGGB10,     // 10-bit Bayer format with a RGGB pattern.
        FMT_BGGR12,     // 12-bit Bayer format with a BGGR pattern.
        FMT_GBRG12,     // 12-bit Bayer format with a GBRG pattern.
        FMT_GRBG12,     // 12-bit Bayer format with a GRBG pattern.
        FMT_RGGB12,     // 12-bit Bayer format with a RGGB pattern.
        FMT_UNCOMPRESSED_MAX,

        // compressed format below, not compressed should define upper
        FMT_COMPRESSED_MIN,
        FMT_JPEG,
        FMT_PNG,
        FMT_COMPRESSED_MAX,

        FMT_INVALID = 0xFF  // format not valid
    }

Fit

Object fit method

item	describe
values	FIT_NONE: no object fit, keep original FIT_FILL: width to new width, height to new height, may be stretch FIT_CONTAIN: keep aspect ratio, fill blank area with black color FIT_COVER: keep aspect ratio, crop image to fit new size FIT_MAX:

C++ defination code:

enum Fit
    {
        FIT_NONE = -1, // no object fit, keep original
        FIT_FILL = 0,  // width to new width, height to new height, may be stretch
        FIT_CONTAIN,   // keep aspect ratio, fill blank area with black color
        FIT_COVER,     // keep aspect ratio, crop image to fit new size
        FIT_MAX
    }

ResizeMethod

Resize method

item	describe
values	NEAREST: BILINEAR: BICUBIC: AREA: LANCZOS: HAMMING: RESIZE_METHOD_MAX:

C++ defination code:

enum ResizeMethod
    {
        NEAREST = 0,
        BILINEAR,
        BICUBIC,
        AREA,
        LANCZOS,
        HAMMING,
        RESIZE_METHOD_MAX
    }

ApriltagFamilies

Family of apriltag

item	describe
values	TAG16H5: TAG25H7: TAG25H9: TAG36H10: TAG36H11: ARTOOLKIT:

C++ defination code:

enum ApriltagFamilies
    {
        TAG16H5   = 1,
        TAG25H7   = 2,
        TAG25H9   = 4,
        TAG36H10  = 8,
        TAG36H11  = 16,
        ARTOOLKIT = 32
    }

TemplateMatch

Template match method

item	describe
values	SEARCH_EX: Exhaustive search SEARCH_DS: Diamond search

C++ defination code:

enum TemplateMatch
    {
        SEARCH_EX,  // Exhaustive search
        SEARCH_DS,  // Diamond search
    }

CornerDetector

CornerDetector class

item	describe
values	CORNER_FAST: CORNER_AGAST:

C++ defination code:

enum CornerDetector
    {
        CORNER_FAST,
        CORNER_AGAST
    }

EdgeDetector

EdgeDetector class

item	describe
values	EDGE_CANNY: EDGE_SIMPLE:

C++ defination code:

enum EdgeDetector
    {
        EDGE_CANNY,
        EDGE_SIMPLE,
    }

Variable

fmt_size

Image format size in bytes

item	description
attention	It's a copy of this variable in MaixPy, so change it in C++ (e.g. update var in hello function) will not take effect the var inMaixPy. So we add const for this var to avoid this mistake.
value	{ 3, 3, 4, 4, 2, 2, 2, 2, 1.5, 1.5, 1.5, 1.5, 1, // grayscale 0.75, // 6-bit Bayer format 0.75, // 6-bit Bayer format 0.75, // 6-bit Bayer format 0.75, // 6-bit Bayer format 1, // 8-bit Bayer format 1, // 8-bit Bayer format 1, // 8-bit Bayer format 1, // 8-bit Bayer format 1.25, // 10-bit Bayer format 1.25, // 10-bit Bayer format 1.25, // 10-bit Bayer format 1.25, // 10-bit Bayer format 1.5, // 12-bit Bayer format 1.5, // 12-bit Bayer format 1.5, // 12-bit Bayer format 1.5, // 12-bit Bayer format 0, // uncompereed_max 0, // compressed_min 1, // jpeg 1, // png 0, // compressed_max 0 // invalid }
readonly	True

C++ defination code:

const std::vector<float> fmt_size = {
        3,
        3,
        4,
        4,
        2,
        2,
        2,
        2,
        1.5,
        1.5,
        1.5,
        1.5,
        1, // grayscale
        0.75,   // 6-bit Bayer format
        0.75,   // 6-bit Bayer format
        0.75,   // 6-bit Bayer format
        0.75,   // 6-bit Bayer format
        1,      // 8-bit Bayer format
        1,      // 8-bit Bayer format
        1,      // 8-bit Bayer format
        1,      // 8-bit Bayer format
        1.25,   // 10-bit Bayer format
        1.25,   // 10-bit Bayer format
        1.25,   // 10-bit Bayer format
        1.25,   // 10-bit Bayer format
        1.5,    // 12-bit Bayer format
        1.5,    // 12-bit Bayer format
        1.5,    // 12-bit Bayer format
        1.5,    // 12-bit Bayer format
        0, // uncompereed_max
        0, // compressed_min
        1, // jpeg
        1, // png
        0, // compressed_max
        0  // invalid
        }

fmt_names

Image format string

item	description
value	{ "RGB888", "BGR888", "RGBA8888", "BGRA8888", "RGB565", "BGR565", "YUV422SP", "YUV422P", "YVU420SP", "YUV420SP", "YVU420P", "YUV420P", "GRAYSCALE", "BGGR6", "GBRG6", "GRBG6", "RG6B6", "BGGR8", "GBRG8", "GRBG8", "RG6B8", "BGGR10", "GBRG10", "GRBG10", "RG6B10", "BGGR12", "GBRG12", "GRBG12", "RG6B12", "UNCOMPRESSED_MAX", "COMPRESSED_MIN", "JPEG", "PNG", "COMPRESSED_MAX", "INVALID" }
readonly	True

C++ defination code:

const std::vector<std::string> fmt_names = {
        "RGB888",
        "BGR888",
        "RGBA8888",
        "BGRA8888",
        "RGB565",
        "BGR565",
        "YUV422SP",
        "YUV422P",
        "YVU420SP",
        "YUV420SP",
        "YVU420P",
        "YUV420P",
        "GRAYSCALE",
        "BGGR6",
        "GBRG6",
        "GRBG6",
        "RG6B6",
        "BGGR8",
        "GBRG8",
        "GRBG8",
        "RG6B8",
        "BGGR10",
        "GBRG10",
        "GRBG10",
        "RG6B10",
        "BGGR12",
        "GBRG12",
        "GRBG12",
        "RG6B12",
        "UNCOMPRESSED_MAX",
        "COMPRESSED_MIN",
        "JPEG",
        "PNG",
        "COMPRESSED_MAX",
        "INVALID"
        }

COLOR_WHITE

Predefined color white

item	description
value	image::Color::from_rgb(255, 255, 255)
readonly	True

C++ defination code:

const image::Color COLOR_WHITE = image::Color::from_rgb(255, 255, 255)

COLOR_BLACK

Predefined color black

item	description
value	image::Color::from_rgb(0, 0, 0)
readonly	True

C++ defination code:

const image::Color COLOR_BLACK = image::Color::from_rgb(0, 0, 0)

COLOR_RED

Predefined color red

item	description
value	image::Color::from_rgb(255, 0, 0)
readonly	True

C++ defination code:

const image::Color COLOR_RED = image::Color::from_rgb(255, 0, 0)

COLOR_GREEN

Predefined color green

item	description
value	image::Color::from_rgb(0, 255, 0)
readonly	True

C++ defination code:

const image::Color COLOR_GREEN = image::Color::from_rgb(0, 255, 0)

COLOR_BLUE

Predefined color blue

item	description
value	image::Color::from_rgb(0, 0, 255)
readonly	True

C++ defination code:

const image::Color COLOR_BLUE = image::Color::from_rgb(0, 0, 255)

COLOR_YELLOW

Predefined color yellow

item	description
value	image::Color::from_rgb(255, 255, 0)
readonly	True

C++ defination code:

const image::Color COLOR_YELLOW = image::Color::from_rgb(255, 255, 0)

COLOR_PURPLE

Predefined color purple

item	description
value	image::Color::from_rgb(143, 0, 255)
readonly	True

C++ defination code:

const image::Color COLOR_PURPLE = image::Color::from_rgb(143, 0, 255)

COLOR_ORANGE

Predefined color orange

item	description
value	image::Color::from_rgb(255, 127, 0)
readonly	True

C++ defination code:

const image::Color COLOR_ORANGE = image::Color::from_rgb(255, 127, 0)

COLOR_GRAY

Predefined color gray

item	description
value	image::Color::from_rgb(127, 127, 127)
readonly	True

C++ defination code:

const image::Color COLOR_GRAY = image::Color::from_rgb(127, 127, 127)

Function

resize_map_pos

def resize_map_pos(w_in: int, h_in: int, w_out: int, h_out: int, fit: Fit, x: int, y: int, w: int = -1, h: int = -1) -> list[int]

map point position or rectangle position from one image size to another image size(resize)

item	description
param	int: h_out target image height fit: resize method, see maix.image.Fit x: original point x, or rectagle left-top point's x y: original point y, or rectagle left-top point's y w: original rectagle width, can be -1 if not use this arg, default -1. h: original rectagle height, can be -1 if not use this arg, default -1.
return	list type, [x, y] if map point, [x, y, w, h] if resize rectangle.

C++ defination code:

std::vector<int> resize_map_pos(int w_in, int h_in, int w_out, int h_out, image::Fit fit, int x, int y, int w = -1, int h = -1)

resize_map_pos (overload 1)

map point position or rectangle position from this image size to another image size(resize)

item	description
param	int: h_out target image height fit: resize method, see maix.image.Fit x: original point x, or rectagle left-top point's x y: original point y, or rectagle left-top point's y w: original rectagle width, can be -1 if not use this arg, default -1. h: original rectagle height, can be -1 if not use this arg, default -1.
return	list type, [x, y] if map point, [x, y, w, h] if resize rectangle.

C++ defination code:

std::vector<int> resize_map_pos(int w_out, int h_out, image::Fit fit, int x, int y, int w = -1, int h = -1)

resize_map_pos_reverse

def resize_map_pos_reverse(w_in: int, h_in: int, w_out: int, h_out: int, fit: Fit, x: int, y: int, w: int = -1, h: int = -1) -> list[int]

reverse resize_map_pos method, when we call image.resize method resiz image 'a' to image 'b', we want to known the original position on 'a' whith a knew point on 'b'

item	description
param	int: h_out image height after resized fit: resize method, see maix.image.Fit x: point on resized image x, or rectagle left-top point's x y: original point y, or rectagle left-top point's y w: original rectagle width, can be -1 if not use this arg, default -1. h: original rectagle height, can be -1 if not use this arg, default -1.
return	list type, [x, y] if map point, [x, y, w, h] if resize rectangle.

C++ defination code:

std::vector<int> resize_map_pos_reverse(int w_in, int h_in, int w_out, int h_out, image::Fit fit, int x, int y, int w = -1, int h = -1)

load

def load(path: str, format: Format = ...) -> Image

Load image from file, and convert to Image object

item	description
param	path: image file path format: read as this format, if not match, will convert to this format, by default is RGB888
return	Image object, if load failed, will return None(nullptr in C++), so you should care about it.

C++ defination code:

image::Image *load(const char *path, image::Format format = image::Format::FMT_RGB888)

from_bytes

def from_bytes(width: int, height: int, format: Format, data: maix.Bytes(bytes), copy: bool = True) -> Image

Create image from bytes

item	description
param	width: image width height: image height format: image format data: image data, if data is None, will malloc memory for image data If the image is in jpeg format, data must be filled in. copy: if true and data is not None, will copy data to new buffer, else will use data directly. default is true to avoid memory leak. Use it carefully!!!
return	Image object

C++ defination code:

image::Image *from_bytes(int width, int height, image::Format format, Bytes *data, bool copy = true)

load_font

def load_font(name: str, path: str, size: int = 16) -> maix.err.Err

Load font from file

item	description
param	name: font name, used to identify font path: font file path, support ttf, ttc, otf size: font size, font height, by default is 16
return	error code, err::ERR_NONE is ok, other is error

C++ defination code:

err::Err load_font(const std::string &name, const char *path, int size = 16)

set_default_font

Set default font, if not call this method, default is hershey_plain

item	description
param	name: font name, supported names can be get by fonts()
return	error code, err::ERR_NONE is ok, other is error

C++ defination code:

err::Err set_default_font(const std::string &name)

fonts

def fonts() -> list[str]

Get all loaded fonts

item	description
return	all loaded fonts, string list type

C++ defination code:

std::vector<std::string> *fonts()

string_size

def string_size(string: str, scale: float = 1, thickness: int = 1, font: str = '') -> Size

Get text rendered width and height

item	description
param	string: text content scale: font scale, by default(value is 1) thickness: text thickness(line width), by default(value is 1)
return	text rendered width and height, [width, height]

C++ defination code:

image::Size string_size(std::string string, float scale = 1, int thickness = 1, const std::string &font = "")

cv2image

def cv2image(array: numpy.ndarray[numpy.uint8], bgr: bool = True, copy: bool = True) -> Image

OpenCV Mat(numpy array object) to Image object

item	description
param	array: numpy array object, must be a 3-dim or 2-dim continuous array with shape hwc or hw bgr: if set bgr, the return image will be marked as BGR888 or BGRA8888 format, grayscale will ignore this arg. copy: if true, will alloc new buffer and copy data, else will directly use array's data buffer, default true. Use this arg carefully, when set to false, ther array MUST keep alive until we don't use the return img of this func, or will cause program crash.
return	Image object

C++ defination code:

image::Image *cv2image(py::array_t<uint8_t, py::array::c_style> array, bool bgr = true, bool copy = true)

image2cv

def image2cv(img: Image, ensure_bgr: bool = True, copy: bool = True) -> numpy.ndarray[numpy.uint8]

Image object to OpenCV Mat(numpy array object)

item	description
param	img: Image object, maix.image.Image type. ensure_bgr: auto convert to BGR888 or BGRA8888 if img format is not BGR or BGRA, if set to false, will not auto convert and directly use img's data, default true. copy: Whether alloc new image and copy data or not, if ensure_bgr and img is not bgr or bgra format, always copy, if not copy, array object will directly use img's data buffer, will faster but change array will affect img's data, default true.
attention	take care of ensure_bgr and copy param.
return	numpy array object

C++ defination code:

py::array_t<uint8_t, py::array::c_style> image2cv(image::Image *img, bool ensure_bgr = true, bool copy = true)

Class

Size

Image size type

C++ defination code:

class Size

__init__

def __init__(self, width: int = 0, height: int = 0) -> None

Construct a new Size object

item	description
type	func
param	width: image width height: image height
static	False

C++ defination code:

Size(int width = 0, int height = 0)

width

def width(self, width: int = -1) -> int

width of size

item	description
type	func
param	width: set new width, if not set, only return current width
static	False

C++ defination code:

int width(int width = -1)

height

def height(self, height: int = -1) -> int

height of size

item	description
type	func
param	height: set new height, if not set, only return current height
static	False

C++ defination code:

int height(int height = -1)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: 0 for width, 1 for height
return	int& width or height
static	False

C++ defination code:

int &operator[](int index)

__str__

def __str__(self) -> str

to string

item	description
type	func
static	False

C++ defination code:

std::string __str__()

Line

Line class

C++ defination code:

class Line

__init__

def __init__(self, x1: int, y1: int, x2: int, y2: int, magnitude: int = 0, theta: int = 0, rho: int = 0) -> None

Line constructor

item	description
type	func
param	x1: coordinate x1 of the straight line y1: coordinate y1 of the straight line x2: coordinate x2 of the straight line y2: coordinate y2 of the straight line magnitude: magnitude of the straight line after Hough transformation theta: angle of the straight line after Hough transformation rho: p-value of the straight line after Hough transformation
static	False

C++ defination code:

Line(int x1, int y1, int x2, int y2, int magnitude = 0, int theta = 0, int rho = 0)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] get x1 of line [1] get y1 of line [2] get x2 of line [3] get y2 of line [4] get length of line [5] get magnitude of the straight line after Hough transformation [6] get angle of the straight line after Hough transformation (0-179 degrees) [7] get p-value of the straight line after Hough transformation
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

x1

def x1(self) -> int

get x1 of line

item	description
type	func
return	return x1 of the line, type is int
static	False

C++ defination code:

int x1()

y1

def y1(self) -> int

get y1 of line

item	description
type	func
return	return y1 of the line, type is int
static	False

C++ defination code:

int y1()

x2

def x2(self) -> int

get x2 of line

item	description
type	func
return	return x2 of the line, type is int
static	False

C++ defination code:

int x2()

y2

def y2(self) -> int

get y2 of line

item	description
type	func
return	return y2 of the line, type is int
static	False

C++ defination code:

int y2()

length

def length(self) -> int

get length of line

item	description
type	func
return	return length of the line, type is int
static	False

C++ defination code:

int length()

magnitude

def magnitude(self) -> int

get magnitude of the straight line after Hough transformation

item	description
type	func
return	return magnitude, type is int
static	False

C++ defination code:

int magnitude()

theta

def theta(self) -> int

get angle of the straight line after Hough transformation (0-179 degrees)

item	description
type	func
return	return angle, type is int
static	False

C++ defination code:

int theta()

rho

def rho(self) -> int

get p-value of the straight line after Hough transformation

item	description
type	func
return	return p-value, type is int
static	False

C++ defination code:

int rho()

Rect

Rect class

C++ defination code:

class Rect

__init__

def __init__(self, corners: list[list[int]], x: int, y: int, w: int, h: int, magnitude: int = 0) -> None

Rect constructor

item	description
type	func
param	corners: corners of rect x: coordinate x of the straight line y: coordinate y of the straight line w: coordinate w of the straight line h: coordinate h of the straight line magnitude: magnitude of the straight line after Hough transformation
static	False

C++ defination code:

Rect(std::vector<std::vector<int>> &corners, int x, int y, int w, int h, int magnitude = 0)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] get x of rect [1] get y of rect [2] get w of rect [3] get h of rect [4] get magnitude of the straight line after Hough transformation
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get corners of rect

item	description
type	func
return	return the coordinate of the rect.
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

rect

def rect(self) -> list[int]

get rectangle of rect

item	description
type	func
return	return the rectangle of the rect. format is {x, y, w, h}, type is std::vector
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get x of rect

item	description
type	func
return	return x of the rect, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of rect

item	description
type	func
return	return y of the rect, type is int
static	False

C++ defination code:

int y()

w

def w(self) -> int

get w of rect

item	description
type	func
return	return w of the rect, type is int
static	False

C++ defination code:

int w()

h

def h(self) -> int

get h of rect

item	description
type	func
return	return h of the rect, type is int
static	False

C++ defination code:

int h()

magnitude

def magnitude(self) -> int

get magnitude of the straight line after Hough transformation

item	description
type	func
return	return magnitude, type is int
static	False

C++ defination code:

int magnitude()

Circle

circle class

C++ defination code:

class Circle

__init__

def __init__(self, x: int, y: int, r: int, magnitude: int) -> None

Circle constructor

item	description
type	func
param	x: coordinate x of the circle y: coordinate y of the circle r: coordinate r of the circle magnitude: coordinate y2 of the straight line
static	False

C++ defination code:

Circle(int x, int y, int r, int magnitude)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] get x of circle [1] get y of circle [2] get r of circle [3] get magnitude of the circle after Hough transformation
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

x

def x(self) -> int

get x of circle

item	description
type	func
return	return x of the circle, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of circle

item	description
type	func
return	return y of the circle, type is int
static	False

C++ defination code:

int y()

r

def r(self) -> int

get r of circle

item	description
type	func
return	return r of the circle, type is int
static	False

C++ defination code:

int r()

magnitude

def magnitude(self) -> int

get magnitude of the circle after Hough transformation

item	description
type	func
return	return magnitude, type is int
static	False

C++ defination code:

int magnitude()

Blob

Blob class

C++ defination code:

class Blob

__init__

def __init__(self, rect: list[int], corners: list[list[int]], mini_corners: list[list[int]], cx: float, cy: float, pixels: int, rotation: float, code: int, count: int, perimeter: int, roundness: float, x_hist_bins: list[int], y_hist_bins: list[int]) -> None

Blob constructor

item	description
type	func
param	rect: blob rect, type is std::vector corners: blob corners, type is std::vector<std::vector> mini_corners: blob mini_corners, type is std::vector<std::vector> cx: blob center x, type is float cy: blob center y, type is float pixels: blob pixels, type is int rotation: blob rotation, type is float code: blob code, type is int count: blob count, type is int perimeter: blob perimeter, type is int roundness: blob roundness, type is float x_hist_bins: blob x_hist_bins, type is std::vector y_hist_bins: blob y_hist_bins, type is std::vector
static	False

C++ defination code:

Blob(std::vector<int> &rect, std::vector<std::vector<int>> &corners, std::vector<std::vector<int>> &mini_corners,float cx, float cy, int pixels, float rotation, int code, int count, int perimeter, float roundness, std::vector<int> &x_hist_bins, std::vector<int> &y_hist_bins)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] Returns the blob’s bounding box x coordinate [1] Returns the blob’s bounding box y coordinate [2] Returns the blob’s bounding box w coordinate [3] Returns the blob’s bounding box h coordinate [4] Returns the number of pixels that are part of this blob [5] Returns the centroid x position of the blob [6] Returns the centroid y position of the blob
return	int& width or height
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get blob corners

item	description
type	func
return	Returns a list of 4 (x,y) tuples of the 4 corners of the object. (x0, y0)___________(x1, y1)							___________	(x3, y3) (x2, y2) note: the order of corners may change
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

mini_corners

def mini_corners(self) -> list[list[int]]

get blob mini corners

item	description
type	func
return	Returns a list of 4 (x,y) tuples of the 4 corners than bound the min area rectangle of the blob. (x0, y0)___________(x1, y1)							___________	(x3, y3) (x2, y2) note: the order of corners may change
static	False

C++ defination code:

std::vector<std::vector<int>> mini_corners()

rect

def rect(self) -> list[int]

get blob rect

item	description
type	func
return	Returns the center coordinates and width and height of the rectangle. format is (x, y, w, h) w (x, y) ___________				h			___________
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get blob x of the upper left coordinate

item	description
type	func
return	Returns the x coordinate of the upper left corner of the rectangle.
static	False

C++ defination code:

int x()

y

def y(self) -> int

get blob y of the upper left coordinate

item	description
type	func
return	Returns the y coordinate of the upper left corner of the rectangle.
static	False

C++ defination code:

int y()

w

def w(self) -> int

get blob width

item	description
type	func
return	Returns the blob’s bounding box w coordinate
static	False

C++ defination code:

int w()

h

def h(self) -> int

get blob height

item	description
type	func
return	Returns the blob’s bounding box h coordinate
static	False

C++ defination code:

int h()

pixels

def pixels(self) -> int

get blob pixels

item	description
type	func
return	Returns the number of pixels that are part of this blob.
static	False

C++ defination code:

int pixels()

cx

def cx(self) -> int

get blob center x

item	description
type	func
return	Returns the centroid x position of the blob
static	False

C++ defination code:

int cx()

cy

def cy(self) -> int

get blob center y

item	description
type	func
return	Returns the centroid y position of the blob
static	False

C++ defination code:

int cy()

cxf

def cxf(self) -> float

get blob center x

item	description
type	func
return	Returns the centroid x position of the blob
static	False

C++ defination code:

float cxf()

cyf

def cyf(self) -> float

get blob center y

item	description
type	func
return	Returns the centroid y position of the blob
static	False

C++ defination code:

float cyf()

rotation

def rotation(self) -> float

get blob rotation

item	description
type	func
return	Returns the rotation of the blob in radians (float). If the blob is like a pencil or pen this value will be unique for 0-180 degrees.
static	False

C++ defination code:

float rotation()

rotation_rad

def rotation_rad(self) -> float

get blob rotation_rad

item	description
type	func
return	Returns the rotation of the blob in radians
static	False

C++ defination code:

float rotation_rad()

rotation_deg

def rotation_deg(self) -> int

get blob rotation_deg

item	description
type	func
return	Returns the rotation of the blob in degrees.
static	False

C++ defination code:

int rotation_deg()

code

def code(self) -> int

get blob code

item	description
type	func
return	Returns a 32-bit binary number with a bit set in it for each color threshold that’s part of this blob
static	False

C++ defination code:

int code()

count

def count(self) -> int

get blob count

item	description
type	func
return	Returns the number of blobs merged into this blob.
static	False

C++ defination code:

int count()

perimeter

def perimeter(self) -> int

get blob merge_cnt

item	description
type	func
return	Returns the number of pixels on this blob’s perimeter.
static	False

C++ defination code:

int perimeter()

roundness

def roundness(self) -> float

get blob roundness

item	description
type	func
return	Returns a value between 0 and 1 representing how round the object is
static	False

C++ defination code:

float roundness()

elongation

def elongation(self) -> float

get blob elongation

item	description
type	func
returnReturns	a value between 0 and 1 representing how long (not round) the object is
static	False

C++ defination code:

float elongation()

area

def area(self) -> int

get blob area

item	description
type	func
return	Returns the area of the bounding box around the blob
static	False

C++ defination code:

int area()

density

def density(self) -> float

get blob density

item	description
type	func
return	Returns the density ratio of the blob
static	False

C++ defination code:

float density()

extent

def extent(self) -> float

Alias for blob.density()

item	description
type	func
return	Returns the density ratio of the blob
static	False

C++ defination code:

float extent()

compactness

def compactness(self) -> float

get blob compactness

item	description
type	func
return	Returns the compactness ratio of the blob
static	False

C++ defination code:

float compactness()

solidity

def solidity(self) -> float

get blob solidity

item	description
type	func
return	Returns the solidity ratio of the blob
static	False

C++ defination code:

float solidity()

convexity

def convexity(self) -> float

get blob convexity

item	description
type	func
return	Returns a value between 0 and 1 representing how convex the object is
static	False

C++ defination code:

float convexity()

x_hist_bins

def x_hist_bins(self) -> list[int]

get blob x_hist_bins

item	description
type	func
return	Returns the x_hist_bins of the blob
static	False

C++ defination code:

std::vector<int> x_hist_bins()

y_hist_bins

def y_hist_bins(self) -> list[int]

get blob y_hist_bins

item	description
type	func
return	Returns the y_hist_bins of the blob
static	False

C++ defination code:

std::vector<int> y_hist_bins()

major_axis_line

def major_axis_line(self) -> list[int]

get blob major_axis_line

item	description
type	func
return	Returns a line tuple (x1, y1, x2, y2) of the minor axis of the blob.
static	False

C++ defination code:

std::vector<int> major_axis_line()

minor_axis_line

def minor_axis_line(self) -> list[int]

get blob minor_axis_line

item	description
type	func
return	Returns a line tuple (x1, y1, x2, y2) of the minor axis of the blob.
static	False

C++ defination code:

std::vector<int> minor_axis_line()

enclosing_circle

def enclosing_circle(self) -> list[int]

get blob enclosing_circle

item	description
type	func
return	Returns a circle tuple (x, y, r) of the circle that encloses the min area rectangle of a blob.
static	False

C++ defination code:

std::vector<int> enclosing_circle()

enclosed_ellipse

def enclosed_ellipse(self) -> list[int]

get blob enclosed_ellipse

item	description
type	func
return	Returns an ellipse tuple (x, y, rx, ry, rotation) of the ellipse that fits inside of the min area rectangle of a blob.
static	False

C++ defination code:

std::vector<int> enclosed_ellipse()

QRCode

QRCode class

C++ defination code:

class QRCode

__init__

def __init__(self, rect: list[int], corners: list[list[int]], payload: str, version: int, ecc_level: int, mask: int, data_type: int, eci: int) -> None

QRCode constructor

item	description
type	func
param	rect: rect of corners, type is std::vector corners: corners of QRCode payload: payload of the QRCode version: version of the QRCode ecc_level: ecc_level of the QRCode mask: mask of the QRCode data_type: data_type of the QRCode eci: eci of the QRCode
static	False

C++ defination code:

QRCode(std::vector<int> &rect, std::vector<std::vector<int>> &corners, std::string &payload, int version, int ecc_level, int mask, int data_type, int eci)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] Returns the qrcode’s bounding box x coordinate [1] Returns the qrcode’s bounding box y coordinate [2] Returns the qrcode’s bounding box w coordinate [3] Returns the qrcode’s bounding box h coordinate [4] Not support this index, try to use payload() method [5] Returns the version of qrcode [6] Returns the error correction level of qrcode [7] Returns the mask of qrcode [8] Returns the datatype of qrcode [9] Returns the eci of qrcode
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get coordinate of QRCode

item	description
type	func
return	return the coordinate of the QRCode.
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

rect

def rect(self) -> list[int]

get rectangle of QRCode

item	description
type	func
return	return the rectangle of the QRCode. format is {x, y, w, h}, type is std::vector
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get x of QRCode

item	description
type	func
return	return x of the QRCode, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of QRCode

item	description
type	func
return	return y of the QRCode, type is int
static	False

C++ defination code:

int y()

w

def w(self) -> int

get w of QRCode

item	description
type	func
return	return w of the QRCode, type is int
static	False

C++ defination code:

int w()

h

def h(self) -> int

get h of QRCode

item	description
type	func
return	return h of the QRCode, type is int
static	False

C++ defination code:

int h()

payload

def payload(self) -> str

get QRCode payload

item	description
type	func
return	return area of the QRCode
static	False

C++ defination code:

std::string payload()

version

def version(self) -> int

get QRCode version

item	description
type	func
return	return version of the QRCode
static	False

C++ defination code:

int version()

ecc_level

def ecc_level(self) -> int

get QRCode error correction level

item	description
type	func
return	return error correction level of the QRCode
static	False

C++ defination code:

int ecc_level()

mask

def mask(self) -> int

get QRCode mask

item	description
type	func
return	return mask of the QRCode
static	False

C++ defination code:

int mask()

data_type

def data_type(self) -> int

get QRCode dataType

item	description
type	func
return	return mask of the QRCode
static	False

C++ defination code:

int data_type()

eci

def eci(self) -> int

get QRCode eci

item	description
type	func
return	return data of the QRCode
static	False

C++ defination code:

int eci()

is_numeric

def is_numeric(self) -> bool

check QRCode is numeric

item	description
type	func
return	return true if the result type of the QRCode is numeric
static	False

C++ defination code:

bool is_numeric()

is_alphanumeric

def is_alphanumeric(self) -> bool

check QRCode is alphanumeric

item	description
type	func
return	return true if the result type of the QRCode is alphanumeric
static	False

C++ defination code:

bool is_alphanumeric()

is_binary

def is_binary(self) -> bool

check QRCode is binary

item	description
type	func
return	return true if the result type of the QRCode is binary
static	False

C++ defination code:

bool is_binary()

is_kanji

def is_kanji(self) -> bool

check QRCode is kanji

item	description
type	func
return	return true if the result type of the QRCode is kanji
static	False

C++ defination code:

bool is_kanji()

AprilTag

AprilTag class

C++ defination code:

class AprilTag

__init__

def __init__(self, rect: list[int], corners: list[list[int]], id: int, famliy: int, centroid_x: float, centroid_y: float, rotation: float, decision_margin: float, hamming: int, goodness: float, x_translation: float, y_translation: float, z_translation: float, x_rotation: float, y_rotation: float, z_rotation: float) -> None

AprilTag constructor

item	description
type	func
param	rect: Inlucdes the top-left corner and the width and height of the rectangle. format is {x, y, w, h}, type is std::vector corners: Includes the four corners of the rectangle. format is {{x0, y0}, {x1, y1}, {x2, y2}, {x3, y3}}, type is std::vector<std::vector> id: The id of the AprilTag famliy: The family of the AprilTag centroid_x: The x coordinate of the center of the AprilTag centroid_y: The y coordinate of the center of the AprilTag rotation: The rotation of the AprilTag decision_margin: The decision_margin of the AprilTag hamming: The hamming of the AprilTag goodness: The goodness of the AprilTag x_translation: The x_translation of the AprilTag y_translation: The y_translation of the AprilTag z_translation: The z_translation of the AprilTag x_rotation: The x_rotation of the AprilTag y_rotation: The y_rotation of the AprilTag z_rotation: The z_rotation of the AprilTag
static	False

C++ defination code:

AprilTag(std::vector<int> &rect, std::vector<std::vector<int>> &corners, int id, int famliy, float centroid_x, float centroid_y, float rotation, float decision_margin, int hamming, float goodness, float x_translation, float y_translation, float z_translation, float x_rotation, float y_rotation, float z_rotation)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] Returns the apriltag’s bounding box x coordinate [1] Returns the apriltag’s bounding box y coordinate [2] Returns the apriltag’s bounding box w coordinate [3] Returns the apriltag’s bounding box h coordinate [4] Returns the apriltag’s id [5] Returns the apriltag’s family [6] Not support [7] Not support [8] Not support [9] Not support [10] Returns the apriltag’s hamming [11] Not support [12] Not support [13] Not support [14] Not support [15] Not support [16] Not support [17] Not support
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get coordinate of AprilTag

item	description
type	func
return	return the coordinate of the AprilTag.
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

rect

def rect(self) -> list[int]

get rectangle of AprilTag

item	description
type	func
return	return the rectangle of the AprilTag. format is {x, y, w, h}, type is std::vector
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get x of AprilTag

item	description
type	func
return	return x of the AprilTag, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of AprilTag

item	description
type	func
return	return y of the AprilTag, type is int
static	False

C++ defination code:

int y()

w

def w(self) -> int

get w of AprilTag

item	description
type	func
return	return w of the AprilTag, type is int
static	False

C++ defination code:

int w()

h

def h(self) -> int

get h of AprilTag

item	description
type	func
return	return h of the AprilTag, type is int
static	False

C++ defination code:

int h()

id

def id(self) -> int

get id of AprilTag

item	description
type	func
return	return id of the AprilTag, type is int
static	False

C++ defination code:

int id()

family

def family(self) -> int

get family of AprilTag

item	description
type	func
return	return family of the AprilTag, type is int
static	False

C++ defination code:

int family()

cx

def cx(self) -> int

get cx of AprilTag

item	description
type	func
return	return cx of the AprilTag, type is int
static	False

C++ defination code:

int cx()

cxf

def cxf(self) -> float

get cxf of AprilTag

item	description
type	func
return	return cxf of the AprilTag, type is float
static	False

C++ defination code:

float cxf()

cy

def cy(self) -> int

get cy of AprilTag

item	description
type	func
return	return cy of the AprilTag, type is int
static	False

C++ defination code:

int cy()

cyf

def cyf(self) -> float

get cyf of AprilTag

item	description
type	func
return	return cyf of the AprilTag, type is float
static	False

C++ defination code:

float cyf()

rotation

def rotation(self) -> float

get rotation of AprilTag

item	description
type	func
return	return rotation of the AprilTag, type is float
static	False

C++ defination code:

float rotation()

decision_margin

def decision_margin(self) -> float

Get decision_margin of AprilTag

item	description
type	func
return	Returns the quality of the apriltag match (0.0 - 1.0) where 1.0 is the best.
static	False

C++ defination code:

float decision_margin()

hamming

def hamming(self) -> int

get hamming of AprilTag

item	description
type	func
return	Returns the number of accepted bit errors for this tag. return 0, means 0 bit errors will be accepted. 1 is TAG25H7, means up to 1 bit error may be accepted 2 is TAG25H9, means up to 3 bit errors may be accepted 3 is TAG36H10, means up to 3 bit errors may be accepted 4 is TAG36H11, means up to 4 bit errors may be accepted 5 is ARTOOLKIT, means 0 bit errors will be accepted
static	False

C++ defination code:

int hamming()

goodness

def goodness(self) -> float

get goodness of AprilTag

item	description
type	func
return	return goodness of the AprilTag, type is float Note: This value is always 0.0 for now.
static	False

C++ defination code:

float goodness()

x_translation

def x_translation(self) -> float

get x_translation of AprilTag

item	description
type	func
return	return x_translation of the AprilTag, type is float
static	False

C++ defination code:

float x_translation()

y_translation

def y_translation(self) -> float

get y_translation of AprilTag

item	description
type	func
return	return y_translation of the AprilTag, type is float
static	False

C++ defination code:

float y_translation()

z_translation

def z_translation(self) -> float

get z_translation of AprilTag

item	description
type	func
return	return z_translation of the AprilTag, type is float
static	False

C++ defination code:

float z_translation()

x_rotation

def x_rotation(self) -> float

get x_rotation of AprilTag

item	description
type	func
return	return x_rotation of the AprilTag, type is float
static	False

C++ defination code:

float x_rotation()

y_rotation

def y_rotation(self) -> float

get y_rotation of AprilTag

item	description
type	func
return	return y_rotation of the AprilTag, type is float
static	False

C++ defination code:

float y_rotation()

z_rotation

def z_rotation(self) -> float

get z_rotation of AprilTag

item	description
type	func
return	return z_rotation of the AprilTag, type is float
static	False

C++ defination code:

float z_rotation()

DataMatrix

DataMatrix class

C++ defination code:

class DataMatrix

__init__

def __init__(self, rect: list[int], corners: list[list[int]], payload: str, rotation: float, rows: int, columns: int, capacity: int, padding: int) -> None

DataMatrix constructor

item	description
type	func
param	rect: Inlucdes the top-left corner and the width and height of the rectangle. format is {x, y, w, h}, type is std::vector corners: Includes the four corners of the rectangle. format is {{x0, y0}, {x1, y1}, {x2, y2}, {x3, y3}}, type is std::vector<std::vector> payload: The payload of the DataMatrix rotation: The rotation of the DataMatrix rows: The rows of the DataMatrix columns: The columns of the DataMatrix capacity: The capacity of the DataMatrix padding: The padding of the DataMatrix
static	False

C++ defination code:

DataMatrix(std::vector<int> &rect, std::vector<std::vector<int>> &corners, std::string &payload, float rotation, int rows, int columns, int capacity, int padding)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] get x of DataMatrix [1] get y of DataMatrix [2] get w of DataMatrix [3] get h of DataMatrix [4] Not support this index, try to use payload() method [5] Not support this index, try to use rotation() method [6] get rows of DataMatrix [7] get columns of DataMatrix [8] get capacity of DataMatrix [9] get padding of DataMatrix
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get coordinate of DataMatrix

item	description
type	func
return	return the coordinate of the DataMatrix.
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

rect

def rect(self) -> list[int]

get rectangle of DataMatrix

item	description
type	func
return	return the rectangle of the DataMatrix. format is {x, y, w, h}, type is std::vector
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get x of DataMatrix

item	description
type	func
return	return x of the DataMatrix, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of DataMatrix

item	description
type	func
return	return y of the DataMatrix, type is int
static	False

C++ defination code:

int y()

w

def w(self) -> int

get w of DataMatrix

item	description
type	func
return	return w of the DataMatrix, type is int
static	False

C++ defination code:

int w()

h

def h(self) -> int

get h of DataMatrix

item	description
type	func
return	return h of the DataMatrix, type is int
static	False

C++ defination code:

int h()

payload

def payload(self) -> str

get payload of DataMatrix

item	description
type	func
return	return payload of the DataMatrix, type is std::string
static	False

C++ defination code:

std::string payload()

rotation

def rotation(self) -> float

get rotation of DataMatrix

item	description
type	func
return	return rotation of the DataMatrix, type is float
static	False

C++ defination code:

float rotation()

rows

def rows(self) -> int

get rows of DataMatrix

item	description
type	func
return	return rows of the DataMatrix, type is int
static	False

C++ defination code:

int rows()

columns

def columns(self) -> int

get columns of DataMatrix

item	description
type	func
return	return columns of the DataMatrix, type is int
static	False

C++ defination code:

int columns()

capacity

def capacity(self) -> int

get capacity of DataMatrix

item	description
type	func
return	returns how many characters could fit in this data matrix, type is int
static	False

C++ defination code:

int capacity()

padding

def padding(self) -> int

get padding of DataMatrix

item	description
type	func
return	returns how many unused characters are in this data matrix, type is int
static	False

C++ defination code:

int padding()

BarCode

BarCode class

C++ defination code:

class BarCode

__init__

def __init__(self, rect: list[int], corners: list[list[int]], payload: str, type: int, rotation: float, quality: int) -> None

BarCode constructor

item	description
type	func
param	rect: Inlucdes the top-left corner and the width and height of the rectangle. format is {x, y, w, h}, type is std::vector corners: Includes the four corners of the rectangle. format is {{x0, y0}, {x1, y1}, {x2, y2}, {x3, y3}}, type is std::vector<std::vector> payload: The payload of the BarCode type: The type of the BarCode rotation: The rotation of the BarCode quality: The quality of the BarCode
static	False

C++ defination code:

BarCode(std::vector<int> &rect, std::vector<std::vector<int>> &corners, std::string &payload, int type, float rotation, int quality)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: [0] get x of BarCode [1] get y of BarCode [2] get w of BarCode [3] get h of BarCode [4] Not support this index, try to use payload() method [5] get type of BarCode [6] Not support this index, try to use rotation() method [7] get quality of BarCode
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

corners

def corners(self) -> list[list[int]]

get coordinate of BarCode

item	description
type	func
return	return the coordinate of the BarCode.
static	False

C++ defination code:

std::vector<std::vector<int>> corners()

rect

def rect(self) -> list[int]

get rectangle of BarCode

item	description
type	func
return	return the rectangle of the BarCode. format is {x, y, w, h}, type is std::vector
static	False

C++ defination code:

std::vector<int> rect()

x

def x(self) -> int

get x of BarCode

item	description
type	func
return	return x of the BarCode, type is int
static	False

C++ defination code:

int x()

y

def y(self) -> int

get y of BarCode

item	description
type	func
return	return y of the BarCode, type is int
static	False

C++ defination code:

int y()

w

def w(self) -> int

get w of BarCode

item	description
type	func
return	return w of the BarCode, type is int
static	False

C++ defination code:

int w()

h

def h(self) -> int

get h of BarCode

item	description
type	func
return	return h of the BarCode, type is int
static	False

C++ defination code:

int h()

payload

def payload(self) -> str

get payload of BarCode

item	description
type	func
return	return payload of the BarCode, type is std::string
static	False

C++ defination code:

std::string payload()

type

def type(self) -> int

get type of BarCode

item	description
type	func
return	return type of the BarCode, type is int
static	False

C++ defination code:

int type()

rotation

def rotation(self) -> float

get rotation of BarCode

item	description
type	func
return	return rotation of the BarCode, type is float. FIXME: always return 0.0
static	False

C++ defination code:

float rotation()

quality

def quality(self) -> int

get quality of BarCode

item	description
type	func
return	return quality of the BarCode, type is int
static	False

C++ defination code:

int quality()

Statistics

Statistics class

C++ defination code:

class Statistics

__init__

def __init__(self, format: Format, l_statistics: list[int], a_statistics: list[int], b_statistics: list[int]) -> None

Statistics constructor

item	description
type	func
param	format: The statistics source image format l_statistics: The statistics of the L channel. format is {mean, median, mode, std_dev, min, max, lq, uq}, type is std::vector a_statistics: The statistics of the A channel. format is {mean, median, mode, std_dev, min, max, lq, uq}, type is std::vector b_statistics: The statistics of the B channel. format is {mean, median, mode, std_dev, min, max, lq, uq}, type is std::vector
static	False

C++ defination code:

Statistics(image::Format format, std::vector<int> &l_statistics, std::vector<int> &a_statistics, std::vector<int> &b_statistics)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: array index
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

format

def format(self) -> Format

get format of Statistics source image

item	description
type	func
return	return format of the Statistics source image, type is image::Format
static	False

C++ defination code:

image::Format format()

l_mean

def l_mean(self) -> int

get L channel mean

item	description
type	func
return	return L channel mean, type is int
static	False

C++ defination code:

int l_mean()

l_median

def l_median(self) -> int

get L channel median

item	description
type	func
return	return L channel median, type is int
static	False

C++ defination code:

int l_median()

l_mode

def l_mode(self) -> int

get L channel mode

item	description
type	func
return	return L channel mode, type is int
static	False

C++ defination code:

int l_mode()

l_std_dev

def l_std_dev(self) -> int

get L channel std_dev

item	description
type	func
return	return L channel std_dev, type is int
static	False

C++ defination code:

int l_std_dev()

l_min

def l_min(self) -> int

get L channel min

item	description
type	func
return	return L channel min, type is int
static	False

C++ defination code:

int l_min()

l_max

def l_max(self) -> int

get L channel max

item	description
type	func
return	return L channel max, type is int
static	False

C++ defination code:

int l_max()

l_lq

def l_lq(self) -> int

get L channel lq

item	description
type	func
return	return L channel lq, type is int
static	False

C++ defination code:

int l_lq()

l_uq

def l_uq(self) -> int

get L channel uq

item	description
type	func
return	return L channel uq, type is int
static	False

C++ defination code:

int l_uq()

a_mean

def a_mean(self) -> int

get A channel mean

item	description
type	func
return	return A channel mean, type is int
static	False

C++ defination code:

int a_mean()

a_median

def a_median(self) -> int

get A channea median

item	description
type	func
return	return A channel median, type is int
static	False

C++ defination code:

int a_median()

a_mode

def a_mode(self) -> int

get A channel mode

item	description
type	func
return	return A channel mode, type is int
static	False

C++ defination code:

int a_mode()

a_std_dev

def a_std_dev(self) -> int

get A channel std_dev

item	description
type	func
return	return A channel std_dev, type is int
static	False

C++ defination code:

int a_std_dev()

a_min

def a_min(self) -> int

get A channel min

item	description
type	func
return	return A channel min, type is int
static	False

C++ defination code:

int a_min()

a_max

def a_max(self) -> int

get A channel max

item	description
type	func
return	return A channel max, type is int
static	False

C++ defination code:

int a_max()

a_lq

def a_lq(self) -> int

get A channel lq

item	description
type	func
return	return A channel lq, type is int
static	False

C++ defination code:

int a_lq()

a_uq

def a_uq(self) -> int

get A channel uq

item	description
type	func
return	return A channel uq, type is int
static	False

C++ defination code:

int a_uq()

b_mean

def b_mean(self) -> int

get B channel mean

item	description
type	func
return	return B channel mean, type is int
static	False

C++ defination code:

int b_mean()

b_median

def b_median(self) -> int

get B channea median

item	description
type	func
return	return B channel median, type is int
static	False

C++ defination code:

int b_median()

b_mode

def b_mode(self) -> int

get B channel mode

item	description
type	func
return	return B channel mode, type is int
static	False

C++ defination code:

int b_mode()

b_std_dev

def b_std_dev(self) -> int

get B channel std_dev

item	description
type	func
return	return B channel std_dev, type is int
static	False

C++ defination code:

int b_std_dev()

b_min

def b_min(self) -> int

get B channel min

item	description
type	func
return	return B channel min, type is int
static	False

C++ defination code:

int b_min()

b_max

def b_max(self) -> int

get B channel max

item	description
type	func
return	return B channel max, type is int
static	False

C++ defination code:

int b_max()

b_lq

def b_lq(self) -> int

get B channel lq

item	description
type	func
return	return B channel lq, type is int
static	False

C++ defination code:

int b_lq()

b_uq

def b_uq(self) -> int

get B channel uq

item	description
type	func
return	return B channel uq, type is int
static	False

C++ defination code:

int b_uq()

Displacement

Displacement class

C++ defination code:

class Displacement

__init__

def __init__(self, x_translation: float, y_translation: float, rotation: float, scale: float, response: float) -> None

Displacement constructor

item	description
type	func
param	x_translation: The x_translation of the Displacement y_translation: The y_translation of the Displacement rotation: The rotation of the Displacement scale: The scale of the Displacement response: The response of the Displacement
static	False

C++ defination code:

Displacement(float x_translation, float y_translation, float rotation, float scale, float response)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
param	index: array index
return	int&
static	False

C++ defination code:

int &__getitem__(int index)

x_translation

def x_translation(self) -> float

get x_translation of Displacement

item	description
type	func
return	return x_translation of the Displacement, type is float
static	False

C++ defination code:

float x_translation()

y_translation

def y_translation(self) -> float

get y_translation of Displacement

item	description
type	func
return	return y_translation of the Displacement, type is float
static	False

C++ defination code:

float y_translation()

rotation

def rotation(self) -> float

get rotation of Displacement

item	description
type	func
return	return rotation of the Displacement, type is float
static	False

C++ defination code:

float rotation()

scale

def scale(self) -> float

get scale of Displacement

item	description
type	func
return	return scale of the Displacement, type is float
static	False

C++ defination code:

float scale()

response

def response(self) -> float

get response of Displacement

item	description
type	func
return	return response of the Displacement, type is float
static	False

C++ defination code:

float response()

Percentile

Percentile class

C++ defination code:

class Percentile

__init__

def __init__(self, l_value: int, a_value: int = 0, b_value: int = 0) -> None

Percentile constructor

item	description
type	func
param	l_value: for grayscale image, it is grayscale percentile value (between 0 and 255). for rgb888 image, it is l channel percentile value of lab (between 0 and 100). a_value: for rgb888 image, it is a channel percentile value of lab format(between -128 and 127). b_value: for rgb888 image, it is b channel percentile value of lab format(between -128 and 127).
static	False

C++ defination code:

Percentile(int l_value, int a_value = 0, int b_value = 0)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
static	False

C++ defination code:

int &__getitem__(int index)

value

def value(self) -> int

Return the grayscale percentile value (between 0 and 255).

item	description
type	func
return	returns grayscale percentile value
static	False

C++ defination code:

int value()

l_value

def l_value(self) -> int

Return the l channel percentile value of lab format (between 0 and 100).

item	description
type	func
return	returns l channel percentile value
static	False

C++ defination code:

int l_value()

a_value

def a_value(self) -> int

Return the a channel percentile value of lab format (between -128 and 127).

item	description
type	func
return	returns a channel percentile value
static	False

C++ defination code:

int a_value()

b_value

def b_value(self) -> int

Return the b channel percentile value of lab format (between -128 and 127).

item	description
type	func
return	returns b channel percentile value
static	False

C++ defination code:

int b_value()

Threshold

Threshold class

C++ defination code:

class Threshold

__init__

def __init__(self, l_value: int, a_value: int = 0, b_value: int = 0) -> None

Threshold constructor

item	description
type	func
param	l_value: for grayscale image, it is grayscale threshold value (between 0 and 255). for rgb888 image, it is l channel threshold value of lab (between 0 and 100). a_value: for rgb888 image, it is a channel threshold value of lab format(between -128 and 127). b_value: for rgb888 image, it is b channel threshold value of lab format(between -128 and 127).
static	False

C++ defination code:

Threshold(int l_value, int a_value = 0, int b_value = 0)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
static	False

C++ defination code:

int &__getitem__(int index)

value

def value(self) -> int

Return the grayscale threshold value (between 0 and 255).

item	description
type	func
return	returns grayscale threshold value
static	False

C++ defination code:

int value()

l_value

def l_value(self) -> int

Return the l channel threshold value of lab format (between 0 and 100).

item	description
type	func
return	returns l channel percentile value
static	False

C++ defination code:

int l_value()

a_value

def a_value(self) -> int

Return the a channel threshold value of lab format (between -128 and 127).

item	description
type	func
return	returns a channel percentile value
static	False

C++ defination code:

int a_value()

b_value

def b_value(self) -> int

Return the b channel threshold value of lab format (between -128 and 127).

item	description
type	func
return	returns b channel percentile value
static	False

C++ defination code:

int b_value()

Histogram

Histogram class

C++ defination code:

class Histogram

__init__

def __init__(self, l_bin: list[float], a_bin: list[float], b_bin: list[float], format: Format = ...) -> None

Histogram constructor

item	description
type	func
param	l_value: for grayscale image, it is grayscale threshold value list (the range of element values in the list is 0 and 255). for rgb888 image, it is l channel threshold value list of lab (the range of element values in the list is 0 and 100). a_value: for rgb888 image, it is a channel threshold value list of lab format(the range of element values in the list is -128 and 127). b_value: for rgb888 image, it is b channel threshold value list of lab format(the range of element values in the list is -128 and 127). format: format of the source image
static	False

C++ defination code:

Histogram(std::vector<float> l_bin, std::vector<float> a_bin, std::vector<float> b_bin, image::Format format = image::Format::FMT_RGB888)

__getitem__

def __getitem__(self, index: int) -> int

Subscript operator

item	description
type	func
static	False

C++ defination code:

int &__getitem__(int index)

bins

def bins(self) -> list[float]

Returns a list of floats for the grayscale histogram.

item	description
type	func
static	False

C++ defination code:

std::vector<float> bins()

l_bins

def l_bins(self) -> list[float]

Returns a list of floats for the RGB565 histogram LAB L channel.

item	description
type	func
static	False

C++ defination code:

std::vector<float> l_bins()

a_bins

def a_bins(self) -> list[float]

Returns a list of floats for the RGB565 histogram LAB A channel.

item	description
type	func
static	False

C++ defination code:

std::vector<float> a_bins()

b_bins

def b_bins(self) -> list[float]

Returns a list of floats for the RGB565 histogram LAB B channel.

item	description
type	func
static	False

C++ defination code:

std::vector<float> b_bins()

get_percentile

def get_percentile(self, percentile: float) -> Percentile

Computes the CDF of the histogram channels and returns a image::Percentile object

item	description
type	func
param	percentile: the values of the histogram at the passed in percentile (0.0 - 1.0) (float). So, if you pass in 0.1 this method will tell you (going from left-to-right in the histogram) what bin when summed into an accumulator caused the accumulator to cross 0.1. This is useful to determine min (with 0.1) and max (with 0.9) of a color distribution without outlier effects ruining your results for adaptive color tracking.
return	image::Percentile object
static	False

C++ defination code:

image::Percentile get_percentile(float percentile)

get_threshold

def get_threshold(self) -> Threshold

Uses Otsu’s Method to compute the optimal threshold values that split the histogram into two halves for each channel of the histogram and returns a image::Threshold object.

item	description
type	func
return	image::Threshold object
static	False

C++ defination code:

image::Threshold get_threshold()

get_statistics

def get_statistics(self) -> Statistics

Computes the mean, median, mode, standard deviation, min, max, lower quartile, and upper quartile of each color channel in the histogram and returns a image::Statistics object.

item	description
type	func
return	image::Statistics object
static	False

C++ defination code:

image::Statistics get_statistics()

LBPKeyPoint

LBPKeyPoint class

C++ defination code:

class LBPKeyPoint

__init__

def __init__(self, data: list[int]) -> None

LBPKeyPoint constructor

item	description
type	func
param	data: The data of the LBPKeyPoint
static	False

C++ defination code:

LBPKeyPoint(std::valarray<uint8_t> &data)

KeyPoint

KeyPoint class

C++ defination code:

class KeyPoint

__init__

def __init__(self, x: int, y: int, score: int, octave: int, angle: int, matched: int, desc: list[int]) -> None

KeyPoint constructor

item	description
type	func
param	x: The x of the KeyPoint y: The y of the KeyPoint score: The score of the KeyPoint octave: The octave of the KeyPoint angle: The angle of the KeyPoint matched: The matched of the KeyPoint desc: The desc of the KeyPoint
static	False

C++ defination code:

KeyPoint(uint16_t x, uint16_t y, uint16_t score, uint16_t octave, uint16_t angle, uint16_t matched, std::vector<uint8_t> &desc)

KPTMatch

KPTMatch class

C++ defination code:

class KPTMatch

__init__

def __init__(self, cx: int, cy: int, x: int, y: int, w: int, h: int, score: int, theta: int, match: int) -> None

KPTMatch constructor

item	description
type	func
param	cx: The cx of the KPTMatch cy: The cy of the KPTMatch x: The x of the KPTMatch y: The y of the KPTMatch w: The w of the KPTMatch h: The h of the KPTMatch score: The score of the KPTMatch theta: The theta of the KPTMatch match: The match of the KPTMatch
static	False

C++ defination code:

KPTMatch(int cx, int cy, int x, int y, int w, int h, int score, int theta, int match)

ORBKeyPoint

ORBKeyPoint class

C++ defination code:

class ORBKeyPoint

__init__

def __init__(self, data: list[KeyPoint], threshold: int, normalized: bool) -> None

ORBKeyPoint constructor

item	description
type	func
param	data: The data of the ORBKeyPoint threshold: The threshold of the ORBKeyPoint normalized: The normalized of the ORBKeyPoint
static	False

C++ defination code:

ORBKeyPoint(std::vector<image::KeyPoint> &data, int threshold, bool normalized)

get_data

def get_data(self) -> list[KeyPoint]

get data of ORBKeyPoint

item	description
type	func
return	return data of the ORBKeyPoint, type is std::vector
static	False

C++ defination code:

std::vector<image::KeyPoint> get_data()

HaarCascade

HaarCascade class

C++ defination code:

class HaarCascade

__init__

def __init__(self) -> None

HaarCascade constructor

item	description
type	func
param	data: The data of the HaarCascade threshold: The threshold of the HaarCascade normalized: The normalized of the HaarCascade
static	False

C++ defination code:

HaarCascade()

Color

Color class

C++ defination code:

class Color

__init__

def __init__(self, ch1: int, ch2: int = 0, ch3: int = 0, alpha: float = 0, format: Format = ...) -> None

Color constructor

item	description
type	func
param	alpha: alpha channel, value range: 0 ~ 1
static	False

C++ defination code:

Color(uint8_t ch1, uint8_t ch2 = 0, uint8_t ch3 = 0, float alpha = 0, image::Format format = image::FMT_GRAYSCALE)

r

Color red channel

item	description
type	var
static	False
readonly	False

C++ defination code:

uint8_t r

g

Color green channel

item	description
type	var
static	False
readonly	False

C++ defination code:

uint8_t g

b

Color blue channel

item	description
type	var
static	False
readonly	False

C++ defination code:

uint8_t b

alpha

Color alpha channel, value from 0.0 to 1.0, float value

item	description
type	var
static	False
readonly	False

C++ defination code:

float alpha

gray

Color gray channel

item	description
type	var
static	False
readonly	False

C++ defination code:

uint8_t gray

format

Color format

item	description
type	var
static	False
readonly	False

C++ defination code:

image::Format format

hex

def hex(self) -> int

Get color's hex value

item	description
type	func
static	False

C++ defination code:

uint32_t hex()

from_rgb

def from_rgb(r: int, g: int, b: int) -> Color

Create Color object from RGB channels

item	description
type	func
static	True

C++ defination code:

static image::Color from_rgb(uint8_t r, uint8_t g, uint8_t b)

from_bgr

def from_bgr(b: int, g: int, r: int) -> Color

Create Color object from BGR channels

item	description
type	func
static	True

C++ defination code:

static image::Color from_bgr(uint8_t b, uint8_t g, uint8_t r)

from_gray

def from_gray(gray: int) -> Color

Create Color object from gray channel

item	description
type	func
static	True

C++ defination code:

static image::Color from_gray(uint8_t gray)

from_rgba

def from_rgba(r: int, g: int, b: int, alpha: float) -> Color

Create Color object from RGBA channels

item	description
type	func
param	alpha: alpha channel, float value, value range: 0 ~ 1
static	True

C++ defination code:

static image::Color from_rgba(uint8_t r, uint8_t g, uint8_t b, float alpha)

from_bgra

def from_bgra(b: int, g: int, r: int, alpha: float) -> Color

Create Color object from BGRA channels

item	description
type	func
param	alpha: alpha channel, float value, value range: 0 ~ 1
static	True

C++ defination code:

static image::Color from_bgra(uint8_t b, uint8_t g, uint8_t r, float alpha)

from_hex

def from_hex(hex: int, format: Format) -> Color

Create Color object from hex value

item	description
type	func
param	hex: hex value, e.g. 0x0000FF00, lower address if first channel format: color format, @see image::Format
static	True

C++ defination code:

static image::Color from_hex(uint32_t hex, image::Format &format)

to_format

def to_format(self, format: Format) -> None

Convert Color format

item	description
type	func
param	format: format want to convert to, @see image::Format, only support RGB888, BGR888, RGBA8888, BGRA8888, GRAYSCALE.
static	False

C++ defination code:

void to_format(const image::Format &format)

to_format2

def to_format2(self, format: Format) -> Color

Convert color format and return a new Color object

item	description
type	func
param	format: format want to convert to, @see image::Format, only support RGB888, BGR888, RGBA8888, BGRA8888, GRAYSCALE.
return	new Color object, you need to delete it manually in C++.
static	False

C++ defination code:

image::Color *to_format2(const image::Format &format)

Image

Image class

C++ defination code:

class Image

__init__

def __init__(self, width: int, height: int, format: Format = ...) -> None

Image constructor

item	description
type	func
param	width: image width, should > 0 height: image height, should > 0 format: image format @see image::Format
static	False

C++ defination code:

Image(int width, int height, image::Format format = image::Format::FMT_RGB888)

format

def format(self) -> Format

Get image's format

item	description
type	func
see	image.Format
static	False

C++ defination code:

image::Format format()

size

def size(self) -> Size

Get image's size, [width, height]

item	description
type	func
static	False

C++ defination code:

image::Size size()

data_size

def data_size(self) -> int

Get image's data size

item	description
type	func
static	False

C++ defination code:

int data_size()

width

def width(self) -> int

Get image's width

item	description
type	func
static	False

C++ defination code:

int width()

height

def height(self) -> int

Get image's height

item	description
type	func
static	False

C++ defination code:

int height()

data

def data(self) -> capsule

Get image's data pointer.\nIn MaixPy is capsule object.

item	description
type	func
static	False

C++ defination code:

void *data()

__str__

def __str__(self) -> str

To string method

item	description
type	func
static	False

C++ defination code:

std::string __str__()

to_str

def to_str(self) -> str

To string method

item	description
type	func
static	False

C++ defination code:

std::string to_str()

get_pixel

def get_pixel(self, x: int, y: int, rgbtuple: bool = False) -> list[int]

Get pixel of image

item	description
type	func
param	x: pixel's coordinate x. x must less than image's width y: pixel's coordinate y. y must less than image's height rgbtuple: switch return value method. rgbtuple decides whether to split the return or not. default is false.
return	pixel value, According to image format and rgbtuple, return different value: format is FMT_RGB888, rgbtuple is true, return [R, G, B]; rgbtuple is false, return [RGB] foramt is FMT_BGR888, rgbtuple is true, return [B, G, R]; rgbtuple is false, return [BGR] format is FMT_GRAYSCALE, return [GRAY];
static	False

C++ defination code:

std::vector<int> get_pixel(int x, int y, bool rgbtuple = false)

set_pixel

def set_pixel(self, x: int, y: int, pixel: list[int]) -> maix.err.Err

Set pixel of image

item	description
type	func
param	x: pixel's coordinate x. x must less than image's width y: pixel's coordinate y. y must less than image's height pixel: pixel value, according to image format and size of pixel, has different operation: format is FMT_RGB888, pixel size must be 1 or 3, if size is 1, will split pixel[0] to [R, G, B]; if size is 3, will use pixel directly format is FMT_BGR888, pixel size must be 1 or 3, if size is 1, will split pixel[0] to [B, G, R]; if size is 3, will use pixel directly format is FMT_GRAYSCALE, pixel size must be 1, will use pixel directly
return	error code, Err::ERR_NONE is ok, other is error
static	False

C++ defination code:

err::Err set_pixel(int x, int y, std::vector<int> pixel)

to_tensor

def to_tensor(self, chw: bool = False, copy: bool = True) -> maix.tensor.Tensor

Convert Image object to tensor::Tensor object

item	description
type	func
param	chw: if true, the shape of tensor is [C, H, W], else [H, W, C] copy: if true, will alloc memory for tensor data, else will use the memory of Image object
return	tensor::Tensor object pointer, an allocated tensor object
static	False

C++ defination code:

tensor::Tensor *to_tensor(bool chw = false, bool copy = true)

to_bytes

def to_bytes(*args, **kwargs)

Get image's data and convert to array bytes

item	description
type	func
param	copy: if true, will alloc memory and copy data to new buffer, else will use the memory of Image object, delete bytes object will not affect Image object， but delete Image object will make bytes object invalid, it may cause program crash !!!! So use this param carefully.
return	image's data bytes, need be delete by caller in C++.
static	False

C++ defination code:

Bytes *to_bytes(bool copy = true)

to_format

def to_format(self, format: Format) -> Image

Convert image to specific format

item	description
type	func
param	format: format want to convert to, @see image::Format, only support RGB888, BGR888, RGBA8888, BGRA8888, GRAYSCALE, JPEG.
return	new image object. Need be delete by caller in C++.
throw	err.Exception, if two images' format not support, or already the format, will raise exception
static	False

C++ defination code:

image::Image *to_format(const image::Format &format)

to_jpeg

def to_jpeg(self, quality: int = 95) -> Image

Convert image to jpeg

item	description
type	func
param	quality: the quality of jpg, default is 95. For MaixCAM supported range is (50, 100], if <= 50 will be fixed to 51.
return	new image object. Need be delete by caller in C++.
throw	err.Exception, if two images' format not support, or already the format, will raise exception
static	False

C++ defination code:

image::Image *to_jpeg(int quality = 95)

draw_image

def draw_image(self, x: int, y: int, img: Image) -> Image

Draw image on this image

item	description
type	func
param	x: left top corner of image point's coordinate x y: left top corner of image point's coordinate y img: image object to draw, the caller's channel must <= the args' channel, e.g. caller is RGB888, args is RGBA8888, will throw exception, but caller is RGBA8888, args is RGB888 or RGBA8888 is ok
return	this image object self
static	False

C++ defination code:

image::Image *draw_image(int x, int y, image::Image &img)

draw_rect

def draw_rect(self, x: int, y: int, w: int, h: int, color: Color, thickness: int = 1) -> Image

Fill rectangle color to image

item	description
type	func
param	x: left top corner of rectangle point's coordinate x y: left top corner of rectangle point's coordinate y w: rectangle width h: rectangle height color: rectangle color thickness: rectangle thickness(line width), by default(value is 1), -1 means fill rectangle
return	this image object self
static	False

C++ defination code:

image::Image *draw_rect(int x, int y, int w, int h, const image::Color &color, int thickness = 1)

draw_line

def draw_line(self, x1: int, y1: int, x2: int, y2: int, color: Color, thickness: int = 1) -> Image

Draw line on image

item	description
type	func
param	x1: start point's coordinate x y1: start point's coordinate y x2: end point's coordinate x y2: end point's coordinate y color: line color @see image::Color thickness: line thickness(line width), by default(value is 1)
return	this image object self
static	False

C++ defination code:

image::Image *draw_line(int x1, int y1, int x2, int y2, const image::Color &color, int thickness = 1)

draw_circle

def draw_circle(self, x: int, y: int, radius: int, color: Color, thickness: int = 1) -> Image

Draw circle on image

item	description
type	func
param	x: circle center point's coordinate x y: circle center point's coordinate y radius: circle radius color: circle color @see image::Color thickness: circle thickness(line width), by default(value is 1), -1 means fill circle
return	this image object self
static	False

C++ defination code:

image::Image *draw_circle(int x, int y, int radius, const image::Color &color, int thickness = 1)

draw_ellipse

def draw_ellipse(self, x: int, y: int, a: int, b: int, angle: float, start_angle: float, end_angle: float, color: Color, thickness: int = 1) -> Image

Draw ellipse on image

item	description
type	func
param	x: ellipse center point's coordinate x y: ellipse center point's coordinate y a: ellipse major axis length b: ellipse minor axis length angle: ellipse rotation angle start_angle: ellipse start angle end_angle: ellipse end angle color: ellipse color @see image::Color thickness: ellipse thickness(line width), by default(value is 1), -1 means fill ellipse
return	this image object self
static	False

C++ defination code:

image::Image *draw_ellipse(int x, int y, int a, int b, float angle, float start_angle, float end_angle, const image::Color &color, int thickness = 1)

draw_string

def draw_string(self, x: int, y: int, textstring: str, color: Color = ..., scale: float = 1, thickness: int = -1, wrap: bool = True, wrap_space: int = 4, font: str = '') -> Image

Draw text on image

item	description
type	func
param	x: text left top point's coordinate x y: text left top point's coordinate y string: text content color: text color @see image::Color, default is white scale: font scale, by default(value is 1) thickness: text thickness(line width), if negative, the glyph is filled, by default(value is -1) wrap: if true, will auto wrap text to next line if text width > image width, by default(value is true)
return	this image object self
static	False

C++ defination code:

image::Image *draw_string(int x, int y, const std::string &textstring, const image::Color &color = image::COLOR_WHITE, float scale = 1, int thickness = -1,
                                bool wrap = true, int wrap_space = 4, const std::string &font = "")

draw_cross

def draw_cross(self, x: int, y: int, color: Color, size: int = 5, thickness: int = 1) -> Image

Draw cross on image

item	description
type	func
param	x: cross center point's coordinate x y: cross center point's coordinate y color: cross color @see image::Color size: how long the lines of the cross extend, by default(value is 5). So the line length is 2 * size + thickness thickness: cross thickness(line width), by default(value is 1)
static	False

C++ defination code:

image::Image *draw_cross(int x, int y, const image::Color &color, int size = 5, int thickness = 1)

draw_arrow

def draw_arrow(self, x0: int, y0: int, x1: int, y1: int, color: Color, thickness: int = 1) -> Image

Draw arrow on image

item	description
type	func
param	x0: start coordinate of the arrow x0 y0: start coordinate of the arrow y0 x1: end coordinate of the arrow x1 y1: end coordinate of the arrow y1 color: cross color @see image::Color thickness: cross thickness(line width), by default(value is 1)
return	this image object self
static	False

C++ defination code:

image::Image *draw_arrow(int x0, int y0, int x1, int y1, const image::Color &color, int thickness = 1)

draw_edges

def draw_edges(self, corners: list[list[int]], color: Color, size: int = 0, thickness: int = 1, fill: bool = False) -> Image

Draw edges on image

item	description
type	func
param	corners: edges, [[x0, y0], [x1, y1], [x2, y2], [x3, y3]] color: edges color @see image::Color size: the circle of radius size. TODO: support in the feature thickness: edges thickness(line width), by default(value is 1) fill: if true, will fill edges, by default(value is false)
return	this image object self
static	False

C++ defination code:

image::Image *draw_edges(std::vector<std::vector<int>> corners, const image::Color &color, int size = 0, int thickness = 1, bool fill = false)

draw_keypoints

def draw_keypoints(self, keypoints: list[int], color: Color, size: int = 10, thickness: int = -1) -> Image

Draw keypoints on image

item	description
type	func
param	keypoints: keypoints, [x1, y1, x2, y2...] or [x, y, rotation_andle_in_degrees, x2, y2, rotation_andle_in_degrees2](TODO: rotation_andle_in_degrees support in the feature) color: keypoints color @see image::Color size: size of keypoints thickness: keypoints thickness(line width), by default(value is -1 means fill circle)
return	this image object self
static	False

C++ defination code:

image::Image *draw_keypoints(std::vector<int> keypoints, const image::Color &color, int size = 10, int thickness = -1)

resize

def resize(self, width: int, height: int, object_fit: Fit = ..., method: ResizeMethod = ...) -> Image

Resize image, will create a new resized image object

item	description
type	func
param	width: new width, if value is -1, will use height to calculate aspect ratio height: new height, if value is -1, will use width to calculate aspect ratio object_fit: fill, contain, cover, by default is fill method: resize method, by default is bilinear
return	Always return a new resized image object even size not change, So in C++ you should take care of the return value to avoid memory leak. And it's better to judge whether the size has changed before calling this function to make the program more efficient. e.g. if img->width() != width		img->height() != height: img = img->resize(width, height);
static	False

C++ defination code:

image::Image *resize(int width, int height, image::Fit object_fit = image::Fit::FIT_FILL, image::ResizeMethod method = image::ResizeMethod::NEAREST)

affine

def affine(self, src_points: list[int], dst_points: list[int], width: int = -1, height: int = -1, method: ResizeMethod = ...) -> Image

Affine transform image, will create a new transformed image object

item	description
type	func
param	src_points: three source points, [x1, y1, x2, y2, x3, y3] dst_points: three destination points, [x1, y1, x2, y2, x3, y3] width: new width, if value is -1, will use height to calculate aspect ratio height: new height, if value is -1, will use width to calculate aspect ratio method: resize method, by default is bilinear
return	new transformed image object
static	False

C++ defination code:

image::Image *affine(std::vector<int> src_points, std::vector<int> dst_points, int width = -1, int height = -1, image::ResizeMethod method = image::ResizeMethod::BILINEAR)

copy

def copy(self) -> Image

Copy image, will create a new copied image object

item	description
type	func
return	new copied image object
static	False

C++ defination code:

image::Image *copy()

crop

def crop(self, x: int, y: int, w: int, h: int) -> Image

Crop image, will create a new cropped image object

item	description
type	func
param	x: left top corner of crop rectangle point's coordinate x y: left top corner of crop rectangle point's coordinate y w: crop rectangle width h: crop rectangle height
return	new cropped image object
static	False

C++ defination code:

image::Image *crop(int x, int y, int w, int h)

rotate

def rotate(self, angle: float, width: int = -1, height: int = -1, method: ResizeMethod = ...) -> Image

Rotate image, will create a new rotated image object

item	description
type	func
param	angle: anti-clock wise rotate angle, if angle is 90 or 270, and width or height is -1, will swap width and height, or will throw exception width: new width, if value is -1, will use height to calculate aspect ratio height: new height, if value is -1, will use width to calculate aspect ratio method: resize method, by default is bilinear
return	new rotated image object
static	False

C++ defination code:

image::Image *rotate(float angle, int width = -1, int height = -1, image::ResizeMethod method = image::ResizeMethod::BILINEAR)

mean_pool

def mean_pool(self, x_div: int, y_div: int, copy: bool = False) -> Image

Finds the mean of x_div * y_div squares in the image and returns the modified image composed of the mean of each square.

item	description
type	func
param	x_div: The width of the squares. y_div: The height of the squares. copy: Select whether to return a new image or modify the original image. default is false. If true, returns a new image composed of the mean of each square; If false, returns the modified image composed of the mean of each square.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mean_pool(int x_div, int y_div, bool copy = false)

midpoint_pool

def midpoint_pool(self, x_div: int, y_div: int, bias: float = 0.5, copy: bool = False) -> Image

Finds the midpoint of x_div * y_div squares in the image and returns the modified image composed of the mean of each square.

item	description
type	func
param	x_div: The width of the squares. y_div: The height of the squares. bias: The bias of the midpoint. default is 0.5. midpoint value is equal to (max * bias + min * (1 - bias)) copy: Select whether to return a new image or modify the original image. default is false. If true, returns a new image composed of the midpoint of each square; If false, returns the modified image composed of the midpoint of each square.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *midpoint_pool(int x_div, int y_div, double bias = 0.5, bool copy = false)

compress

def compress(self, quality: int = 95) -> Image

JPEG compresses the image in place, the same as to_jpeg functioin, it's recommend to use to_jpeg instead.

item	description
type	func
param	quality: The quality of the compressed image. default is 95.
return	Returns the compressed JPEG image
static	False

C++ defination code:

image::Image *compress(int quality = 95)

clear

def clear(self, mask: Image = None) -> Image

Sets all pixels in the image to zero

item	description
type	func
param	mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *clear(image::Image *mask = nullptr)

mask_rectange

def mask_rectange(self, x: int = -1, y: int = -1, w: int = -1, h: int = -1) -> Image

Zeros a rectangular part of the image. If no arguments are supplied this method zeros the center of the image.

item	description
type	func
param	x: The x coordinate of the top left corner of the rectangle. y: The y coordinate of the top left corner of the rectangle. w: The width of the rectangle. h: The height of the rectangle.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mask_rectange(int x = -1, int y = -1, int w = -1, int h = -1)

mask_circle

def mask_circle(self, x: int = -1, y: int = -1, radius: int = -1) -> Image

Zeros a circular part of the image. If no arguments are supplied this method zeros the center of the image.

item	description
type	func
param	x: The x coordinate of the center of the circle. y: The y coordinate of the center of the circle. radius: The radius of the circle.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mask_circle(int x = -1, int y = -1, int radius = -1)

mask_ellipse

def mask_ellipse(self, x: int = -1, y: int = -1, radius_x: int = -1, radius_y: int = -1, rotation_angle_in_degrees: float = 0) -> Image

Zeros a ellipse part of the image. If no arguments are supplied this method zeros the center of the image.

item	description
type	func
param	x: The x coordinate of the center of the ellipse. y: The y coordinate of the center of the ellipse. radius_x: The radius of the ellipse in the x direction. radius_y: The radius of the ellipse in the y direction. rotation_angle_in_degrees: The rotation angle of the ellipse in degrees.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mask_ellipse(int x = -1, int y = -1, int radius_x = -1, int radius_y = -1, float rotation_angle_in_degrees = 0)

binary

def binary(self, thresholds: list[list[int]] = [], invert: bool = False, zero: bool = False, mask: Image = None, to_bitmap: bool = False, copy: bool = False) -> Image

Sets all pixels in the image to black or white depending on if the pixel is inside of a threshold in the threshold list thresholds or not.

item	description
type	func
note	For GRAYSCALE format, Lmin and Lmax range is [0, 255]. For RGB888 format, Lmin and Lmax range is [0, 100].
param	thresholds: You can define multiple thresholds. For GRAYSCALE format, you can use {{Lmin, Lmax}, ...} to define one or more thresholds. For RGB888 format, you can use {{Lmin, Lmax, Amin, Amax, Bmin, Bmax}, ...} to define one or more thresholds. Where the upper case L,A,B represent the L,A,B channels of the LAB image format, and min, max represent the minimum and maximum values of the corresponding channels. invert: If true, the thresholds will be inverted before the operation. default is false. zero: If zero is true, the image will be set the pixels within the threshold to 0, other pixels remain unchanged. If zero is false, the image will be set to black or white. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None. to_bitmap: If true, the image will be converted to a bitmap image before thresholding. default is false. TODO: support in the feature copy: Select whether to return a new image or modify the original image. default is false.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *binary(std::vector<std::vector<int>> thresholds = std::vector<std::vector<int>>(), bool invert = false, bool zero = false, image::Image *mask = nullptr, bool to_bitmap = false, bool copy = false)

invert

def invert(self) -> Image

Inverts the image in place.

item	description
type	func
return	Returns the image after the operation is completed
static	False

C++ defination code:

image::Image *invert()

b_and

def b_and(self, other: Image, mask: Image = None) -> Image

Performs a bitwise and operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_and(image::Image *other, image::Image *mask = nullptr)

b_nand

def b_nand(self, other: Image, mask: Image = None) -> Image

Performs a bitwise nand operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_nand(image::Image *other, image::Image *mask = nullptr)

b_or

def b_or(self, other: Image, mask: Image = None) -> Image

Performs a bitwise or operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_or(image::Image *other, image::Image *mask = nullptr)

b_nor

def b_nor(self, other: Image, mask: Image = None) -> Image

Performs a bitwise nor operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_nor(image::Image *other, image::Image *mask = nullptr)

b_xor

def b_xor(self, other: Image, mask: Image = None) -> Image

Performs a bitwise xor operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_xor(image::Image *other, image::Image *mask = nullptr)

b_xnor

def b_xnor(self, other: Image, mask: Image = None) -> Image

Performs a bitwise xnor operation between the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *b_xnor(image::Image *other, image::Image *mask = nullptr)

awb

def awb(self, max: bool = False) -> Image

Performs an auto white balance operation on the image. TODO: support in the feature

item	description
type	func
param	max: if True uses the white-patch algorithm instead. default is false.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *awb(bool max = false)

ccm

def ccm(self, matrix: list[float]) -> Image

Multiples the passed (3x3) or (4x3) floating-point color-correction-matrix with the image.\nnote: Grayscale format is not support.

item	description
type	func
param	matrix: The color correction matrix to use. 3x3 or 4x3 matrix. Weights may either be positive or negative, and the sum of each column in the 3x3 matrix should generally be 1. example: { 1, 0, 0, 0, 1, 0, 0, 0, 1, } Where the last row of the 4x3 matrix is an offset per color channel. If you add an offset you may wish to make the weights sum to less than 1 to account for the offset. example: { 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, }
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *ccm(std::vector<float> &matrix)

gamma

def gamma(self, gamma: float = 1.0, contrast: float = 1.0, brightness: float = 0.0) -> Image

Quickly changes the image gamma, contrast, and brightness. Create a array whose size is usually 255,\nand use the parameters gamma, contrast, and brightness to calculate the value of the array, and then map the\nimage pixel value through the value of the array.\nThe calculation method for array is: array[array_idx] = (powf((array_idx / 255.0), (1 / gamma)) * contrast + brightness) * scale,\npowf is a function used to calculate floating point power.\narray is the array used for mapping.\narray_idx is the index of the array, the maximum value is determined according to the image format, usually 255.\nscale is a constant, the value is determined by the image format, usually 255.\nMapping method:\nAssume that a pixel value in the image is 128, then map the pixel value to the value of array[128]\nUsers can adjust the value of the array through the gamma, contrast, and brightness parameters.

item	description
type	func
param	gamma: The contrast gamma greater than 1.0 makes the image darker in a non-linear manner while less than 1.0 makes the image brighter. default is 1.0. contrast: The contrast value greater than 1.0 makes the image brighter in a linear manner while less than 1.0 makes the image darker. default is 1.0. brightness: The brightness value greater than 0.0 makes the image brighter in a constant manner while less than 0.0 makes the image darker. default is 0.0.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *gamma(double gamma = 1.0, double contrast = 1.0, double brightness = 0.0)

gamma_corr

def gamma_corr(self, gamma: float, contrast: float = 1.0, brightness: float = 0.0) -> Image

Alias for Image.gamma.

item	description
type	func
param	gamma: The contrast gamma greater than 1.0 makes the image darker in a non-linear manner while less than 1.0 makes the image brighter. default is 1.0. contrast: The contrast value greater than 1.0 makes the image brighter in a linear manner while less than 1.0 makes the image darker. default is 1.0. brightness: The brightness value greater than 0.0 makes the image brighter in a constant manner while less than 0.0 makes the image darker. default is 0.0.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *gamma_corr(double gamma, double contrast = 1.0, double brightness = 0.0)

negate

def negate(self) -> Image

Flips (numerically inverts) all pixels values in an image

item	description
type	func
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *negate()

replace

def replace(self, other: Image = None, hmirror: bool = False, vflip: bool = False, transpose: bool = False, mask: Image = None) -> Image

Replaces all pixels in the image with the corresponding pixels in the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. hmirror: If true, the image will be horizontally mirrored before the operation. default is false. vflip: If true, the image will be vertically flipped before the operation. default is false. transpose: If true, the image can be used to rotate 90 degrees or 270 degrees. hmirror = false, vflip = false, transpose = false, the image will not be rotated. hmirror = false, vflip = true, transpose = true, the image will be rotated 90 degrees. hmirror = true, vflip = true, transpose = false, the image will be rotated 180 degrees. hmirror = true, vflip = false, transpose = true, the image will be rotated 270 degrees. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *replace(image::Image *other = nullptr, bool hmirror = false, bool vflip = false, bool transpose = false, image::Image *mask = nullptr)

set

def set(self, other: Image, hmirror: bool = False, vflip: bool = False, transpose: bool = False, mask: Image = None) -> Image

Alias for Image::replace.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. hmirror: If true, the image will be horizontally mirrored before the operation. default is false. vflip: If true, the image will be vertically flipped before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *set(image::Image *other, bool hmirror = false, bool vflip = false, bool transpose = false, image::Image *mask = nullptr)

add

def add(self, other: Image, mask: Image = None) -> Image

Adds the other image to the image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *add(image::Image *other, image::Image *mask = nullptr)

sub

def sub(self, other: Image, reverse: bool = False, mask: Image = None) -> Image

Subtracts the other image from the image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? reverse: If true, the image will be reversed before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *sub(image::Image *other, bool reverse = false, image::Image *mask = nullptr)

mul

def mul(self, other: Image, invert: bool = False, mask: Image = None) -> Image

Multiplies the image by the other image.\nNote: This method is meant for image blending and cannot multiply the pixels in the image by a scalar like 2.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? invert: If true, the image will be change the multiplication operation from ab to 1/((1/a)(1/b)). In particular, this lightens the image instead of darkening it (e.g. multiply versus burn operations). default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mul(image::Image *other, bool invert = false, image::Image *mask = nullptr)

div

def div(self, other: Image, invert: bool = False, mod: bool = False, mask: Image = None) -> Image

Divides the image by the other image.\nThis method is meant for image blending and cannot divide the pixels in the image by a scalar like 2.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. TODO: support path? invert: If true, the image will be change the division direction from a/b to b/a. default is false. mod: If true, the image will be change the division operation to the modulus operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *div(image::Image *other, bool invert = false, bool mod = false, image::Image *mask = nullptr)

min

def min(self, other: Image, mask: Image = None) -> Image

Caculate the minimum of each pixel in the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *min(image::Image *other, image::Image *mask = nullptr)

max

def max(self, other: Image, mask: Image = None) -> Image

Caculate the maximum of each pixel in the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *max(image::Image *other, image::Image *mask = nullptr)

difference

def difference(self, other: Image, mask: Image = None) -> Image

Caculate the absolute value of the difference between each pixel in the image and the other image.

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *difference(image::Image *other, image::Image *mask = nullptr)

blend

def blend(self, other: Image, alpha: int = 128, mask: Image = None) -> Image

Blends the image with the other image.\nres = alpha * this_img / 256 + (256 - alpha) * other_img / 256

item	description
type	func
param	other: The other image should be an image and should be the same size as the image being operated on. alpha: The alpha value of the blend, the value range is [0, 256],default is 128. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *blend(image::Image *other, int alpha = 128, image::Image *mask = nullptr)

histeq

def histeq(self, adaptive: bool = False, clip_limit: int = -1, mask: Image = None) -> Image

Runs the histogram equalization algorithm on the image.

item	description
type	func
param	adaptive: If true, an adaptive histogram equalization method will be run on the image instead which as generally better results than non-adaptive histogram qualization but a longer run time. default is false. clip_limit: Provides a way to limit the contrast of the adaptive histogram qualization. Use a small value for this, like 10, to produce good histogram equalized contrast limited images. default is -1. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *histeq(bool adaptive = false, int clip_limit = -1, image::Image *mask = nullptr)

mean

def mean(self, size: int, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Standard mean blurring filter using a box filter.\nThe parameters offset and invert are valid when threshold is True.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mean(int size, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

median

def median(self, size: int, percentile: float = 0.5, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Runs the median filter on the image. The median filter is the best filter for smoothing surfaces while preserving edges but it is very slow.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). percentile: This parameter controls the percentile of the value used in the kernel. You can set this to 0 for a min filter, 0.25 for a lower quartile filter, 0.75 for an upper quartile filter, and 1.0 for a max filter. default is 0.5. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *median(int size, double percentile = 0.5, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

mode

def mode(self, size: int, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Runs the mode filter on the image by replacing each pixel with the mode of their neighbors.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *mode(int size, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

midpoint

def midpoint(self, size: int, bias: float = 0.5, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Runs the midpoint filter on the image.This filter finds the midpoint (max * bias + min * (1 - bias)) of each pixel neighborhood in the image.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). bias: The bias of the midpoint. default is 0.5. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *midpoint(int size, double bias = 0.5, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

morph

def morph(self, size: int, kernel: list[int], mul: float = -1, add: float = 0.0, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Convolves the image by a filter kernel. This allows you to do general purpose convolutions on an image.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). kernel: The kernel used for convolution. The kernel should be a list of lists of numbers. The kernel should be the same size as the actual kernel size. mul: This parameter is used to multiply the convolved pixel results. default is auto. add: This parameter is the value to be added to each convolution pixel result. default is 0.0. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *morph(int size, std::vector<int> kernel, float mul = -1, float add = 0.0, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

gaussian

def gaussian(self, size: int, unsharp: bool = False, mul: float = -1, add: float = 0.0, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Convolves the image by a smoothing guassian kernel.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). unsharp: If true, this method will perform an unsharp mask operation instead of gaussian filtering operation, this improves the clarity of image edges. default is false. mul: This parameter is used to multiply the convolved pixel results. default is auto. add: This parameter is the value to be added to each convolution pixel result. default is 0.0. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *gaussian(int size, bool unsharp = false, float mul = -1, float add = 0.0, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

laplacian

def laplacian(self, size: int, sharpen: bool = False, mul: float = -1, add: float = 0.0, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Convolves the image by a edge detecting laplacian kernel.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). sharpen: If True, this method will sharpen the image instead of an unthresholded edge detection image. Then increase the kernel size to improve image clarity. default is false. mul: This parameter is used to multiply the convolved pixel results. default is auto. add: This parameter is the value to be added to each convolution pixel result. default is 0.0. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *laplacian(int size, bool sharpen = false, float mul = -1, float add = 0.0, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

bilateral

def bilateral(self, size: int, color_sigma: float = 0.1, space_sigma: float = 1, threshold: bool = False, offset: int = 0, invert: bool = False, mask: Image = None) -> Image

Convolves the image by a bilateral filter.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). color_sigma: Controls how closely colors are matched using the bilateral filter. default is 0.1. space_sigma: Controls how closely pixels space-wise are blurred with each other. default is 1. threshold: If true, which will enable adaptive thresholding of the image which sets pixels to white or black based on a pixel’s brightness in relation to the brightness of the kernel of pixels around them. default is false. offset: The larger the offset value, the lower brightness pixels on the original image will be set to white. default is 0. invert: If true, the image will be inverted before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *bilateral(int size, double color_sigma = 0.1, double space_sigma = 1, bool threshold = false, int offset = 0, bool invert = false, image::Image *mask = nullptr)

linpolar

def linpolar(self, reverse: bool = False) -> Image

Re-project’s and image from cartessian coordinates to linear polar coordinates.

item	description
type	func
param	reverse: If true, the image will be reverse polar transformed. default is false.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *linpolar(bool reverse = false)

logpolar

def logpolar(self, reverse: bool = False) -> Image

Re-project’s and image from cartessian coordinates to log polar coordinates.

item	description
type	func
param	reverse: If true, the image will be reverse polar transformed. default is false.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *logpolar(bool reverse = false)

lens_corr

def lens_corr(self, strength: float = 1.8, zoom: float = 1.0, x_corr: float = 0.0, y_corr: float = 0.0) -> Image

Performs a lens correction operation on the image. TODO: support in the feature

item	description
type	func
param	strength: The strength of the lens correction. default is 1.8. zoom: The zoom of the lens correction. default is 1.0. x_corr: The x correction of the lens correction. default is 0.0. y_corr: The y correction of the lens correction. default is 0.0.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *lens_corr(double strength = 1.8, double zoom = 1.0, double x_corr = 0.0, double y_corr = 0.0)

rotation_corr

def rotation_corr(self, x_rotation: float = 0.0, y_rotation: float = 0.0, z_rotation: float = 0.0, x_translation: float = 0.0, y_translation: float = 0.0, zoom: float = 1.0, fov: float = 60.0, corners: list[float] = []) -> Image

Performs a rotation correction operation on the image. TODO: support in the feature

item	description
type	func
param	x_rotation: The x rotation of the rotation correction. default is 0.0. y_rotation: The y rotation of the rotation correction. default is 0.0. z_rotation: The z rotation of the rotation correction. default is 0.0. x_translation: The x translation of the rotation correction. default is 0.0. y_translation: The y translation of the rotation correction. default is 0.0. zoom: The zoom of the rotation correction. default is 1.0. fov: The fov of the rotation correction. default is 60.0. corners: The corners of the rotation correction. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *rotation_corr(double x_rotation = 0.0, double y_rotation = 0.0, double z_rotation = 0.0, double x_translation = 0.0, double y_translation = 0.0, double zoom = 1.0, double fov = 60.0, std::vector<float> corners = std::vector<float>())

get_histogram

def get_histogram(self, thresholds: list[list[int]] = [], invert: bool = False, roi: list[int] = [], bins: int = -1, l_bins: int = 100, a_bins: int = 256, b_bins: int = 256, difference: Image = None) -> Histogram

Computes the normalized histogram on all color channels and returns a image::Histogram object.

item	description
type	func
note	For GRAYSCALE format, Lmin and Lmax range is [0, 255]. For RGB888 format, Lmin and Lmax range is [0, 100].
param	thresholds: You can define multiple thresholds. For GRAYSCALE format, you can use {{Lmin, Lmax}, ...} to define one or more thresholds. For RGB888 format, you can use {{Lmin, Lmax, Amin, Amax, Bmin, Bmax}, ...} to define one or more thresholds. Where the upper case L,A,B represent the L,A,B channels of the LAB image format, and min, max represent the minimum and maximum values of the corresponding channels. invert: If true, the thresholds will be inverted before the operation. default is false. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. bins: The number of bins to use for the histogram. In GRAYSCALE format, setting range is [2, 256], default is 100. In RGB888 format, setting range is [2, 100], default is 100. l_bins: The number of bins to use for the l channel of the histogram. Only valid in RGB888 format. If an invalid value is set, bins will be used instead. The setting range is [2, 100], default is 100. a_bins: The number of bins to use for the a channel of the histogram. Only valid in RGB888 format.The setting range is [2, 256], default is 256. b_bins: The number of bins to use for the b channel of the histogram. Only valid in RGB888 format. The setting range is [2, 256], default is 256. difference: difference may be set to an image object to cause this method to operate on the difference image between the current image and the difference image object. default is None.
return	Returns image::Histogram object
static	False

C++ defination code:

image::Histogram get_histogram(std::vector<std::vector<int>> thresholds = std::vector<std::vector<int>>(), bool invert = false, std::vector<int> roi = std::vector<int>(), int bins = -1, int l_bins = 100, int a_bins = 256, int b_bins = 256, image::Image *difference = nullptr)

get_statistics

def get_statistics(self, thresholds: list[list[int]] = [], invert: bool = False, roi: list[int] = [], bins: int = -1, l_bins: int = -1, a_bins: int = -1, b_bins: int = -1, difference: Image = None) -> Statistics

Gets the statistics of the image. TODO: support in the feature

item	description
type	func
note	For GRAYSCALE format, Lmin and Lmax range is [0, 255]. For RGB888 format, Lmin and Lmax range is [0, 100].
param	thresholds: You can define multiple thresholds. For GRAYSCALE format, you can use {{Lmin, Lmax}, ...} to define one or more thresholds. For RGB888 format, you can use {{Lmin, Lmax, Amin, Amax, Bmin, Bmax}, ...} to define one or more thresholds. Where the upper case L,A,B represent the L,A,B channels of the LAB image format, and min, max represent the minimum and maximum values of the corresponding channels. invert: If true, the image will be inverted before the operation. default is false. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. bins: The number of bins to use for the statistics. default is -1. l_bins: The number of bins to use for the l channel of the statistics. default is -1. a_bins: The number of bins to use for the a channel of the statistics. default is -1. b_bins: The number of bins to use for the b channel of the statistics. default is -1. difference: The difference image to use for the statistics. default is None.
return	Returns the statistics of the image
static	False

C++ defination code:

image::Statistics get_statistics(std::vector<std::vector<int>> thresholds = std::vector<std::vector<int>>(), bool invert = false, std::vector<int> roi = std::vector<int>(), int bins = -1, int l_bins = -1, int a_bins = -1, int b_bins = -1, image::Image *difference = nullptr)

get_regression

def get_regression(self, thresholds: list[list[int]] = [], invert: bool = False, roi: list[int] = [], x_stride: int = 2, y_stride: int = 1, area_threshold: int = 10, pixels_threshold: int = 10, robust: bool = False) -> list[Line]

Gets the regression of the image.

item	description
type	func
note	For GRAYSCALE format, Lmin and Lmax range is [0, 255]. For RGB888 format, Lmin and Lmax range is [0, 100].
param	thresholds: You can define multiple thresholds. For GRAYSCALE format, you can use {{Lmin, Lmax}, ...} to define one or more thresholds. For RGB888 format, you can use {{Lmin, Lmax, Amin, Amax, Bmin, Bmax}, ...} to define one or more thresholds. Where the upper case L,A,B represent the L,A,B channels of the LAB image format, and min, max represent the minimum and maximum values of the corresponding channels. invert: If true, the image will be inverted before the operation. default is false. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. x_stride: The x stride to use for the regression. default is 2. y_stride: The y stride to use for the regression. default is 1. area_threshold: The area threshold to use for the regression. default is 10. pixels_threshold: The pixels threshold to use for the regression. default is 10. robust: If true, the regression will be robust. default is false.
return	Returns the regression of the image
static	False

C++ defination code:

std::vector<image::Line> get_regression(std::vector<std::vector<int>> thresholds = std::vector<std::vector<int>>(), bool invert = false, std::vector<int> roi = std::vector<int>(), int x_stride = 2, int y_stride = 1, int area_threshold = 10, int pixels_threshold = 10, bool robust = false)

save

def save(self, path: str, quality: int = 95) -> maix.err.Err

Save image to file

item	description
type	func
param	path: file path quality: image quality, by default(value is 95), support jpeg and png format
return	error code, err::ERR_NONE is ok, other is error
static	False

C++ defination code:

err::Err save(const char *path, int quality = 95)

flood_fill

def flood_fill(self, x: int, y: int, seed_threshold: float = 0.05, floating_threshold: float = 0.05, color: Color = ..., invert: bool = False, clear_background: bool = False, mask: Image = None) -> Image

Flood fills a region of the image starting from location x, y.

item	description
type	func
param	x: The x coordinate of the seed point. y: The y coordinate of the seed point. seed_threshold: The seed_threshold value controls how different any pixel in the fill area may be from the original starting pixel. default is 0.05. floating_threshold: The floating_threshold value controls how different any pixel in the fill area may be from any neighbor pixels. default is 0.05. color: The color to fill the region with. default is white. invert: If true, the image will be inverted before the operation. default is false. clear_background: If true, the background will be cleared before the operation. default is false. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None. FIXME: the mask image works abnormally
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *flood_fill(int x, int y, float seed_threshold = 0.05, float floating_threshold = 0.05, image::Color color = image::COLOR_WHITE, bool invert = false, bool clear_background = false, image::Image *mask = nullptr)

erode

def erode(self, size: int, threshold: int = -1, mask: Image = None) -> Image

Erodes the image in place.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: The number of pixels in the kernel that are not 0. If it is less than or equal to the threshold, set the center pixel to black. default is (kernel_size - 1). mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *erode(int size, int threshold = -1, image::Image *mask = nullptr)

dilate

def dilate(self, size: int, threshold: int = 0, mask: Image = None) -> Image

Dilates the image in place.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: The number of pixels in the kernel that are not 0. If it is greater than or equal to the threshold, set the center pixel to white. default is 0. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *dilate(int size, int threshold = 0, image::Image *mask = nullptr)

open

def open(self, size: int, threshold: int = 0, mask: Image = None) -> Image

Performs erosion and dilation on an image in order.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: As the threshold for erosion and dilation, the actual threshold for erosion is (kernel_size - 1 - threshold), the actual threshold for dialation is threshold. default is 0. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *open(int size, int threshold = 0, image::Image *mask = nullptr)

close

def close(self, size: int, threshold: int = 0, mask: Image = None) -> Image

Performs dilation and erosion on an image in order.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: As the threshold for erosion and dilation, the actual threshold for erosion is (kernel_size - 1 - threshold), the actual threshold for dialation is threshold. default is 0. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *close(int size, int threshold = 0, image::Image *mask = nullptr)

top_hat

def top_hat(self, size: int, threshold: int = 0, mask: Image = None) -> Image

Returns the image difference of the image and Image.open()’ed image.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: As the threshold for open method. default is 0. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *top_hat(int size, int threshold = 0, image::Image *mask = nullptr)

black_hat

def black_hat(self, size: int, threshold: int = 0, mask: Image = None) -> Image

Returns the image difference of the image and Image.close()’ed image.

item	description
type	func
param	size: Kernel size. The actual kernel size is ((size * 2) + 1) * ((size * 2) + 1). Use 1(3x3 kernel), 2(5x5 kernel). threshold: As the threshold for close method. default is 0. mask: Mask is another image to use as a pixel level mask for the operation. The mask should be an image with just black or white pixels and should be the same size as the image being operated on. Only pixels set in the mask are modified. default is None.
return	Returns the image after the operation is completed.
static	False

C++ defination code:

image::Image *black_hat(int size, int threshold = 0, image::Image *mask = nullptr)

find_blobs

def find_blobs(self, thresholds: list[list[int]] = [], invert: bool = False, roi: list[int] = [], x_stride: int = 2, y_stride: int = 1, area_threshold: int = 10, pixels_threshold: int = 10, merge: bool = False, margin: int = 0, x_hist_bins_max: int = 0, y_hist_bins_max: int = 0) -> list[Blob]

Finds all blobs in the image and returns a list of image.Blob class which describe each Blob.\nPlease see the image.Blob object more more information.

item	description
type	func
note	For GRAYSCALE format, Lmin and Lmax range is [0, 255]. For RGB888 format, Lmin and Lmax range is [0, 100].
param	thresholds: You can define multiple thresholds. For GRAYSCALE format, you can use {{Lmin, Lmax}, ...} to define one or more thresholds. For RGB888 format, you can use {{Lmin, Lmax, Amin, Amax, Bmin, Bmax}, ...} to define one or more thresholds. Where the upper case L,A,B represent the L,A,B channels of the LAB image format, and min, max represent the minimum and maximum values of the corresponding channels. invert: if true, will invert thresholds before find blobs, default is false roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. x_stride: x stride is the number of x pixels to skip when doing the hough transform. default is 2 y_stride: y_stride is the number of y pixels to skip when doing the hough transform. default is 1 area_threshold: area threshold, if the blob area is smaller than area_threshold, the blob is not returned, default is 10 pixels_threshold: pixels threshold, if the blob pixels is smaller than area_threshold, the blob is not returned,, default is 10. when x_stride and y_stride is equal to 1, pixels_threshold is equivalent to area_threshold merge: if True merges all not filtered out blobs whos bounding rectangles intersect each other. default is false margin: margin can be used to increase or decrease the size of the bounding rectangles for blobs during the intersection test. For example, with a margin of 1 blobs whos bounding rectangles are 1 pixel away from each other will be merged. default is 0 x_hist_bins_max: if set to non-zero populates a histogram buffer in each blob object with an x_histogram projection of all columns in the object. This value then sets the number of bins for that projection. y_hist_bins_max: if set to non-zero populates a histogram buffer in each blob object with an y_histogram projection of all rows in the object. This value then sets the number of bins for that projection.
return	Return the blob when found blobs, format is (blob1, blob2, ...), you can use blob class methods to do more operations.
static	False

C++ defination code:

std::vector<image::Blob> find_blobs(std::vector<std::vector<int>> thresholds = std::vector<std::vector<int>>(), bool invert = false, std::vector<int> roi = std::vector<int>(), int x_stride = 2, int y_stride = 1, int area_threshold = 10, int pixels_threshold = 10, bool merge = false, int margin = 0, int x_hist_bins_max = 0, int y_hist_bins_max = 0)

find_lines

def find_lines(self, roi: list[int] = [], x_stride: int = 2, y_stride: int = 1, threshold: float = 1000, theta_margin: float = 25, rho_margin: float = 25) -> list[Line]

Find lines in image

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. x_stride: x stride is the number of x pixels to skip when doing the hough transform. default is 2 y_stride: y_stride is the number of y pixels to skip when doing the hough transform. default is 1 threshold: threshold threshold controls what lines are detected from the hough transform. Only lines with a magnitude greater than or equal to threshold are returned. The right value of threshold for your application is image dependent. default is 1000. theta_margin: theta_margin controls the merging of detected lines. default is 25. rho_margin: rho_margin controls the merging of detected lines. default is 25.
return	Return the line when found lines, format is (line1, line2, ...), you can use line class methods to do more operations
static	False

C++ defination code:

std::vector<image::Line> find_lines(std::vector<int> roi = std::vector<int>(), int x_stride = 2, int y_stride = 1, double threshold = 1000, double theta_margin = 25, double rho_margin = 25)

find_line_segments

def find_line_segments(self, roi: list[int] = [], merge_distance: int = 0, max_theta_difference: int = 15) -> list[Line]

Finds all line segments in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. merge_distance: The maximum distance between two lines to merge them. default is 0. max_theta_difference: The maximum difference between two lines to merge them. default is 15.
return	Return the line when found lines, format is (line1, line2, ...), you can use line class methods to do more operations
static	False

C++ defination code:

std::vector<image::Line> find_line_segments(std::vector<int> roi = std::vector<int>(), int merge_distance = 0, int max_theta_difference = 15)

find_circles

def find_circles(self, roi: list[int] = [], x_stride: int = 2, y_stride: int = 1, threshold: int = 2000, x_margin: int = 10, y_margin: int = 10, r_margin: int = 10, r_min: int = 2, r_max: int = -1, r_step: int = 2) -> list[Circle]

Find circles in image

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. x_stride: x stride is the number of x pixels to skip when doing the hough transform. default is 2 y_stride: y_stride is the number of y pixels to skip when doing the hough transform. default is 1 threshold: threshold controls what circles are detected from the hough transform. Only circles with a magnitude greater than or equal to threshold are returned. The right value of threshold for your application is image dependent. x_margin: x_margin controls the merging of detected circles. Circles which are x_margin, y_margin, and r_margin pixels apart are merged. default is 10 y_margin: y_margin controls the merging of detected circles. Circles which are x_margin, y_margin, and r_margin pixels apart are merged. default is 10 r_margin: r_margin controls the merging of detected circles. Circles which are x_margin, y_margin, and r_margin pixels apart are merged. default is 10 r_min: r_min controls the minimum circle radius detected. Increase this to speed up the algorithm. default is 2 r_max: r_max controls the maximum circle radius detected. Decrease this to speed up the algorithm. default is min(roi.w / 2, roi.h / 2) r_step: r_step controls how to step the radius detection by. default is 2.
return	Return the circle when found circles, format is (circle1, circle2, ...), you can use circle class methods to do more operations
static	False

C++ defination code:

std::vector<image::Circle> find_circles(std::vector<int> roi = std::vector<int>(), int x_stride = 2, int y_stride = 1, int threshold = 2000, int x_margin = 10, int y_margin = 10, int r_margin = 10, int r_min = 2, int r_max = -1, int r_step = 2)

find_rects

def find_rects(self, roi: list[int] = [], threshold: int = 10000) -> list[Rect]

Finds all rects in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. threshold: The threshold to use for the rects. default is 10000.
return	Returns the rects of the image
static	False

C++ defination code:

std::vector<image::Rect> find_rects(std::vector<int> roi = std::vector<int>(), int threshold = 10000)

find_qrcodes

def find_qrcodes(self, roi: list[int] = []) -> list[QRCode]

Finds all qrcodes in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image.
return	Returns the qrcodes of the image
static	False

C++ defination code:

std::vector<image::QRCode> find_qrcodes(std::vector<int> roi = std::vector<int>())

find_apriltags

def find_apriltags(self, roi: list[int] = [], families: ApriltagFamilies = ..., fx: float = -1, fy: float = -1, cx: int = -1, cy: int = -1) -> list[AprilTag]

Finds all apriltags in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. families: The families to use for the apriltags. default is TAG36H11. fx: The camera X focal length in pixels, default is -1. fy: The camera Y focal length in pixels, default is -1. cx: The camera X center in pixels, default is image.width / 2. cy: The camera Y center in pixels, default is image.height / 2.
return	Returns the apriltags of the image
static	False

C++ defination code:

std::vector<image::AprilTag> find_apriltags(std::vector<int> roi = std::vector<int>(), image::ApriltagFamilies families = image::ApriltagFamilies::TAG36H11, float fx = -1, float fy = -1, int cx = -1, int cy = -1)

find_datamatrices

def find_datamatrices(self, roi: list[int] = [], effort: int = 200) -> list[DataMatrix]

Finds all datamatrices in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. effort: Controls how much time to spend trying to find data matrix matches. default is 200.
return	Returns the datamatrices of the image
static	False

C++ defination code:

std::vector<image::DataMatrix> find_datamatrices(std::vector<int> roi = std::vector<int>(), int effort = 200)

find_barcodes

def find_barcodes(self, roi: list[int] = []) -> list[BarCode]

Finds all barcodes in the image.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image.
return	Returns the barcodes of the image
static	False

C++ defination code:

std::vector<image::BarCode> find_barcodes(std::vector<int> roi = std::vector<int>())

find_displacement

def find_displacement(self, template_image: Image, roi: list[int] = [], template_roi: list[int] = [], logpolar: bool = False) -> Displacement

Finds the displacement between the image and the template. TODO: support in the feature\nnote: this method must be used on power-of-2 image sizes

item	description
type	func
param	template_image: The template image. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. template_roi: The region-of-interest rectangle (x, y, w, h) to work in. If not specified, it is equal to the image rectangle. logpolar: If true, it will instead find rotation and scale changes between the two images. default is false.
return	Returns the displacement of the image
static	False

C++ defination code:

image::Displacement find_displacement(image::Image &template_image, std::vector<int> roi = std::vector<int>(), std::vector<int> template_roi = std::vector<int>(), bool logpolar = false)

find_template

def find_template(self, template_image: Image, threshold: float, roi: list[int] = [], step: int = 2, search: TemplateMatch = ...) -> list[int]

Finds the template in the image.

item	description
type	func
param	template_image: The template image. threshold: Threshold is floating point number (0.0-1.0) where a higher threshold prevents false positives while lowering the detection rate while a lower threshold does the opposite. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. Only valid in SEARCH_EX mode. step: The step size to use for the template. default is 2. Only valid in SEARCH_EX mode search: The search method to use for the template. default is SEARCH_EX.
return	Returns a bounding box tuple (x, y, w, h) for the matching location otherwise None.
static	False

C++ defination code:

std::vector<int> find_template(image::Image &template_image, float threshold, std::vector<int> roi = std::vector<int>(), int step = 2, image::TemplateMatch search = image::TemplateMatch::SEARCH_EX)

find_features

def find_features(self, cascade: int, threshold: float = 0.5, scale: float = 1.5, roi: list[int] = []) -> list[int]

Finds the features in the image. TODO: support in the feature

item	description
type	func
param	cascade: The cascade to use for the features. default is CASCADE_FRONTALFACE_ALT. threshold: The threshold to use for the features. default is 0.5. scale: The scale to use for the features. default is 1.5. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image.
return	Returns the features of the image
static	False

C++ defination code:

std::vector<int> find_features(int cascade, float threshold = 0.5, float scale = 1.5, std::vector<int> roi = std::vector<int>())

find_lbp

def find_lbp(self, roi: list[int] = []) -> LBPKeyPoint

Finds the lbp in the image. TODO: support in the feature.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image.
return	Returns the lbp of the image
static	False

C++ defination code:

image::LBPKeyPoint find_lbp(std::vector<int> roi = std::vector<int>())

find_keypoints

def find_keypoints(self, roi: list[int] = [], threshold: int = 20, normalized: bool = False, scale_factor: float = 1.5, max_keypoints: int = 100, corner_detector: CornerDetector = ...) -> ORBKeyPoint

Finds the keypoints in the image. TODO: support in the feature.

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. threshold: The threshold to use for the keypoints. default is 20. normalized: If true, the image will be normalized before the operation. default is false. scale_factor: The scale factor to use for the keypoints. default is 1.5. max_keypoints: The maximum number of keypoints to use for the keypoints. default is 100. corner_detector: The corner detector to use for the keypoints. default is CORNER_AGAST.
return	Returns the keypoints of the image
static	False

C++ defination code:

image::ORBKeyPoint find_keypoints(std::vector<int> roi = std::vector<int>(), int threshold = 20, bool normalized = false, float scale_factor = 1.5, int max_keypoints = 100, image::CornerDetector corner_detector = image::CornerDetector::CORNER_AGAST)

find_edges

def find_edges(self, edge_type: EdgeDetector, roi: list[int] = [], threshold: list[int] = [100, 200]) -> Image

Finds the edges in the image.

item	description
type	func
param	edge_type: The edge type to use for the edges. default is EDGE_CANNY. roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. threshold: The threshold to use for the edges. default is 20.
return	Returns the edges of the image
static	False

C++ defination code:

image::Image* find_edges(image::EdgeDetector edge_type, std::vector<int> roi = std::vector<int>(), std::vector<int> threshold = std::vector<int>({100, 200}))

find_hog

def find_hog(self, roi: list[int] = [], size: int = 8) -> Image

Finds the hog in the image. TODO: support in the feature

item	description
type	func
param	roi: The region of interest, input in the format of (x, y, w, h), x and y are the coordinates of the upper left corner, w and h are the width and height of roi. default is None, means whole image. size: The size to use for the hog. default is 8.
return	Returns the hog of the image
static	False

C++ defination code:

image::Image* find_hog(std::vector<int> roi = std::vector<int>(), int size = 8)

match_lbp_descriptor

def match_lbp_descriptor(self, desc1: LBPKeyPoint, desc2: LBPKeyPoint) -> int

Matches the lbp descriptor of the image. TODO: support in the feature

item	description
type	func
param	desc1: The descriptor to use for the match. desc2: The descriptor to use for the match.
return	Returns the match of the image
static	False

C++ defination code:

int match_lbp_descriptor(image::LBPKeyPoint &desc1, image::LBPKeyPoint &desc2)

match_orb_descriptor

def match_orb_descriptor(self, desc1: ORBKeyPoint, desc2: ORBKeyPoint, threshold: int = 95, filter_outliers: bool = False) -> KPTMatch

Matches the orb descriptor of the image. TODO: support in the feature

item	description
type	func
param	desc1: The descriptor to use for the match. desc2: The descriptor to use for the match. threshold: The threshold to use for the match. default is 95. filter_outliers: If true, the image will be filter_outliers before the operation. default is false.
return	Returns the match of the image
static	False

C++ defination code:

image::KPTMatch match_orb_descriptor(image::ORBKeyPoint &desc1, image::ORBKeyPoint &desc2, int threshold = 95, bool filter_outliers = false)