
"""simple docstring"""
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   :      Optional[int]       =				1_000






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







      if isinstance(a__    ,     torch.Tensor  ):
        _snake_case  :    Optional[Any]            = img.numpy().astype("np.uint8"  )
      if isinstance(a__    ,     a__  ):
        _snake_case  :    List[str]            = img_tensorize(a__  )
      assert isinstance(a__    ,     np.ndarray  )

      _snake_case      ,       _snake_case  :    Tuple            = img.shape[1], img.shape[0]
      _snake_case  :    str            = mplfigure.Figure(frameon=a__  )
      _snake_case  :    str            = fig.get_dpi()
      _snake_case  :    str            = (width * scale + 1E-2) / dpi
      _snake_case  :    List[str]            = (height * scale + 1E-2) / dpi
      fig.set_size_inches(a__    ,     a__  )
      _snake_case  :    int            = fig.add_axes([0.0, 0.0, 1.0, 1.0]  )
      ax.axis("off"  )
      ax.set_xlim(0.0    ,     a__  )
      ax.set_ylim(a__  )

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







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







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

      _snake_case  :    Optional[Any]            = [self._random_color(maximum=1  ) for _ in range(len(a__  )  )]
      _snake_case  :    List[str]            = [assigned_colors[idx] for idx in sorted_idxs]
      if obj_ids is not None:
        _snake_case  :    str            = self._create_text_labels_attr(a__    ,     a__    ,     a__    ,     a__  )
        for i in range(len(a__  )  ):
          _snake_case  :    Union[str, Any]            = assigned_colors[i]
          self.add_box(boxes[i]    ,     a__  )
          self.draw_labels(labels[i]    ,     boxes[i]    ,     a__  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case  :    Dict            = box
      _snake_case  :    str            = (xa, ya)
      _snake_case  :    str            = (ya - ya) * (xa - xa)
      _snake_case  :    int            = _SMALL_OBJ * self.scale
      if instance_area < small or ya - ya < 40 * self.scale:
        if ya >= self.height - 5:
          _snake_case  :    int            = (xa, ya)
        else:
          _snake_case  :    str            = (xa, ya)

      _snake_case  :    int            = (ya - ya) / np.sqrt(self.height * self.width  )
      _snake_case  :    Dict            = self._change_color_brightness(a__    ,     brightness_factor=0.7  )
      _snake_case  :    Any            = np.clip((height_ratio - 0.02) / 0.08 + 1    ,     1.2    ,     2  )
      font_size *= 0.75 * self.font_size

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







      if saveas is None:
        _snake_case  :    int            = self.saveas
      if saveas.lower().endswith(".jpg"  ) or saveas.lower().endswith(".png"  ):
        cva.imwrite(
            a__    ,     self._get_buffer()[:, :, ::-1]    ,     )
      else:
        self.fig.savefig(a__  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Union[str, Any]            = [self.idaobj[i] for i in classes]
      _snake_case  :    Union[str, Any]            = [self.idaattr[i] for i in attr_classes]
      _snake_case  :    Optional[Any]            = [
          F'{label} {score:.2f} {attr} {attr_score:.2f}'
          for label, score, attr, attr_score in zip(a__    ,     a__    ,     a__    ,     a__  )
      ]
      return labels
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    int            = [self.idaobj[i] for i in classes]
      if scores is not None:
        if labels is None:
          _snake_case  :    List[str]            = ["{:.0f}%".format(s * 1_00  ) for s in scores]
        else:
          _snake_case  :    Dict            = ["{} {:.0f}%".format(a__    ,     s * 1_00  ) for li, s in zip(a__    ,     a__  )]
      return labels
    def        lowerCamelCase__						(     self    ,     snake_case_=2_55  ):
      _snake_case  :    List[str]            = np.random.randint(0    ,     len(_COLORS  )  )
      _snake_case  :    Union[str, Any]            = _COLORS[idx] * maximum
      if not self.rgb:
        _snake_case  :    Union[str, Any]            = ret[::-1]
      return ret
    def        lowerCamelCase__						(     self  ):







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

      _snake_case  :    List[Any]            = np.frombuffer(a__    ,     dtype="uint8"  )
      _snake_case  :    int            = buffer.reshape(a__    ,     a__    ,     4  )
      _snake_case      ,       _snake_case  :    List[Any]            = np.split(a__    ,     [3]    ,     axis=2  )

      try:
        import numexpr as ne  # fuse them with numexpr

        _snake_case  :    Dict            = ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"  )
      except ImportError:
        _snake_case  :    List[Any]            = alpha.astype("float32"  ) / 2_55.0
        _snake_case  :    Any            = img * (1 - alpha) + rgb * alpha

      return visualized_image.astype("uint8"  )


    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_  ):
      assert brightness_factor >= -1.0 and brightness_factor <= 1.0
      _snake_case  :    str            = mplc.to_rgb(a__  )
      _snake_case  :    Dict            = colorsys.rgb_to_hls(*mplc.to_rgb(a__  )  )
      _snake_case  :    Optional[Any]            = polygon_color[1] + (brightness_factor * polygon_color[1])
      _snake_case  :    Any            = 0.0 if modified_lightness < 0.0 else modified_lightness
      _snake_case  :    List[Any]            = 1.0 if modified_lightness > 1.0 else modified_lightness
      _snake_case  :    Optional[int]            = colorsys.hls_to_rgb(polygon_color[0]    ,     a__    ,     polygon_color[2]  )
      return modified_color


_a   :      Dict       =				(
    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)
)





"""simple docstring"""


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_											=     10_00
class snake_case   :







		def __init__(       self   :							Optional[int]     , a__   :							int     , a__   :							List[str]=1.2     , a__   :							int="g"     , a__   :							List[Any]=0.5     , a__   :							Tuple="-"     , a__   :							Optional[int]="test_out.jpg"     , a__   :							Tuple=True     , a__   :							List[str]=False     , a__   :							Dict=None     , a__   :							Optional[Any]=None     , a__   :							Optional[int]=0.7     , )							->    Union[str, Any]:





						'''simple docstring'''







						if isinstance(a__     , torch.Tensor		):
										_A       	=      img.numpy().astype("np.uint8"		)
						if isinstance(a__     , a__		):
										_A       	=      img_tensorize(a__		)
						assert isinstance(a__     , np.ndarray		)

						_A	,		_A       	=      img.shape[1], img.shape[0]
						_A       	=      mplfigure.Figure(frameon=a__		)
						_A       	=      fig.get_dpi()
						_A       	=      (width * scale + 1E-2) / dpi
						_A       	=      (height * scale + 1E-2) / dpi
						fig.set_size_inches(a__     , a__		)
						_A       	=      fig.add_axes([0.0, 0.0, 1.0, 1.0]		)
						ax.axis("off"		)
						ax.set_xlim(0.0     , a__		)
						ax.set_ylim(a__		)

						_A       	=      saveas
						_A       	=      rgb
						_A       	=      pynb
						_A       	=      img
						_A       	=      edgecolor
						_A       	=      0.5
						_A       	=      linestyle
						_A       	=      int(np.sqrt(min(a__     , a__		)		) * scale // 3		)
						_A       	=      width
						_A       	=      height
						_A       	=      scale
						_A       	=      fig
						_A       	=      ax
						_A       	=      pad
						_A       	=      idaobj
						_A       	=      idaattr
						_A       	=      FigureCanvasAgg(a__		)







		def 			a_			(       self   :							List[Any]     , a__   :							Union[str, Any]     , a__   :							Tuple=None		)							->    Tuple:





						'''simple docstring'''







						if color is None:
										_A       	=      self.edgecolor
						((_A)	,		(_A)	,		(_A)	,		(_A))       	=      box
						_A       	=      xa - xa
						_A       	=      ya - ya
						self.ax.add_patch(
						    mpl.patches.Rectangle(
						        (xa, ya)     , a__     , a__     , fill=a__     , edgecolor=a__     , linewidth=self.font_size // 3     , alpha=self.alpha     , linestyle=self.linestyle     , )		)







		def 			a_			(       self   :							Union[str, Any]     , a__   :							Dict     , a__   :							List[Any]=None     , a__   :							int=None     , a__   :							str=None     , a__   :							Optional[int]=None		)							->    List[str]:





						'''simple docstring'''







						if len(boxes.shape		) > 2:
										_A       	=      boxes[0]
						if len(obj_ids.shape		) > 1:
										_A       	=      obj_ids[0]
						if len(obj_scores.shape		) > 1:
										_A       	=      obj_scores[0]
						if len(attr_ids.shape		) > 1:
										_A       	=      attr_ids[0]
						if len(attr_scores.shape		) > 1:
										_A       	=      attr_scores[0]
						if isinstance(a__     , torch.Tensor		):
										_A       	=      boxes.numpy()
						if isinstance(a__     , a__		):
										_A       	=      np.array(a__		)
						assert isinstance(a__     , np.ndarray		)
						_A       	=      np.prod(boxes[:, 2:] - boxes[:, :2]     , axis=1		)
						_A       	=      np.argsort(-areas		).tolist()
						_A       	=      boxes[sorted_idxs] if boxes is not None else None
						_A       	=      obj_ids[sorted_idxs] if obj_ids is not None else None
						_A       	=      obj_scores[sorted_idxs] if obj_scores is not None else None
						_A       	=      attr_ids[sorted_idxs] if attr_ids is not None else None
						_A       	=      attr_scores[sorted_idxs] if attr_scores is not None else None

						_A       	=      [self._random_color(maximum=1		) for _ in range(len(a__		)		)]
						_A       	=      [assigned_colors[idx] for idx in sorted_idxs]
						if obj_ids is not None:
										_A       	=      self._create_text_labels_attr(a__     , a__     , a__     , a__		)
										for i in range(len(a__		)		):
														_A       	=      assigned_colors[i]
														self.add_box(boxes[i]     , a__		)
														self.draw_labels(labels[i]     , boxes[i]     , a__		)







		def 			a_			(       self   :							List[str]     , a__   :							Any     , a__   :							List[str]     , a__   :							Tuple		)							->    int:





						'''simple docstring'''







						_A	,		_A	,		_A	,		_A       	=      box
						_A       	=      (xa, ya)
						_A       	=      (ya - ya) * (xa - xa)
						_A       	=      _SMALL_OBJ * self.scale
						if instance_area < small or ya - ya < 40 * self.scale:
										if ya >= self.height - 5:
														_A       	=      (xa, ya)
										else:
														_A       	=      (xa, ya)

						_A       	=      (ya - ya) / np.sqrt(self.height * self.width		)
						_A       	=      self._change_color_brightness(a__     , brightness_factor=0.7		)
						_A       	=      np.clip((height_ratio - 0.0_2) / 0.0_8 + 1     , 1.2     , 2		)
						font_size *= 0.7_5 * self.font_size

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







		def 			a_			(       self   :							str     , a__   :							Optional[int]     , a__   :							Optional[int]     , a__   :							Any="g"     , a__   :							Optional[int]="left"     , )							->    Dict:





						'''simple docstring'''







						_A       	=      0
						_A       	=      self.font_size
						_A       	=      np.maximum(list(mplc.to_rgb(a__		)		)     , 0.2		)
						_A       	=      max(0.8     , np.max(a__		)		)
						_A       	=      {
						    "facecolor": "black",
						    "alpha": self.alpha,
						    "pad": self.pad,
						    "edgecolor": "none",
						}
						_A	,		_A       	=      position
						self.ax.text(
						    a__     , a__     , a__     , size=font_size * self.scale     , family="sans-serif"     , bbox=a__     , verticalalignment="top"     , horizontalalignment=a__     , color=a__     , zorder=10     , rotation=a__     , )







		def 			a_			(       self   :							List[str]     , a__   :							str=None		)							->    Optional[int]:





						'''simple docstring'''







						if saveas is None:
										_A       	=      self.saveas
						if saveas.lower().endswith(".jpg"		) or saveas.lower().endswith(".png"		):
										cva.imwrite(
										    a__     , self._get_buffer()[:, :, ::-1]     , )
						else:
										self.fig.savefig(a__		)







		def 			a_			(       self   :							Union[str, Any]     , a__   :							Optional[Any]     , a__   :							List[Any]     , a__   :							Tuple     , a__   :							List[str]		)							->    Optional[int]:





						'''simple docstring'''







						_A       	=      [self.idaobj[i] for i in classes]
						_A       	=      [self.idaattr[i] for i in attr_classes]
						_A       	=      [
						    F"""{label} {score:.2f} {attr} {attr_score:.2f}"""
						    for label, score, attr, attr_score in zip(a__     , a__     , a__     , a__		)
						]
						return labels







		def 			a_			(       self   :							Any     , a__   :							Dict     , a__   :							Tuple		)							->    Dict:





						'''simple docstring'''







						_A       	=      [self.idaobj[i] for i in classes]
						if scores is not None:
										if labels is None:
														_A       	=      ["{:.0f}%".format(s * 1_00		) for s in scores]
										else:
														_A       	=      ["{} {:.0f}%".format(a__     , s * 1_00		) for li, s in zip(a__     , a__		)]
						return labels







		def 			a_			(       self   :							List[Any]     , a__   :							Optional[Any]=2_55		)							->    str:





						'''simple docstring'''







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







		def 			a_			(       self   :							int		)							->    Dict:





						'''simple docstring'''







						if not self.pynb:
										_A	,		_A       	=      self.canvas.print_to_buffer()
										if (width, height) != (self.width, self.height):
														_A       	=      cva.resize(self.img     , (width, height)		)
										else:
														_A       	=      self.img
						else:
										_A       	=      io.BytesIO()  # works for cairo backend
										self.canvas.print_rgba(a__		)
										_A	,		_A       	=      self.width, self.height
										_A       	=      buf.getvalue()
										_A       	=      self.img

						_A       	=      np.frombuffer(a__     , dtype="uint8"		)
						_A       	=      buffer.reshape(a__     , a__     , 4		)
						_A	,		_A       	=      np.split(a__     , [3]     , axis=2		)

						try:
										import numexpr as ne  # fuse them with numexpr

										_A       	=      ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"		)
						except ImportError:
										_A       	=      alpha.astype("float32"		) / 2_5_5.0
										_A       	=      img * (1 - alpha) + rgb * alpha

						return visualized_image.astype("uint8"		)







		def 			a_			(       self   :							Optional[int]     , a__   :							str     , a__   :							Union[str, Any]		)							->    str:





						'''simple docstring'''







						assert brightness_factor >= -1.0 and brightness_factor <= 1.0
						_A       	=      mplc.to_rgb(a__		)
						_A       	=      colorsys.rgb_to_hls(*mplc.to_rgb(a__		)		)
						_A       	=      polygon_color[1] + (brightness_factor * polygon_color[1])
						_A       	=      0.0 if modified_lightness < 0.0 else modified_lightness
						_A       	=      1.0 if modified_lightness > 1.0 else modified_lightness
						_A       	=      colorsys.hls_to_rgb(polygon_color[0]     , a__     , polygon_color[2]		)
						return modified_color





a_											=     (
    np.array(
        [
            0.0_00,
            0.4_47,
            0.7_41,
            0.8_50,
            0.3_25,
            0.0_98,
            0.9_29,
            0.6_94,
            0.1_25,
            0.4_94,
            0.1_84,
            0.5_56,
            0.4_66,
            0.6_74,
            0.1_88,
            0.3_01,
            0.7_45,
            0.9_33,
            0.6_35,
            0.0_78,
            0.1_84,
            0.3_00,
            0.3_00,
            0.3_00,
            0.6_00,
            0.6_00,
            0.6_00,
            1.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.7_49,
            0.7_49,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            0.0_00,
            0.3_33,
            0.6_67,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            0.3_33,
            0.0_00,
            0.6_67,
            0.6_67,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.3_33,
            0.5_00,
            0.0_00,
            0.6_67,
            0.5_00,
            0.0_00,
            1.0_00,
            0.5_00,
            0.3_33,
            0.0_00,
            0.5_00,
            0.3_33,
            0.3_33,
            0.5_00,
            0.3_33,
            0.6_67,
            0.5_00,
            0.3_33,
            1.0_00,
            0.5_00,
            0.6_67,
            0.0_00,
            0.5_00,
            0.6_67,
            0.3_33,
            0.5_00,
            0.6_67,
            0.6_67,
            0.5_00,
            0.6_67,
            1.0_00,
            0.5_00,
            1.0_00,
            0.0_00,
            0.5_00,
            1.0_00,
            0.3_33,
            0.5_00,
            1.0_00,
            0.6_67,
            0.5_00,
            1.0_00,
            1.0_00,
            0.5_00,
            0.0_00,
            0.3_33,
            1.0_00,
            0.0_00,
            0.6_67,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            0.0_00,
            1.0_00,
            0.3_33,
            0.3_33,
            1.0_00,
            0.3_33,
            0.6_67,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            0.0_00,
            1.0_00,
            0.6_67,
            0.3_33,
            1.0_00,
            0.6_67,
            0.6_67,
            1.0_00,
            0.6_67,
            1.0_00,
            1.0_00,
            1.0_00,
            0.0_00,
            1.0_00,
            1.0_00,
            0.3_33,
            1.0_00,
            1.0_00,
            0.6_67,
            1.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_67,
            0.0_00,
            0.0_00,
            0.3_33,
            0.0_00,
            0.0_00,
            0.5_00,
            0.0_00,
            0.0_00,
            0.6_67,
            0.0_00,
            0.0_00,
            0.8_33,
            0.0_00,
            0.0_00,
            1.0_00,
            0.0_00,
            0.0_00,
            0.0_00,
            0.1_43,
            0.1_43,
            0.1_43,
            0.8_57,
            0.8_57,
            0.8_57,
            1.0_00,
            1.0_00,
            1.0_00,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)