o e(@sddlmZddlmZmZmZmZddlZddlZ ddl m Z ddl m Z mZmZddlmZddlmZmZddlmZmZdd lmZdd lmZGd d d e ZGd dde ZGddde ZGddde ZGddde Z Gddde Z!Gddde Z"Gddde Z#Gddde Z$GdddZ%Gdd d e Z&Gd!d"d"Z'Gd#d$d$Z(Gd%d&d&e Z)Gd'd(d(e Z*dS)))sqrt)ListOptionalTupleUnionN) BaseAnnotator) ColorLookupTrace resolve_color) Detections) clip_boxesmask_to_polygons)Color ColorPalette) draw_polygon)Positionc @deZdZdZedejfdee efde defddZ dd e j d ed ee j d e j fd dZdS)BoundingBoxAnnotatorzS A class for drawing bounding boxes on an image using provided detections. color thickness color_lookupcC||_||_||_dS)aY Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the bounding box lines. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. NrrrselfrrrrJ/var/www/myenv/lib/python3.10/site-packages/supervision/annotators/core.py__init__ zBoundingBoxAnnotator.__init__Nscene detectionscustom_color_lookupreturnc Csptt|D]/}|j|t\}}}}t|j|||dur |jn|d} tj |||f||f| |j dq|S)a Annotates the given scene with bounding boxes based on the provided detections. Args: scene (np.ndarray): The image where bounding boxes will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> bounding_box_annotator = sv.BoundingBoxAnnotator() >>> annotated_frame = bounding_box_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![bounding-box-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/bounding-box-annotator-example-purple.png) Nrr! detection_idxrimgpt1pt2rr) rangelenxyxyastypeintr rrcv2 rectangleas_bgrr) rr r!r"r%x1y1x2y2rrrrannotate's$#zBoundingBoxAnnotator.annotateN__name__ __module__ __qualname____doc__rdefaultrCLASSrrr.rnpndarrayr rr6rrrrr,  rc @r) MaskAnnotatorz A class for drawing masks on an image using provided detections. !!! warning This annotator utilizes the `sv.Detections.mask`. ?ropacityrcCran Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrDrrrrDrrrrrgrzMaskAnnotator.__init__Nr r!r"r#cCs|jdur|Stj|dtjd}tt|jD]}t|j|||dur'|j n|d}|j|}| ||<qt ||j |d|j d}|tjS)a Annotates the given scene with masks based on the provided detections. Args: scene (np.ndarray): The image where masks will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> mask_annotator = sv.MaskAnnotator() >>> annotated_frame = mask_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![mask-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/mask-annotator-example-purple.png) NT)copydtyper$r)maskr?arrayuint8flipargsortarear rrr1r/ addWeightedrDr-)rr r!r" colored_maskr%rrJrrrr6ys #  zMaskAnnotator.annotater7r9r:r;r<rr=rr>rrfloatrr?r@r rr6rrrrrB^,   rBc @r)PolygonAnnotatorz A class for drawing polygons on an image using provided detections. !!! warning This annotator utilizes the `sv.Detections.mask`. rrrrcCr)aT Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the polygon lines. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. NrrrrrrrzPolygonAnnotator.__init__Nr r!r"r#cCsp|jdur|Stt|D](}|j|}t|j|||dur |jn|d}t|dD] }t||||jd}q)q |S)a Annotates the given scene with polygons based on the provided detections. Args: scene (np.ndarray): The image where polygons will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> polygon_annotator = sv.PolygonAnnotator() >>> annotated_frame = polygon_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![polygon-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/polygon-annotator-example-purple.png) Nr$)rJ)r polygonrr) rJr*r+r rrr rr)rr r!r"r%rJrrVrrrr6s* # zPolygonAnnotator.annotater7r8rrrrrUrTrUc @r)ColorAnnotatorzN A class for drawing box masks on an image using provided detections. rCrrDrcCs||_||_||_dSrE)rrrDrFrrrr rzColorAnnotator.__init__Nr r!r"r#c Cs|}tt|D].}|j|t\}}}} t|j|||dur$|jn|d} t j |||f|| f| ddq t j ||j |d|j dd}|S)a Annotates the given scene with box masks based on the provided detections. Args: scene (np.ndarray): The image where bounding boxes will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> color_annotator = sv.ColorAnnotator() >>> annotated_frame = color_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![box-mask-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/box-mask-annotator-example-purple.png) Nr$r&rIr)gamma)rGr*r+r,r-r.r rrr/r0r1rPrD) rr r!r" mask_imager%r2r3r4r5rrrrr6s,#zColorAnnotator.annotater7rRrrrrrWrArWc @sjeZdZdZeddejfdee efde de defdd Z dd e jd ed ee jde jfddZd S) HaloAnnotatorz A class for drawing Halos on an image using provided detections. !!! warning This annotator utilizes the `sv.Detections.mask`. g?(rrD kernel_sizercCs||_||_||_||_dS)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. opacity (float): Opacity of the overlay mask. Must be between `0` and `1`. kernel_size (int): The size of the average pooling kernel used for creating the halo. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrDrr])rrrDr]rrrrrbs zHaloAnnotator.__init__Nr r!r"r#c Cs(|jdur|Stj|tjd}tdg|jd|jd|jd|jd}tt|j D]%}t |j |||dur@|j n|d}|j|}t ||}|} | ||<q2t||j|jf}gd||<t|tj} |j| | } | ddddtjf} t|d| ||j}|S)a Annotates the given scene with halos based on the provided detections. Args: scene (np.ndarray): The image where masks will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> halo_annotator = sv.HaloAnnotator() >>> annotated_frame = halo_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![halo-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/halo-annotator-example-purple.png) N)rHFrrIr$)rrr)rJr? zeros_likerLrKshapereshaperMrNrOr rr logical_orr1r/blurr]cvtColorCOLOR_BGR2GRAYrDmaxnewaxis) rr r!r"rQfmaskr%rrJ color_bgrgrayalpha alpha_maskrrrr6xs4 #     zHaloAnnotator.annotater7)r9r:r;r<rr=rr>rrrSr.rr?r@r rr6rrrrr[Ys2   r[c @speZdZdZedddejfdee efde de de d ef d d Z dd e j dedee j de j fddZd S)EllipseAnnotatorzM A class for drawing ellipses on an image using provided detections. rirr start_angle end_anglercC"||_||_||_||_||_dS)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the ellipse lines. start_angle (int): Starting angle of the ellipse. end_angle (int): Ending angle of the ellipse. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrrnror)rrrrnrorrrrr  zEllipseAnnotator.__init__Nr r!r"r#c Cstt|D]H}|j|t\}}}}t|j|||dur |jn|d} t||d|f} ||} tj || t| td| fd|j |j | |j tjd q|S)a Annotates the given scene with ellipses based on the provided detections. Args: scene (np.ndarray): The image where ellipses will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> ellipse_annotator = sv.EllipseAnnotator() >>> annotated_frame = ellipse_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![ellipse-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/ellipse-annotator-example-purple.png) Nr$rgffffff?g)centeraxesangle startAngleendAnglerrlineType)r*r+r,r-r.r rrr/ellipsernror1rLINE_4) rr r!r"r%r2r3r4r5rrrwidthrrrr6s0# zEllipseAnnotator.annotater7r8rrrrrls8  rlc @sjeZdZdZeddejfdee efde de defdd Z dd e j d ed ee j de j fddZd S)BoxCornerAnnotatorzP A class for drawing box corners on an image using provided detections. rr corner_lengthrcC||_||_||_||_dS)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the corner lines. corner_length (int): Length of each corner line. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrr~r)rrrr~rrrrr zBoxCornerAnnotator.__init__Nr r!r"r#c Cstt|D]q}|j|t\}}}}t|j|||dur |jn|d} ||f||f||f||fg} | D]B\} } | |krA| |jn| |j} t j || | f| | f| |j d| |kr`| |jn| |j}t j || | f| |f| |j dq4q|S)a Annotates the given scene with box corners based on the provided detections. Args: scene (np.ndarray): The image where box corners will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> corner_annotator = sv.BoxCornerAnnotator() >>> annotated_frame = corner_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![box-corner-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/box-corner-annotator-example-purple.png) Nr$)r) r*r+r,r-r.r rrr~r/liner1r)rr r!r"r%r2r3r4r5rcornersxyx_endy_endrrrr6-s,#  zBoxCornerAnnotator.annotater7r8rrrrr{s2  r{c @r)CircleAnnotatorzK A class for drawing circle on an image using provided detections. rrrrcCr)aR Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. thickness (int): Thickness of the circle line. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. Nrrrrrrns zCircleAnnotator.__init__Nr r!r"r#c Cstt|D]K}|j|t\}}}}||d||df} t|| dd|| dd} t|j|||dur>|jn|d} t j || t| | |j dq|S)a Annotates the given scene with circles based on the provided detections. Args: scene (np.ndarray): The image where box corners will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> circle_annotator = sv.CircleAnnotator() >>> annotated_frame = circle_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![circle-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/circle-annotator-example-purple.png) rrrINr$)r'rrradiusrr) r*r+r,r-r.rr rrr/circler1r) rr r!r"r%r2r3r4r5rrdistancerrrrr6s($$zCircleAnnotator.annotater7r8rrrrris,  rc @sleZdZdZedejej fde e efde dedefddZ dd ejd ed eejd ejfddZd S) DotAnnotatorzh A class for drawing dots on an image at specific coordinates based on provided detections. r|rrpositionrcCr)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. radius (int): Radius of the drawn dots. position (Position): The anchor position for placing the dot. color_lookup (ColorLookup): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrrr)rrrrrrrrrrzDotAnnotator.__init__Nr r!r"r#cCs||j|jd}tt|D].}t|j|||dur|jn|d}t||dft||dff}t |||j | dq |S)a Annotates the given scene with dots based on the provided detections. Args: scene (np.ndarray): The image where dots will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> dot_annotator = sv.DotAnnotator() >>> annotated_frame = dot_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![dot-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/dot-annotator-example-purple.png) anchorNr$rrIrX) get_anchors_coordinatesrr*r+r rrr.r/rrr1)rr r!r"xyr%rrrrrrr6s# zDotAnnotator.annotater7r9r:r;r<rr=rCENTERrr>rrr.rr?r@r rr6rrrrrs2  rc@seZdZdZeedddej e j fde eefdede ded ed ed e fd d ZedeeefdeeefdedeeeeeffddZ  ddejdedeedeejdejf ddZdS)LabelAnnotatorzN A class for annotating labels on an image using provided detections. rCrI r text_color text_scaletext_thickness text_padding text_positionrcCs.||_||_||_||_||_||_||_dS)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating the text background. text_color (Color): The color to use for the text. text_scale (float): Font scale for the text. text_thickness (int): Thickness of the text characters. text_padding (int): Padding around the text within its background box. text_position (Position): Position of the text relative to the detection. Possible values are defined in the `Position` enum. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrrrr text_anchorr)rrrrrrrrrrrrs zLabelAnnotator.__init__center_coordinatestext_whrr#cCs |\}}|\}}|tjkr||||||fS|tjkr&||||||fS|tjkr;||d||||d|fS|tjksE|tjkr[||d||d||d||dfS|tjkrj||||||fS|tjkry||||||fS|tjkr||d|||d||fSdS)Nr) rTOP_LEFT TOP_RIGHT TOP_CENTERrCENTER_OF_MASS BOTTOM_LEFT BOTTOM_RIGHT BOTTOM_CENTER)rrrcenter_xcenter_ytext_wtext_hrrrresolve_text_background_xyxy-s:              z+LabelAnnotator.resolve_text_background_xyxyNr r!labelsr"c CsLtj}|j|jdt}t|D]\}}t|j|||dur!|j n|d} |dus1t |t |kr7|j |n||} tj | ||j |jdd\} } | d|j} | d|j}|jt|| |f|jd}|d|j}|d|j| }tj||d|df|d|d f| tjd tj|| ||f||j |j|jtjd q|S) a; Annotates the given scene with labels based on the provided detections. Args: scene (np.ndarray): The image where labels will be drawn. detections (Detections): Object detections to annotate. labels (List[str]): Optional. Custom labels for each detection. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER) >>> annotated_frame = label_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![label-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/label-annotator-example-purple.png) rNr$)textfontFace fontScalerrr)rrrrIr&)r'rorgrrrrrw)r/FONT_HERSHEY_SIMPLEXrrr-r. enumerater rrr+class_id getTextSizerrrrtupler0r1FILLEDputTextras_rgbLINE_AA)rr r!rr"fontanchors_coordinatesr%rrrrr text_w_padded text_h_paddedtext_background_xyxytext_xtext_yrrrr6Tsl%  zLabelAnnotator.annotate)NN)r9r:r;r<rr=rblackrrrr>rrSr.r staticmethodrrr?r@r rstrrr6rrrrr s^     *rc@:eZdZdZd defddZdejdedejfd d Z d S) BlurAnnotatorzM A class for blurring regions in an image using provided detections. r}r]cC ||_dS)zp Args: kernel_size (int): The size of the average pooling kernel used for blurring. N)r])rr]rrrr zBlurAnnotator.__init__r r!r#c Cs||jdd\}}t|j||fdt}|D]$\}}}} ||| ||f} t| |j|jf} | ||| ||f<q|S)a> Annotates the given scene by blurring regions based on the provided detections. Args: scene (np.ndarray): The image where blurring will be applied. detections (Detections): Object detections to annotate. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> blur_annotator = sv.BlurAnnotator() >>> annotated_frame = circle_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![blur-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/blur-annotator-example-purple.png) Nrr, resolution_wh)r_r r,r-r.r/rbr]) rr r! image_height image_width clipped_xyxyr2r3r4r5roirrrr6s  zBlurAnnotator.annotateN)r} r9r:r;r<r.rr?r@r r6rrrrrrc @sreZdZdZeejddej fde e efdede de def d d Z dd ejd edeejdejfddZd S)TraceAnnotatora+ A class for drawing trace paths on an image based on detection coordinates. !!! warning This annotator utilizes the `sv.Detections.tracker_id`. Read [here](https://supervision.roboflow.com/trackers/) to learn how to plug tracking into your inference pipeline. rrr trace_lengthrrcCs$||_t||d|_||_||_dS)aT Args: color (Union[Color, ColorPalette]): The color to draw the trace, can be a single color or a color palette. position (Position): The position of the trace. Defaults to `CENTER`. trace_length (int): The maximum length of the trace in terms of historical points. Defaults to `30`. thickness (int): The thickness of the trace lines. Defaults to `2`. color_lookup (str): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. )max_sizerN)rr tracerr)rrrrrrrrrrs zTraceAnnotator.__init__Nr r!r"r#cCs|j|tt|D]8}t|j|}t|j|||dur!|jn|d}|jj |d}t|dkrDt j || t jgd||jd}q |S)a Draws trace paths on the frame based on the detection coordinates provided. Args: scene (np.ndarray): The image on which the traces will be drawn. detections (Detections): The detections which include coordinates for which the traces will be drawn. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> from ultralytics import YOLO >>> model = YOLO('yolov8x.pt') >>> trace_annotator = sv.TraceAnnotator() >>> video_info = sv.VideoInfo.from_video_path(video_path='...') >>> frames_generator = sv.get_video_frames_generator(source_path='...') >>> tracker = sv.ByteTrack() >>> with sv.VideoSink(target_path='...', video_info=video_info) as sink: ... for frame in frames_generator: ... result = model(frame)[0] ... detections = sv.Detections.from_ultralytics(result) ... detections = tracker.update_with_detections(detections) ... annotated_frame = trace_annotator.annotate( ... scene=frame.copy(), ... detections=detections) ... sink.write_frame(frame=annotated_frame) ``` ![trace-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/trace-annotator-example-purple.png) Nr$) tracker_idrIF)rr)rputr*r+r.rr rrgetr/ polylinesr-r?int32r1r)rr r!r"r%rrrrrrr6 s, .  zTraceAnnotator.annotater7rrrrrrs8   rc @s\eZdZdZejdddddfdeded ed ed ed ef d dZde j de de j fddZ dS)HeatMapAnnotatorz A class for drawing heatmaps on an image based on provided detections. Heat accumulates over time and is drawn as a semi-transparent overlay of blurred circles. g?r\r}rrDrr]top_huelow_huecCs.||_||_||_||_d|_||_||_dS)a Args: position (Position): The position of the heatmap. Defaults to `BOTTOM_CENTER`. opacity (float): Opacity of the overlay mask, between 0 and 1. radius (int): Radius of the heat circle. kernel_size (int): Kernel size for blurring the heatmap. top_hue (int): Hue at the top of the heatmap. Defaults to 0 (red). low_hue (int): Hue at the bottom of the heatmap. Defaults to 125 (blue). N)rrDrr] heat_maskrr)rrrDrr]rrrrrrZs zHeatMapAnnotator.__init__r r!r#cCsH|jdurt|jdd|_t|jdd}||jD]}t|t|dt|df|j ddq ||j|_|j }|j || |j |j }|tj}|jdurft||j|jf}t|j}||d<d|d<d|d <t|tjtj}t|jtjtjdk}t||j|d|jd|||<|S) a0 Annotates the scene with a heatmap based on the provided detections. Args: scene (np.ndarray): The image where the heatmap will be drawn. detections (Detections): Object detections to annotate. Returns: Annotated image. Example: ```python >>> import supervision as sv >>> from ultralytics import YOLO >>> model = YOLO('yolov8x.pt') >>> heat_map_annotator = sv.HeatMapAnnotator() >>> video_info = sv.VideoInfo.from_video_path(video_path='...') >>> frames_generator = get_video_frames_generator(source_path='...') >>> with sv.VideoSink(target_path='...', video_info=video_info) as sink: ... for frame in frames_generator: ... result = model(frame)[0] ... detections = sv.Detections.from_ultralytics(result) ... annotated_frame = heat_map_annotator.annotate( ... scene=frame.copy(), ... detections=detections) ... sink.write_frame(frame=annotated_frame) ``` ![heatmap-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/heat-map-annotator-example-purple.png) NrrrIrX).r).rI).r)rr?zerosr_rrr/rr.rrGrrerr-rLr]rbrc COLOR_HSV2BGRCOLOR_GRAY2BGRrPrD)rr r!rJrtemphsvrrrr6us* %*     zHeatMapAnnotator.annotateN) r9r:r;r<rrrSr.rr?r@r r6rrrrrSs, rc@r) PixelateAnnotatorzO A class for pixelating regions in an image using provided detections.  pixel_sizecCr)zQ Args: pixel_size (int): The size of the pixelation. N)r)rrrrrrrzPixelateAnnotator.__init__r r!r#c Cs|jdd\}}t|j||fdt}|D]:\}}}} ||| ||f} tj| dd|jd|jd} tj| | jd| jdftjd} | ||| ||f<q|S)a\ Annotates the given scene by pixelating regions based on the provided detections. Args: scene (np.ndarray): The image where pixelating will be applied. detections (Detections): Object detections to annotate. Returns: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> pixelate_annotator = sv.PixelateAnnotator() >>> annotated_frame = pixelate_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![pixelate-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/pixelate-annotator-example-10.png) NrrrI)srcdsizefxfyr)rr interpolation) r_r r,r-r.r/resizer INTER_NEAREST) rr r!rrrr2r3r4r5r scaled_up_roiscaled_down_roirrrr6s$! zPixelateAnnotator.annotateN)rrrrrrrrrc @sreZdZdZeddejej fde e efde de dedef dd Z dd ejd ed eejdejfddZd S)TriangleAnnotatorzt A class for drawing triangle markers on an image at specific coordinates based on provided detections. rrbaseheightrrcCrp)a Args: color (Union[Color, ColorPalette]): The color or color palette to use for annotating detections. base (int): The base width of the triangle. height (int): The height of the triangle. position (Position): The anchor position for placing the triangle. color_lookup (ColorLookup): Strategy for mapping colors to annotations. Options are `INDEX`, `CLASS`, `TRACK`. N)rrrrr)rrrrrrrrrrrqzTriangleAnnotator.__init__Nr r!r"r#c Cs|j|jd}tt|D]M}t|j|||dur|jn|d}t||dft||df}}t ||j d||j g||j d||j g||ggtj } t || g|q |S)a Annotates the given scene with triangles based on the provided detections. Args: scene (np.ndarray): The image where triangles will be drawn. detections (Detections): Object detections to annotate. custom_color_lookup (Optional[np.ndarray]): Custom color lookup array. Allows to override the default color mapping strategy. Returns: np.ndarray: The annotated image. Example: ```python >>> import supervision as sv >>> image = ... >>> detections = sv.Detections(...) >>> triangle_annotator = sv.TriangleAnnotator() >>> annotated_frame = triangle_annotator.annotate( ... scene=image.copy(), ... detections=detections ... ) ``` ![triangle-annotator-example](https://media.roboflow.com/ supervision-annotator-examples/triangle-annotator-example.png) rNr$rrIr)rrr*r+r rrr.r?rKrrrr/fillPolyr1) rr r!r"rr%rtip_xtip_yverticesrrrr6s(#" zTriangleAnnotator.annotater7)r9r:r;r<rr=rrrr>rrr.rr?r@r rr6rrrrrs8  r)+mathrtypingrrrrr/numpyr?supervision.annotators.basersupervision.annotators.utilsrr r supervision.detection.corer supervision.detection.utilsr r supervision.draw.colorrrsupervision.draw.utilsrsupervision.geometry.corerrrBrUrWr[rlr{rrrrrrrrrrrrs6     NSVR`ZVSM(9j^B