


"""simple docstring"""
from __future__ import annotations

from collections.abc import Iterable



class      _UpperCAmelCase					:






		'''simple docstring'''

		def __init__(self							,			a_							,			a_   ):





			'''simple docstring'''

			__snake_case      ,				__snake_case      :		str         =							float(a_   ), float(a_   )



		def __eq__(self							,			a_   ):





			'''simple docstring'''

			return self.x == other.x and self.y == other.y



		def __ne__(self							,			a_   ):





			'''simple docstring'''

			return not self == other



		def __gt__(self							,			a_   ):





			'''simple docstring'''

			if self.x > other.x:
				return True
			elif self.x == other.x:
				return self.y > other.y
			return False



		def __lt__(self							,			a_   ):





			'''simple docstring'''

			return not self > other



		def __ge__(self							,			a_   ):





			'''simple docstring'''

			if self.x > other.x:
				return True
			elif self.x == other.x:
				return self.y >= other.y
			return False



		def __le__(self							,			a_   ):





			'''simple docstring'''

			if self.x < other.x:
				return True
			elif self.x == other.x:
				return self.y <= other.y
			return False



		def __repr__(self   ):





			'''simple docstring'''

			return f"""({self.x}, {self.y})"""



		def __hash__(self   ):





			'''simple docstring'''

			return hash(self.x   )






def 						lowercase				(	_snake_case		: list[Point] | list[list[float]] | Iterable[list[float]]	,  )	->list[Point]:
	"""simple docstring"""





	__snake_case      :		list[Point]         =							[]
	if list_of_tuples:
		for p in list_of_tuples:
			if isinstance(_snake_case	,  _snake_case	):
				points.append(_snake_case	)
			else:
				try:
					points.append(Point(p[0]	,  p[1]	)	)
				except (IndexError, TypeError):
					print(
					    f"""Ignoring deformed point {p}. All points"""
					    ''' must have at least 2 coordinates.'''	)
	return points






def 						lowercase				(	_snake_case		: list[Point] | list[list[float]]	)	->list[Point]:
	"""simple docstring"""





	if not hasattr(_snake_case	,  '''__iter__'''	):
		__snake_case      :		Optional[Any]         =							f"""Expecting an iterable object but got an non-iterable type {points}"""
		raise ValueError(_snake_case	)

	if not points:
		__snake_case      :		str         =							f"""Expecting a list of points but got {points}"""
		raise ValueError(_snake_case	)

	return _construct_points(_snake_case	)






def 						lowercase				(	_snake_case		: Point	,  _snake_case		: Point	,  _snake_case		: Point	)	->float:
	"""simple docstring"""





	__snake_case      :		Any         =							(a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
	return det






def 						lowercase				(	_snake_case		: list[Point]	)	->list[Point]:
	"""simple docstring"""





	__snake_case      :		List[Any]         =							sorted(_validate_input(_snake_case	)	)
	__snake_case      :		Optional[int]         =							len(_snake_case	)
	__snake_case      :		List[str]         =							set()

	for i in range(n - 1	):
		for j in range(i + 1	,  _snake_case	):
			__snake_case      :		List[Any]         =							False
			__snake_case      :		int         =							True
			for k in range(_snake_case	):
				if k != i and k != j:
					__snake_case      :		List[Any]         =							_det(points[i]	,  points[j]	,  points[k]	)

					if det_k > 0:
						__snake_case      :		List[Any]         =							True
					elif det_k < 0:
						__snake_case      :		str         =							True
					else:
						# point[i], point[j], point[k] all lie on a straight line
						# if point[k] is to the left of point[i] or it's to the
						# right of point[j], then point[i], point[j] cannot be
						# part of the convex hull of A
						if points[k] < points[i] or points[k] > points[j]:
							__snake_case      :		int         =							False
							break

				if points_left_of_ij and points_right_of_ij:
					__snake_case      :		List[str]         =							False
					break

			if ij_part_of_convex_hull:
				convex_set.update([points[i], points[j]]	)

	return sorted(_snake_case	)






def 						lowercase				(	_snake_case		: list[Point]	)	->list[Point]:
	"""simple docstring"""





	__snake_case      :		str         =							sorted(_validate_input(_snake_case	)	)
	__snake_case      :		List[Any]         =							len(_snake_case	)

	# divide all the points into an upper hull and a lower hull
	# the left most point and the right most point are definitely
	# members of the convex hull by definition.
	# use these two anchors to divide all the points into two hulls,
	# an upper hull and a lower hull.

	# all points to the left (above) the line joining the extreme points belong to the
	# upper hull
	# all points to the right (below) the line joining the extreme points below to the
	# lower hull
	# ignore all points on the line joining the extreme points since they cannot be
	# part of the convex hull

	__snake_case      :		List[str]         =							points[0]
	__snake_case      :		str         =							points[n - 1]

	__snake_case      :		Union[str, Any]         =							{left_most_point, right_most_point}
	__snake_case      :		str         =							[]
	__snake_case      :		List[Any]         =							[]

	for i in range(1	,  n - 1	):
		__snake_case      :		str         =							_det(_snake_case	,  _snake_case	,  points[i]	)

		if det > 0:
			upper_hull.append(points[i]	)
		elif det < 0:
			lower_hull.append(points[i]	)

	_construct_hull(_snake_case	,  _snake_case	,  _snake_case	,  _snake_case	)
	_construct_hull(_snake_case	,  _snake_case	,  _snake_case	,  _snake_case	)

	return sorted(_snake_case	)






def 						lowercase				(	_snake_case		: list[Point]	,  _snake_case		: Point	,  _snake_case		: Point	,  _snake_case		: set[Point]	)	->None:
	"""simple docstring"""





	if points:
		__snake_case      :		int         =							None
		__snake_case      :		Dict         =							float('''-inf'''	)
		__snake_case      :		Union[str, Any]         =							[]

		for p in points:
			__snake_case      :		Union[str, Any]         =							_det(_snake_case	,  _snake_case	,  _snake_case	)

			if det > 0:
				candidate_points.append(_snake_case	)

				if det > extreme_point_distance:
					__snake_case      :		int         =							det
					__snake_case      :		Optional[Any]         =							p

		if extreme_point:
			_construct_hull(_snake_case	,  _snake_case	,  _snake_case	,  _snake_case	)
			convex_set.add(_snake_case	)
			_construct_hull(_snake_case	,  _snake_case	,  _snake_case	,  _snake_case	)






def 						lowercase				(	_snake_case		: list[Point]	)	->list[Point]:
	"""simple docstring"""





	__snake_case      :		List[str]         =							sorted(_validate_input(_snake_case	)	)
	__snake_case      :		int         =							len(_snake_case	)

	__snake_case      :		Tuple         =							points[:2]
	for i in range(2	,  _snake_case	):
		__snake_case      :		List[str]         =							_det(convex_hull[1]	,  convex_hull[0]	,  points[i]	)
		if det > 0:
			convex_hull.insert(0	,  points[i]	)
			break
		elif det < 0:
			convex_hull.append(points[i]	)
			break
		else:
			__snake_case      :		str         =							points[i]
	i += 1

	for j in range(_snake_case	,  _snake_case	):
		if (
		    _det(convex_hull[0]	,  convex_hull[-1]	,  points[j]	) > 0
		    and _det(convex_hull[-1]	,  convex_hull[0]	,  points[1]	) < 0
		):
			# The point lies within the convex hull
			continue

		convex_hull.insert(0	,  points[j]	)
		convex_hull.append(points[j]	)
		while _det(convex_hull[0]	,  convex_hull[1]	,  convex_hull[2]	) >= 0:
			del convex_hull[1]
		while _det(convex_hull[-1]	,  convex_hull[-2]	,  convex_hull[-3]	) <= 0:
			del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
	return sorted(convex_hull[1:] if len(_snake_case	) > 3 else convex_hull	)






def 						lowercase				(	)	->List[Any]:
	"""simple docstring"""





	__snake_case      :		Optional[Any]         =							[
	    (0, 3),
	    (2, 2),
	    (1, 1),
	    (2, 1),
	    (3, 0),
	    (0, 0),
	    (3, 3),
	    (2, -1),
	    (2, -4),
	    (1, -3),
	]
	# the convex set of points is
	# [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
	__snake_case      :		Tuple         =							convex_hull_bf(_snake_case	)

	__snake_case      :		List[Any]         =							convex_hull_recursive(_snake_case	)
	assert results_bf == results_recursive

	__snake_case      :		Tuple         =							convex_hull_melkman(_snake_case	)
	assert results_bf == results_melkman

	print(_snake_case	)


if __name__ == "__main__":
			main()













import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


A_			:Tuple	    =		1000




class 							__A	:





				"""simple docstring"""







				def __init__(					self				,    lowerCamelCase__				,    lowerCamelCase__=1.2				,    lowerCamelCase__="g"				,    lowerCamelCase__=0.5				,    lowerCamelCase__="-"				,    lowerCamelCase__="test_out.jpg"				,    lowerCamelCase__=True				,    lowerCamelCase__=False				,    lowerCamelCase__=None				,    lowerCamelCase__=None				,    lowerCamelCase__=0.7				,    ):




									"""simple docstring"""

									if isinstance(lowerCamelCase__				,    torch.Tensor       ):
														__UpperCamelCase :   Union[str, Any]									=img.numpy().astype('np.uint8'       )
									if isinstance(lowerCamelCase__				,    lowerCamelCase__       ):
														__UpperCamelCase :   List[str]									=img_tensorize(lowerCamelCase__       )
									assert isinstance(lowerCamelCase__				,    np.ndarray       )

									__UpperCamelCase						,							__UpperCamelCase :   Any									=img.shape[1], img.shape[0]
									__UpperCamelCase :   Any									=mplfigure.Figure(frameon=lowerCamelCase__       )
									__UpperCamelCase :   Any									=fig.get_dpi()
									__UpperCamelCase :   Optional[Any]									=(width * scale + 1E-2) / dpi
									__UpperCamelCase :   Optional[Any]									=(height * scale + 1E-2) / dpi
									fig.set_size_inches(lowerCamelCase__				,    lowerCamelCase__       )
									__UpperCamelCase :   Dict									=fig.add_axes([0.0, 0.0, 1.0, 1.0]       )
									ax.axis('off'       )
									ax.set_xlim(0.0				,    lowerCamelCase__       )
									ax.set_ylim(lowerCamelCase__       )

									__UpperCamelCase :   List[Any]									=saveas
									__UpperCamelCase :   Any									=rgb
									__UpperCamelCase :   int									=pynb
									__UpperCamelCase :   Optional[int]									=img
									__UpperCamelCase :   List[Any]									=edgecolor
									__UpperCamelCase :   List[str]									=0.5
									__UpperCamelCase :   Optional[Any]									=linestyle
									__UpperCamelCase :   Dict									=int(np.sqrt(min(lowerCamelCase__				,    lowerCamelCase__       )       ) * scale // 3       )
									__UpperCamelCase :   List[Any]									=width
									__UpperCamelCase :   List[Any]									=height
									__UpperCamelCase :   int									=scale
									__UpperCamelCase :   List[str]									=fig
									__UpperCamelCase :   Union[str, Any]									=ax
									__UpperCamelCase :   Dict									=pad
									__UpperCamelCase :   List[Any]									=idaobj
									__UpperCamelCase :   List[Any]									=idaattr
									__UpperCamelCase :   List[str]									=FigureCanvasAgg(lowerCamelCase__       )


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__=None       ):




									"""simple docstring"""

									if color is None:
														__UpperCamelCase :   Optional[Any]									=self.edgecolor
									((__UpperCamelCase)						,							(__UpperCamelCase)						,							(__UpperCamelCase)						,							(__UpperCamelCase)) :   str									=box
									__UpperCamelCase :   List[Any]									=xa - xa
									__UpperCamelCase :   List[Any]									=ya - ya
									self.ax.add_patch(
									    mpl.patches.Rectangle(
									        (xa, ya)				,    lowerCamelCase__				,    lowerCamelCase__				,    fill=lowerCamelCase__				,    edgecolor=lowerCamelCase__				,    linewidth=self.font_size // 3				,    alpha=self.alpha				,    linestyle=self.linestyle				,    )       )


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__=None				,    lowerCamelCase__=None				,    lowerCamelCase__=None				,    lowerCamelCase__=None       ):




									"""simple docstring"""

									if len(boxes.shape       ) > 2:
														__UpperCamelCase :   List[str]									=boxes[0]
									if len(obj_ids.shape       ) > 1:
														__UpperCamelCase :   Tuple									=obj_ids[0]
									if len(obj_scores.shape       ) > 1:
														__UpperCamelCase :   int									=obj_scores[0]
									if len(attr_ids.shape       ) > 1:
														__UpperCamelCase :   str									=attr_ids[0]
									if len(attr_scores.shape       ) > 1:
														__UpperCamelCase :   Optional[int]									=attr_scores[0]
									if isinstance(lowerCamelCase__				,    torch.Tensor       ):
														__UpperCamelCase :   Dict									=boxes.numpy()
									if isinstance(lowerCamelCase__				,    lowerCamelCase__       ):
														__UpperCamelCase :   Tuple									=np.array(lowerCamelCase__       )
									assert isinstance(lowerCamelCase__				,    np.ndarray       )
									__UpperCamelCase :   Dict									=np.prod(boxes[:, 2:] - boxes[:, :2]				,    axis=1       )
									__UpperCamelCase :   int									=np.argsort(-areas       ).tolist()
									__UpperCamelCase :   Optional[Any]									=boxes[sorted_idxs] if boxes is not None else None
									__UpperCamelCase :   List[Any]									=obj_ids[sorted_idxs] if obj_ids is not None else None
									__UpperCamelCase :   Tuple									=obj_scores[sorted_idxs] if obj_scores is not None else None
									__UpperCamelCase :   Dict									=attr_ids[sorted_idxs] if attr_ids is not None else None
									__UpperCamelCase :   Optional[Any]									=attr_scores[sorted_idxs] if attr_scores is not None else None

									__UpperCamelCase :   int									=[self._random_color(maximum=1       ) for _ in range(len(lowerCamelCase__       )       )]
									__UpperCamelCase :   Tuple									=[assigned_colors[idx] for idx in sorted_idxs]
									if obj_ids is not None:
														__UpperCamelCase :   str									=self._create_text_labels_attr(lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__       )
														for i in range(len(lowerCamelCase__       )       ):
																			__UpperCamelCase :   Dict									=assigned_colors[i]
																			self.add_box(boxes[i]				,    lowerCamelCase__       )
																			self.draw_labels(labels[i]				,    boxes[i]				,    lowerCamelCase__       )


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__       ):




									"""simple docstring"""

									__UpperCamelCase						,							__UpperCamelCase						,							__UpperCamelCase						,							__UpperCamelCase :   Dict									=box
									__UpperCamelCase :   str									=(xa, ya)
									__UpperCamelCase :   Optional[int]									=(ya - ya) * (xa - xa)
									__UpperCamelCase :   Optional[Any]									=_SMALL_OBJ * self.scale
									if instance_area < small or ya - ya < 40 * self.scale:
														if ya >= self.height - 5:
																			__UpperCamelCase :   str									=(xa, ya)
														else:
																			__UpperCamelCase :   str									=(xa, ya)

									__UpperCamelCase :   Tuple									=(ya - ya) / np.sqrt(self.height * self.width       )
									__UpperCamelCase :   List[Any]									=self._change_color_brightness(lowerCamelCase__				,    brightness_factor=0.7       )
									__UpperCamelCase :   Any									=np.clip((height_ratio - 0.02) / 0.08 + 1				,    1.2				,    2       )
									font_size *= 0.75 * self.font_size

									self.draw_text(
									    text=lowerCamelCase__				,    position=lowerCamelCase__				,    color=lowerCamelCase__				,    )


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__="g"				,    lowerCamelCase__="left"				,    ):




									"""simple docstring"""

									__UpperCamelCase :   int									=0
									__UpperCamelCase :   Optional[int]									=self.font_size
									__UpperCamelCase :   Optional[Any]									=np.maximum(list(mplc.to_rgb(lowerCamelCase__       )       )				,    0.2       )
									__UpperCamelCase :   int									=max(0.8				,    np.max(lowerCamelCase__       )       )
									__UpperCamelCase :   str									={
									    'facecolor': 'black',
									    'alpha': self.alpha,
									    'pad': self.pad,
									    'edgecolor': 'none',
									}
									__UpperCamelCase						,							__UpperCamelCase :   Union[str, Any]									=position
									self.ax.text(
									    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__				,    size=font_size * self.scale				,    family='sans-serif'				,    bbox=lowerCamelCase__				,    verticalalignment='top'				,    horizontalalignment=lowerCamelCase__				,    color=lowerCamelCase__				,    zorder=10				,    rotation=lowerCamelCase__				,    )


				def  __lowercase				(					self				,    lowerCamelCase__=None       ):




									"""simple docstring"""

									if saveas is None:
														__UpperCamelCase :   Optional[int]									=self.saveas
									if saveas.lower().endswith('.jpg'       ) or saveas.lower().endswith('.png'       ):
														cva.imwrite(
														    lowerCamelCase__				,    self._get_buffer()[:, :, ::-1]				,    )
									else:
														self.fig.savefig(lowerCamelCase__       )


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__       ):




									"""simple docstring"""

									__UpperCamelCase :   Optional[int]									=[self.idaobj[i] for i in classes]
									__UpperCamelCase :   str									=[self.idaattr[i] for i in attr_classes]
									__UpperCamelCase :   Any									=[
									    f'{label} {score:.2f} {attr} {attr_score:.2f}'
									    for label, score, attr, attr_score in zip(lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__				,    lowerCamelCase__       )
									]
									return labels


				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__       ):




									"""simple docstring"""

									__UpperCamelCase :   Tuple									=[self.idaobj[i] for i in classes]
									if scores is not None:
														if labels is None:
																			__UpperCamelCase :   List[str]									=['{:.0f}%'.format(s * 100       ) for s in scores]
														else:
																			__UpperCamelCase :   Union[str, Any]									=['{} {:.0f}%'.format(lowerCamelCase__				,    s * 100       ) for li, s in zip(lowerCamelCase__				,    lowerCamelCase__       )]
									return labels


				def  __lowercase				(					self				,    lowerCamelCase__=255       ):




									"""simple docstring"""

									__UpperCamelCase :   Any									=np.random.randint(0				,    len(_COLORS       )       )
									__UpperCamelCase :   List[str]									=_COLORS[idx] * maximum
									if not self.rgb:
														__UpperCamelCase :   Optional[Any]									=ret[::-1]
									return ret


				def  __lowercase				(					self       ):




									"""simple docstring"""

									if not self.pynb:
														__UpperCamelCase						,							__UpperCamelCase :   Tuple									=self.canvas.print_to_buffer()
														if (width, height) != (self.width, self.height):
																			__UpperCamelCase :   Optional[int]									=cva.resize(self.img				,    (width, height)       )
														else:
																			__UpperCamelCase :   Tuple									=self.img
									else:
														__UpperCamelCase :   Optional[int]									=io.BytesIO()  # works for cairo backend
														self.canvas.print_rgba(lowerCamelCase__       )
														__UpperCamelCase						,							__UpperCamelCase :   int									=self.width, self.height
														__UpperCamelCase :   Union[str, Any]									=buf.getvalue()
														__UpperCamelCase :   Dict									=self.img

									__UpperCamelCase :   Dict									=np.frombuffer(lowerCamelCase__				,    dtype='uint8'       )
									__UpperCamelCase :   List[str]									=buffer.reshape(lowerCamelCase__				,    lowerCamelCase__				,    4       )
									__UpperCamelCase						,							__UpperCamelCase :   Union[str, Any]									=np.split(lowerCamelCase__				,    [3]				,    axis=2       )

									try:
														import numexpr as ne  # fuse them with numexpr

														__UpperCamelCase :   List[Any]									=ne.evaluate('img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)'       )
									except ImportError:
														__UpperCamelCase :   int									=alpha.astype('float32'       ) / 255.0
														__UpperCamelCase :   Tuple									=img * (1 - alpha) + rgb * alpha

									return visualized_image.astype('uint8'       )







				def  __lowercase				(					self				,    lowerCamelCase__				,    lowerCamelCase__       ):




									"""simple docstring"""

									assert brightness_factor >= -1.0 and brightness_factor <= 1.0
									__UpperCamelCase :   List[Any]									=mplc.to_rgb(lowerCamelCase__       )
									__UpperCamelCase :   Dict									=colorsys.rgb_to_hls(*mplc.to_rgb(lowerCamelCase__       )       )
									__UpperCamelCase :   Dict									=polygon_color[1] + (brightness_factor * polygon_color[1])
									__UpperCamelCase :   Tuple									=0.0 if modified_lightness < 0.0 else modified_lightness
									__UpperCamelCase :   str									=1.0 if modified_lightness > 1.0 else modified_lightness
									__UpperCamelCase :   Union[str, Any]									=colorsys.hls_to_rgb(polygon_color[0]				,    lowerCamelCase__				,    polygon_color[2]       )
									return modified_color
A_			:Union[str, Any]	    =		(
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)

