'plot', # Main plotting function

'blend', # Core blending function for numpy arrays

'blend2PIL', # Specialized blending for Jupyter/PIL output

'plot_at', # Plot directly onto existing array

'plot1_at', # Plot 1D array onto existing array

try:

importlib.import_module(module_name)

return True

except ImportError:

def decorator(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

if perf_name in perf_timers:

with perf_timers[perf_name]:

result = func(*args, **kwargs)

return result

else:

return func(*args, **kwargs)

return wrapper

"""

# Calculate the bounds for both rows of the array values

bounds = np.array([np.min(values, axis=1), np.max(values, axis=1)])

# Calculate the range of the values

value_range = bounds[1] - bounds[0]

value_range[value_range == 0] = 1

# Calculate the scaling factor

scale = np.array(grid_shape) / value_range

# Adjust the values to fill the grid box maximally

adjusted_values = (values - bounds[0, :, np.newaxis]) * scale[:, np.newaxis]

# Calculate the median degree for values in both rows and round to the nearest whole number

median_degree = np.round(np.median(values, axis=1)).astype(int)

"""

# Calculate the bounds for both rows of the array values

ybounds = np.array([np.min(values[1, :]), np.max(values[1, :])])

values = values[:, -max_len:]

xbounds = np.array([np.min(values[0]), np.max(values[0])])

bounds = np.stack([xbounds, ybounds], axis=1)

# Calculate the range of the values

value_range = np.array([xbounds[1] - xbounds[0], ybounds[1] - ybounds[0]])

median_degree = np.array([0, 0])

if value_range[0] == 0:

value_range[0] = values[0]

median_degree[0] = 0

if value_range[1] == 0:

value_range[1] = values[1]

median_degree[1] = 0

if value_range[0] and value_range[1]:

median_degree = np.round(np.log10(np.median(np.abs(values), axis=1))).astype(

int

)

# Calculate the scaling factor

scale = np.array(grid_shape[::-1]) / value_range

# Adjust the values to fill the grid box maximally

adjusted_values = (values - bounds[0, :, np.newaxis]) * (scale[:, np.newaxis])

# Calculate the median degree for values in both rows and round to the nearest whole number

"""

# Create an array of distances

num_points = max(np.max(abs(x1 - x0)), np.max(abs(y1 - y0))) + 1

t = np.linspace(0, 1, num_points)

# Create 2D arrays for x and y coordinates

x = (x0 + np.outer(t, (x1 - x0))).astype(int)

y = (y0 + np.outer(t, (y1 - y0))).astype(int)

# Create a boolean mask with the size of the canvas and an additional dimension for t

mask = np.zeros(canvas_size, dtype=bool)

# Set the corresponding positions to True

mask[y.ravel(), x.ravel()] = True

"""

# Create an array of distances

num_points = max(np.max(abs(x1 - x0)), np.max(abs(y1 - y0))) + 1

t = np.linspace(0, 1, num_points)

# Create 2D arrays for x and y coordinates

x = (x0 + np.outer(t, (x1 - x0))).astype(int)

y = (y0 + np.outer(t, (y1 - y0))).astype(int)

# Set the corresponding positions to clr

img_array[y.ravel(), x.ravel()] = clr

y0, x0, y1, x1, img_array, thickness, clr=(0, 0, 255)

):

"""

# Create an array of distances

num_points = max(np.max(abs(x1 - x0)), np.max(abs(y1 - y0))) + 1

t = np.linspace(0, 1, num_points)

# Create 2D arrays for x and y coordinates

x = (x0 + np.outer(t, (x1 - x0))).astype(int)

y = (y0 + np.outer(t, (y1 - y0))).astype(int)

# Create the shift indices

shift_indices = np.arange(-thickness // 2, thickness // 2 + 1)

# Ensure that the shift is broadcastable by adding a new axis to y1 and y0

y1 = y1[:, np.newaxis]

y0 = y0[:, np.newaxis]

x1 = x1[:, np.newaxis]

x0 = x0[:, np.newaxis]

# Create the shifted coordinates

x_shifted = x[..., np.newaxis] + shift_indices * np.sign(x1 - x0)

y_shifted = y[..., np.newaxis] + shift_indices * np.sign(y1 - y0)

# Clip the shifted coordinates to the image boundaries

x_shifted = np.clip(x_shifted, 0, img_array.shape[1] - 1)

y_shifted = np.clip(y_shifted, 0, img_array.shape[0] - 1)

# Flatten the arrays to set the color in the image array

img_array[y_shifted.ravel(), x_shifted.ravel()] = clr

img_array: np.ndarray,

values: np.array,

offset: Tuple[int, int],

title: str = 'Measuring',

size: Tuple[int, int] = (300, 300),

point_color: Tuple[int, int, int, int] = (0, 0, 255),

r=2,

nticks: int = 16,

grid_color: Tuple[int, int, int, int] = (128, 128, 128),

precision: int = 4,

default_font_size: float = 0.5,

default_font_size_small: float = 0.4,

label_color: Tuple[int, int, int, int] = (0, 0, 255),

scatter=True,

thickness=2,

line_color: Tuple[int, int, int, int] = (0, 0, 255),

max_len: int = 100,

) -> np.ndarray:

"""Plot into a NumPy image array.

font_size = default_font_size

font_size_small = default_font_size_small

font = cv2.FONT_HERSHEY_SIMPLEX

text_size_title = cv2.getTextSize(title, font, font_size, 1)[0]

margin_ver = int(text_size_title[1] * 2.0)

axlablen = cv2.getTextSize('A' * precision, font, font_size_small, 1)[0][0]

margin_hor = int(axlablen * 1.5)

grid_topleft = np.array((margin_ver, margin_hor))

grid_botright = np.array(size) - grid_topleft

gsize = grid_botright - grid_topleft

gsize2 = gsize - (gsize % nticks)

iota = (gsize - gsize2) / 2

gsize = gsize2

grid_topleft = (grid_topleft + iota).astype(int)

grid_botright = (grid_botright - iota).astype(int)

pxdelta = (gsize // nticks).astype(int)

gh, gw = tuple(gsize)

adjusted_values, bounds, scale, median_degree = adjust_values_maxlen(

values, gsize, max_len=max_len

)

pxdelta = (gsize // nticks).astype(int)

# Adjust the title to include the multiplier

# Draw grid and rectangle with opacity

gtl_img = grid_topleft + offset

gbr_img = grid_botright + offset

title += f', 10^{int(median_degree[1])}'

text_x_title = int(

gtl_img[1] + gw / 2 - cv2.getTextSize(title, font, font_size, 1)[0][0] / 2

)

text_y_title = gtl_img[0] - int(text_size_title[1] * 1.5)

img_array[

gtl_img[0] : gbr_img[0] + 1 : pxdelta[0], gtl_img[1] : gbr_img[1] + 1, :

] = grid_color

img_array[

gtl_img[0] : gbr_img[0] + 1, gtl_img[1] : gbr_img[1] + 1 : pxdelta[1], :

] = grid_color

# Render points

# Create an array of indices

x = gtl_img[1] + (adjusted_values[0, ...]).astype(int)

y = gbr_img[0] - (adjusted_values[1, ...]).astype(int)

# Create a mask for valid indices

valid_mask = (

(gtl_img[0] <= y) & (y <= gbr_img[0]) & (gtl_img[1] <= x) & (x <= gbr_img[1])

)

valsx = x[valid_mask]

valsy = y[valid_mask]

# Create a grid of offsets

x_offset = np.arange(-r, r + 1)

y_offset = np.arange(-r, r + 1)

xx, yy = np.meshgrid(x_offset, y_offset)

# Apply offsets to the original x and y coordinates

xx = xx.ravel() + valsx[:, None]

yy = yy.ravel() + valsy[:, None]

# Flatten the arrays

xx = xx.ravel()

yy = yy.ravel()

# Assign color to the corresponding pixels and the surrounding pixels

img_array[yy, xx] = point_color

if not scatter and values.shape[1] >= 2:

# Create pairs of adjacent points

with _veclinesperf:

img_array = vectorized_lines_with_thickness(

y[:-1],

x[:-1],

y[1:],

x[1:],

img_array,

clr=line_color,

thickness=thickness,

)

# rendering text

n = gsize[0] // (2 * pxdelta[0])

tick_color = label_color

yscale = bounds[1, 1] - bounds[0, 1]

for i in range(n + 1):

# Scale the tick label by the multiplier

tickval = bounds[0, 1] + (yscale / n) * i

dotp = precision - len(str(tickval).split('.')[0])

val = '{:.{}f}'.format(tickval, dotp)

text_size, _ = cv2.getTextSize(val, font, font_size_small, 1)

text_width, text_height = text_size

text_x = offset[1] + pxdelta[1] // 2 # Adjust position to the left of the grid

text_y = gbr_img[0] - i * 2 * pxdelta[0] + text_height // 2

cv2.putText(

img_array, val, (text_x, text_y), font, font_size_small, tick_color, 1

)

# Draw title with opacity

cv2.putText(

img_array, title, (text_x_title, text_y_title), font, font_size, label_color, 1

)

values: np.array,

title: str = 'Measuring',

size: Tuple[int, int] = (300, 300),

point_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

r=2,

nticks: int = 16,

grid_color: Tuple[int, int, int, int] = (128, 128, 128, 255),

precision: int = 4,

default_font_size: float = 0.5,

default_font_size_small: float = 0.4,

label_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

scatter=True,

thickness=2,

line_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

max_len: int = 100,

) -> np.array:

"""Plot into a NumPy image array.

font_size = default_font_size

font_size_small = default_font_size_small

font = cv2.FONT_HERSHEY_SIMPLEX

text_size_title = cv2.getTextSize(title, font, font_size, 1)[0]

text_y_title = int(text_size_title[1] * 1.5)

margin_ver = int(text_y_title + text_size_title[1] * 0.5)

axlablen = cv2.getTextSize('A' * precision, font, font_size_small, 1)[0][0]

margin_hor = int(axlablen * 1.5)

grid_topleft = np.array((margin_ver, margin_hor))

grid_botright = np.array(size) - grid_topleft

gsize = grid_botright - grid_topleft

gsize2 = gsize - (gsize % nticks)

iota = (gsize - gsize2) / 2

gsize = gsize2

grid_topleft = (grid_topleft + iota).astype(int)

grid_botright = (grid_botright - iota).astype(int)

pxdelta = (gsize // nticks).astype(int)

gh, gw = tuple(gsize)

adjusted_values, bounds, scale, median_degree = adjust_values_maxlen(

values, gsize, max_len=max_len

)

title += f', 10^{int(median_degree[1])}'

text_x_title = int(

grid_topleft[1] + gw / 2 - cv2.getTextSize(title, font, font_size, 1)[0][0] / 2

)

pxdelta = (gsize // nticks).astype(int)

img_array = np.zeros((*size, 4), np.uint8)

# Adjust the title to include the multiplier

# Draw grid and rectangle with opacity

img_array[

grid_topleft[0] : grid_botright[0] + 1 : pxdelta[0],

grid_topleft[1] : grid_botright[1] + 1,

:,

] = grid_color

img_array[

grid_topleft[0] : grid_botright[0] + 1,

grid_topleft[1] : grid_botright[1] + 1 : pxdelta[1],

:,

] = grid_color

# Render points

# Create an array of indices

x = grid_topleft[1] + (adjusted_values[0, ...]).astype(int)

y = grid_botright[0] - (adjusted_values[1, ...]).astype(int)

# Create a mask for valid indices

valid_mask = (

(grid_topleft[0] <= y)

& (y <= grid_botright[0])

& (grid_topleft[1] <= x)

& (x <= grid_botright[1])

)

valsx = x[valid_mask]

valsy = y[valid_mask]

# Create a grid of offsets

x_offset = np.arange(-r, r + 1)

y_offset = np.arange(-r, r + 1)

xx, yy = np.meshgrid(x_offset, y_offset)

# Apply offsets to the original x and y coordinates

xx = xx.ravel() + valsx[:, None]

yy = yy.ravel() + valsy[:, None]

# Flatten the arrays

xx = xx.ravel()

yy = yy.ravel()

# Assign color to the corresponding pixels and the surrounding pixels

img_array[yy, xx] = point_color

if not scatter and values.shape[1] >= 2:

# Create pairs of adjacent points

with _veclinesperf:

img_array = vectorized_lines_with_thickness(

y[:-1],

x[:-1],

y[1:],

x[1:],

img_array,

clr=line_color,

thickness=thickness,

)

# rendering text

n = gsize[0] // (2 * pxdelta[0])

tick_color = label_color

yscale = bounds[1, 1] - bounds[0, 1]

for i in range(n + 1):

# Scale the tick label by the multiplier

tickval = bounds[0, 1] + (yscale / n) * i

dotp = precision - len(str(tickval).split('.')[0])

val = '{:.{}f}'.format(tickval, dotp)

text_size, _ = cv2.getTextSize(val, font, font_size_small, 1)

text_width, text_height = text_size

text_x = pxdelta[1] // 2 # Adjust position to the left of the grid

text_y = grid_botright[0] - i * 2 * pxdelta[0] + text_height // 2

cv2.putText(

img_array, val, (text_x, text_y), font, font_size_small, tick_color, 1

)

# Draw title with opacity

cv2.putText(

img_array, title, (text_x_title, text_y_title), font, font_size, label_color, 1

)

values: np.array,

title: str = 'Measuring',

size: Tuple[int, int] = (300, 300),

point_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

r=2,

nticks: int = 16,

grid_color: Tuple[int, int, int, int] = (128, 128, 128, 255),

precision: int = 2,

default_font_size: float = 0.5,

default_font_size_small: float = 0.4,

label_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

scatter=True,

thickness=2,

line_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

max_len: int = 100,

) -> np.array:

"""Plot into a NumPy image array.

min_val = np.min(values)

max_val = np.max(values)

if max_len > 0:

values = values[-max_len:]

# Calculate adjustment factor and shift

if max_val - min_val == 0:

if min_val == 0:

scale = 1.0

shift = -0.5

power = 1

adjust_factor = 1

else:

scale = min_val / 2

power = np.floor(np.log10(min_val))

adjust_factor = 1

shift = -scale

else:

scale = max_val - min_val

power = np.ceil(np.log10((np.abs(min_val) + np.abs(max_val)) / 2))

shift = -min_val

# Determine the multiplier to scale the tick values above 1.0

multiplier = 10**-power

title += f', 10^{int(power)}'

# Set the paramerics

# height = size[1]

# width = size[0]

font_size = default_font_size

font_size_small = default_font_size_small

font = cv2.FONT_HERSHEY_SIMPLEX

text_size_title = cv2.getTextSize(title, font, font_size, 1)[0]

text_y_title = int(text_size_title[1] * 1.5)

margin_ver = int(text_y_title + text_size_title[1] * 0.5)

axlablen = cv2.getTextSize('A' * precision, font, font_size_small, 1)[0][0]

margin_hor = int(axlablen * 1.5)

grid_topleft = np.array((margin_ver, margin_hor))

grid_botright = np.array(size) - grid_topleft

gsize = grid_botright - grid_topleft

gsize2 = gsize - (gsize % nticks)

iota = (gsize - gsize2) / 2

grid_topleft = (grid_topleft + iota).astype(int)

grid_botright = (grid_botright - iota).astype(int)

pxdelta = (gsize // nticks).astype(int)

gsize = gsize2

gh, gw = tuple(gsize)

text_x_title = int(grid_topleft[1] + gw / 2 - text_size_title[0] / 2)

pxdelta = (gsize // nticks).astype(int)

img_array = np.zeros((*size, 4), np.uint8)

# Adjust the title to include the multiplier

adjust_factor = gsize[0] / scale

# Adjust values

adjusted_values = (values + shift) * adjust_factor

# top_left = (0, 0)

# bottom_right = (height, width)

# Draw grid and rectangle with opacity

img_array[

grid_topleft[0] : grid_botright[0] + 1 : pxdelta[0],

grid_topleft[1] : grid_botright[1] + 1,

:,

] = grid_color

img_array[

grid_topleft[0] : grid_botright[0] + 1,

grid_topleft[1] : grid_botright[1] + 1 : pxdelta[1],

:,

] = grid_color

# Render points

# Create an array of indices

i = np.arange(len(adjusted_values))

x = grid_botright[1] - ((i + 1) * gw // len(adjusted_values))

y = grid_botright[0] - (adjusted_values).astype(int)

# Create a mask for valid indices

valid_mask = (

(grid_topleft[0] <= y)

& (y <= grid_botright[0])

& (grid_topleft[1] <= x)

& (x <= grid_botright[1])

)

valsx = x[valid_mask]

valsy = y[valid_mask]

# Create a grid of offsets

x_offset = np.arange(-r, r + 1)

y_offset = np.arange(-r, r + 1)

xx, yy = np.meshgrid(x_offset, y_offset)

# Apply offsets to the original x and y coordinates

xx = xx.ravel() + valsx[:, None]

yy = yy.ravel() + valsy[:, None]

# Flatten the arrays

xx = xx.ravel()

yy = yy.ravel()

# Assign color to the corresponding pixels and the surrounding pixels

img_array[yy, xx] = point_color

if not scatter and values.shape[0] >= 2:

# Create pairs of adjacent points

with _veclinesperf:

img_array = vectorized_lines_with_thickness(

y[:-1],

x[:-1],

y[1:],

x[1:],

img_array,

clr=line_color,

thickness=thickness,

)

# rendering text

n = gsize[0] // (2 * pxdelta[0])

tick_color = label_color

for i in range(n + 1):

# Scale the tick label by the multiplier

val = '{:.{}f}'.format((scale / n * i) * multiplier, precision)

text_size, _ = cv2.getTextSize(val, font, font_size_small, 1)

text_width, text_height = text_size

text_x = pxdelta[1] // 2 # Adjust position to the left of the grid

text_y = grid_botright[0] - i * 2 * pxdelta[0] + text_height // 2

cv2.putText(

img_array, val, (text_x, text_y), font, font_size_small, tick_color, 1

)

# Draw title with opacity

cv2.putText(

img_array, title, (text_x_title, text_y_title), font, font_size, label_color, 1

)

values: np.array,

title: str = 'Measuring',

size: Tuple[int, int] = (300, 300),

point_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

r=2,

nticks: int = 16,

grid_color: Tuple[int, int, int, int] = (128, 128, 128, 255),

precision: int = 2,

default_font_size: float = 0.8,

default_font_size_small: float = 0.6,

label_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

scatter=True,

thickness=2,

line_color: Tuple[int, int, int, int] = (0, 0, 255, 255),

max_len: int = 100,

) -> np.array:

"""Draw a plot on a new NumPy image array using textrender for text rendering.

if max_len > 0:

values = values[-max_len:]

min_val = np.min(values)

max_val = np.max(values)

# Calculate adjustment factor and shift

if max_val - min_val == 0:

if min_val == 0:

scale = 1.0

shift = -0.5

power = 1

adjust_factor = 1

else:

scale = min_val / 2

power = np.floor(np.log10(min_val))

adjust_factor = 1

shift = -scale

else:

scale = max_val - min_val

power = np.ceil(np.log10((np.abs(min_val) + np.abs(max_val)) / 2))

shift = -min_val

multiplier = 10**-power

title += f', 10^{int(power)}'

# Estimate text sizes and positions

font_size = default_font_size # Adjust this factor as needed

font_size_small = default_font_size_small # Adjust this factor as needed

# Estimate margins and grid size

margin_ver = int(size[1] * 0.1) # 10% of height for vertical margin

margin_hor = int(size[0] * 0.15) # 15% of width for horizontal margin

grid_topleft = np.array((margin_hor, margin_ver))

grid_botright = np.array(size) - grid_topleft

gsize = grid_botright - grid_topleft

# Adjust grid size to be divisible by nticks

gsize2 = gsize - (gsize % nticks)

iota = (gsize - gsize2) / 2

grid_topleft = (grid_topleft + iota).astype(int)

grid_botright = (grid_botright - iota).astype(int)

gsize = gsize2

pxdelta = (gsize // nticks).astype(int)

# Create image array

img_array = np.zeros((*size, 4), np.uint8)

adjust_factor = gsize[0] / scale

adjusted_values = (values + shift) * adjust_factor

# Draw grid and rectangle with opacity

img_array[

grid_topleft[0] : grid_botright[0] + 1 : pxdelta[0],

grid_topleft[1] : grid_botright[1] + 1,

:,

] = grid_color

img_array[

grid_topleft[0] : grid_botright[0] + 1,

grid_topleft[1] : grid_botright[1] + 1 : pxdelta[1],

:,

] = grid_color

# Render points

i = np.arange(len(adjusted_values))

x = grid_botright[1] - ((i + 1) * gsize[1] // len(adjusted_values))

y = grid_botright[0] - (adjusted_values).astype(int)

valid_mask = (

(grid_topleft[0] <= y)

& (y <= grid_botright[0])

& (grid_topleft[1] <= x)

& (x <= grid_botright[1])

)

valsx = x[valid_mask]

valsy = y[valid_mask]

x_offset = np.arange(-r, r + 1)

y_offset = np.arange(-r, r + 1)

xx, yy = np.meshgrid(x_offset, y_offset)

xx = xx.ravel() + valsx[:, None]

yy = yy.ravel() + valsy[:, None]

xx = xx.ravel()

yy = yy.ravel()

img_array[yy, xx] = point_color

if not scatter and values.shape[0] >= 2:

with _veclinesperf:

img_array = vectorized_lines_with_thickness(

y[:-1],

x[:-1],

y[1:],

x[1:],

img_array,

clr=line_color,

thickness=thickness,

)

# Render y-axis labels

tick_color = label_color[:3] # Remove alpha channel for vectorized_text

for i in range(nticks + 1):

val = '{:.{}f}'.format((scale / nticks * i) * multiplier, precision)

l = len(val)

dx = int(l * 5 * font_size_small * 2)

text_x = grid_topleft[1] - dx # Approximate text width

text_y = grid_botright[0] - i * pxdelta[0] - 5 * int(font_size_small) # Adjust for text height

img_array = vectorized_text(

img_array, val, (text_x, text_y), color=tick_color, font_size=font_size_small

)

# Draw title

title_color = label_color[:3] # Remove alpha channel for vectorized_text

text_x_title = grid_topleft[1] + (grid_botright[1] - grid_topleft[1]) // 2 - len(title) * 5 * int(font_size * 2) // 2 # Approximate text width

text_y_title = grid_topleft[0] - int(font_size * 5*2)

img_array = vectorized_text(

img_array, title, (text_x_title, text_y_title), color=title_color, font_size=font_size

)

"""

if not arrays:

raise ValueError("At least one array must be provided")

# Use the first array as the base

base_array = arrays[0]

# Check if all arrays have the same shape

for array in arrays:

if array.shape != base_array.shape:

return base_array

# Blend arrays by overlaying them in order

blended_array = base_array.copy()

for array in arrays[1:]:

alpha = array[..., 3] / 255.0 # Assuming the last channel is alpha

blended_array[..., :3] = (1 - alpha[..., None]) * blended_array[..., :3] + alpha[..., None] * array[..., :3]

dst_img: np.ndarray, paste_img: np.ndarray, offset: Tuple[int, int]

) -> np.ndarray:

# pasting image fits

assert dst_img.ndim == paste_img.ndim and np.all(

offset + paste_img.shape[0:2] <= dst_img.shape[0:2]

)

# it is rgba and proper type

assert paste_img.shape[2] == 4 and paste_img.dtype == np.uint8

alpha = paste_img[..., 3][..., None].astype(np.float32) / 255.0

img = paste_img[..., 0:3]

sz = img.shape[0:2]

y0 = offset[0]

y1 = y0 + sz[0]

x0 = offset[1]

x1 = x0 + sz[1]

dst_img[y0:y1, x0:x1] = dst_img[y0:y1, x0:x1] * (1 - alpha) + img * alpha

img_array: np.ndarray,

values: np.ndarray,

title: str = 'Measuring',

offset: Tuple[int, int] = (50, 50),

size: Tuple[int, int] = (300, 270),

point_color: Tuple[int, int, int, int] = (0, 0, 255),

r=2,

pxdelta: int = 15,

grid_color: Tuple[int, int, int, int] = (128, 128, 128),

precision: int = 2,

default_font_size: float = 0.75,

default_font_size_small: float = 0.5,

label_color: Tuple[int, int, int, int] = (0, 0, 255),

scatter=False,

thickness=2,

line_color: Tuple[int, int, int, int] = (0, 0, 255),

max_len: int = 100,