^jddlmZddlmZmZddlmZddlmZddl Z ddl Z ddl mZ ddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlm Z e e!Z"GddeZ#Gdde#Z$Gdde#Z%Gdde#Z&Gdde&Z'Gdde&Z(Gdde&Z)e'Z*GddZ+y)) annotations)ABCabstractmethod)Sequence)castN) pad_boxesspread_out_boxes) ImageType)Color)draw_rounded_rectangle)Rect) KeyPoints)SKELETONS_BY_VERTEX_COUNT)!ensure_cv2_image_for_class_method) _get_loggerceZdZeddZy)BaseKeyPointAnnotatorcyN)selfscene key_pointss l/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/key_points/annotators.pyannotatezBaseKeyPointAnnotator.annotates Nrr rrreturnr )__name__ __module__ __qualname__rrrrrrrs  rrcNeZdZdZej df ddZeddZy)VertexAnnotatorz A class that specializes in drawing skeleton vertices on images. It uses specified key points to determine the locations where the vertices should be drawn. c ||_||_y)z Args: color: The color to use for annotating key points. radius: The radius of the circles used to represent the key points. N)colorradius)rr&r's r__init__zVertexAnnotator.__init__%s  rc t|tjsJt|dk(r|St |j D]\}}t |D]\}\}}tj ||fdr"|j|j||fs@tj|t|t|f|j|jjd|S)ak Annotates the given scene with skeleton vertices based on the provided key points. It draws circles at each key point location. Anchors marked as not visible via ``key_points.visible`` are skipped. Args: scene: The image where skeleton vertices will be drawn. `ImageType` is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. key_points: A collection of key points where each key point consists of x and y coordinates. Returns: The annotated image, matching the type of `scene` (`numpy.ndarray` or `PIL.Image.Image`) Example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... ) >>> annotator = sv.VertexAnnotator( ... color=sv.Color.ROBOFLOW, radius=10 ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` r)imgcenterr'r& thickness) isinstancenpndarraylen enumeratexyallclosevisiblecv2circleintr'r&as_bgr)rrrdetection_indexr3 point_indexxys rrzVertexAnnotator.annotate2sJ%,,, z?a L#,Z]]#;  OR'0} # Va;;1vq)&&2&.. /KL FCF+;;**++-   " rN)r&r r'r8rNoner rr r!__doc__r ROBOFLOWr(rrrrrr#r#sH~~     '9'9rr#cTeZdZdZej ddf ddZeddZy) EdgeAnnotatorz A class that specializes in drawing skeleton edges on images using specified key points. It connects key points with lines to form the skeleton structure. Nc.||_||_||_y)a$ Args: color: The color to use for the edges. thickness: The thickness of the edges. edges: The edges to draw. If set to ``None``, will attempt to auto-detect the skeleton by vertex count. A ``Sequence[tuple[int, int]]`` applies a single skeleton to every instance. A ``dict[int, Sequence[tuple[int, int]]]`` maps ``class_id`` to skeleton edges, enabling correct rendering for datasets with multiple skeleton types. N)r&r-edges)rr&r-rFs rr(zEdgeAnnotator.__init__us& " rc t|tjsJt|dk(r|St |j D]\}}t|j tr`|jt|j|nd}| td||j vrtd|d|j |}n[|j r |j }nBtjt|}|s tjdt||}|D]\}} |dz } | dz } || } || } tj| dstj| drG|j #|j || fr|j || fsvt#j$|t| dt| dft| dt| df|j&j)|j*|S) a Annotates the given scene by drawing lines between specified key points to form edges. Edges where either endpoint is marked as not visible via ``key_points.visible`` are skipped. Args: scene: The image where skeleton edges will be drawn. `ImageType` is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. key_points: A collection of key points where each key point consists of x and y coordinates. Returns: The annotated image, matching the type of `scene` (`numpy.ndarray` or `PIL.Image.Image`) Example: Single-skeleton example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... ) >>> annotator = sv.EdgeAnnotator( ... color=sv.Color.ROBOFLOW, ... thickness=3, ... edges=[(1, 2), (1, 3)], ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` Multi-skeleton example with per-class edges: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]], ... [[700, 300], [650, 500], [0, 0]]], ... dtype=np.float32, ... ), ... class_id=np.array([0, 1]), ... visible=np.array( ... [[True, True, True], ... [True, True, False]], ... ), ... ) >>> annotator = sv.EdgeAnnotator( ... color=sv.Color.ROBOFLOW, ... thickness=3, ... edges={0: [(1, 2), (1, 3)], 1: [(1, 2)]}, ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` rNzGedges is a dict but class_id is None; KeyPoints must have class_id set.zNo edges defined for class_id=.z"No skeleton found with %d vertices)r+pt1pt2r&r-)r.r/r0r1r2r3rFdictclass_idr8 ValueErrorrgetloggerwarningr4r5r6liner&r9r-)rrrr:r3rMrF _looked_upclass_aclass_bidx_aidx_bxy_axy_bs rrzEdgeAnnotator.annotatesH%,,, z?a L#,Z]]#;,  OR$**d+"**6 ++O<= #$<4::-$'EhZq%QRR 8, 6::3r7C !NN#GRQ"$)  ! ! %y%y;;tQ'2;;tQ+?%%1&../EF)11/52HI T!Ws47|4T!Ws47|4**++-"nn  1, \ r)r&r r-r8rFzGSequence[tuple[int, int]] | dict[int, Sequence[tuple[int, int]]] | Nonerr>rr?rrrrCrCosZ~~   T  .'u'urrCceZdZdZdej ej ejfdf ddZd dZ d dZ d dZ y) _BaseVertexEllipseAnnotatorzPrivate base for ellipse-based keypoint annotators. Handles sigma/color validation, sorting, covariance extraction and eigendecomposition shared by all VertexEllipse* variants. ?@g@Nc4t|ttfr|fn|t|tr|fn|}t dk(r t dt dDr t d||dkr t dt |t k7r$t dt |dt dttt fd d }|Dcgc]}| c}|_ |Dcgc]}|| c}|_ ||_ ycc}wcc}w) Nrz%sigma must contain at least one valuec3&K|] }|dk yw)rNr).0ss r z7_BaseVertexEllipseAnnotator.__init__..s)!qAv)sz!All sigma values must be positivez'max_axis must be positive when providedzcolor length (z) must match sigma length ()c|Srr)i sigma_seqs rz6_BaseVertexEllipseAnnotator.__init__..$s 1rT)keyreverse) r.r8floatr r1rNanysortedrangesigmar&max_axis)rror&rp color_seqsorted_indicesrfrgs @rr(z$_BaseVertexEllipseAnnotator.__init__ s#53,7UHU 2Q DE E )y) )@A A  HMFG G y>S^ + Y 01!!$Y 03   #i. !'=t -;;qil; ,:;qil;   <;s  D4 Dc|jjd}| tdttj t jt j|t j}g|jjdddd}|j|k7rtd|d|jd|S)N covariancezBkey_points.data must contain 'covariance' with shape (N, K, 2, 2).dtyperDzExpected covariance shape z, got rH) datarOrNrnptNDArrayr/float32asarrayr3shape)rr covariancescovariances_arrayexpected_shapes r_get_covariancesz,_BaseVertexEllipseAnnotator._get_covariances*s oo)),7  T ! KK #RZZ 2::%N ::==..r29A9q9  " "n 4,^,<=(../q2 ! rctj|jsy tjj |j tj \}}tj|jrtj|dkrytj|ddd}|||dd|ffS#tjj$rYywxYw)zIEigendecompose a 2x2 covariance, returning sorted (eigenvalues, vectors).Nrr*) r/isfinitealllinalgeighastypefloat64 LinAlgErrorrlargsort)rrt eigenvalues eigenvectorsorders r_decompose_covariancez1_BaseVertexEllipseAnnotator._decompose_covariance;s{{:&**, (* z7H7H7T(U %K{{;'++- q8H1I ;'"-5!<5#999 yy$$  s?C C*)C*c |j|}|jDcgc]}gc}}t|jD]\}}t|D]o\}\}} t j || fdr#|j |j ||fsA|||f} |j| } | \| \} } tt jt j| d| d}t|t| f}tt|j|jD]\}\}}|t j| z}|j t j ||j}t#dt|dt#dt|df}||j%|||||fr|Scc}w)z?Return ellipse params grouped by sigma level (outermost first).r)rIr)rrrI)rror2r3r/r4r5rrkdegreesarctan2roundzipr&sqrtrpminimummaxappend)rrr}_levelsr:r3r;r<r=rt decompositionrrangler, level_idxror&axes axis_lengthss r_iter_ellipse_paramsz0_BaseVertexEllipseAnnotator._iter_ellipse_paramsJs++J7  $AR $ $-Z]]#;  OR'0} # Va;;1vq)&&2&.. /KL(+)EF $ : :: F  (,9) \JJrzz,t*PQR (E!H-1:3tzz4::;V1W -I~u 277;#77D}}0!zz$ >AuT!W~.AuT!W~.$L9%,,ueUC #  : = %s G )rofloat | Sequence[float]r&Color | Sequence[Color]rp float | Nonerr>)rrrnpt.NDArray[np.float32])rtrrz>tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None)rrrzHlist[list[tuple[tuple[int, int], tuple[int, int], float, float, Color]]]) rr r!r@r GREENYELLOWREDr(rrrrrrr[r[s*9*/++u||UYY)O!% !&!'! !  !<!" :1 : G :%#% Q%rr[ceZdZdZdej ej ejfddf dfd Ze ddZ xZ S) VertexEllipseAreaAnnotatora Draws filled semi-transparent covariance ellipses at multiple sigma levels around each keypoint, each ring in a different color. This produces a bullseye-like uncertainty visualization where inner rings represent higher probability density. !!! warning This annotator uses `key_points.data["covariance"]` with shape `(N, K, 2, 2)` in pixel coordinates. r\g?Nc8t||||||_y)ae Args: sigma: Sigma multipliers for each ring, drawn from outermost to innermost. Accepts a single float or a sequence of floats. Defaults to ``(1.0, 2.0, 3.0)``. color: The color for each sigma level. Accepts a single ``Color`` or a sequence of colors (one per sigma level). Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. opacity: Opacity of the overlay mask. Must be between ``0`` and ``1``. max_axis: Optional cap for ellipse semi-axis lengths in pixels. ror&rpNsuperr(opacityrror&rrp __class__s rr(z#VertexEllipseAreaAnnotator.__init__ & uEHE rc t|tjsJt|dk(r|S|j }|j |D]I}|D]B\}}}}} t j||||dd| jdt j DKt j||j|d|jz d||S)a Draws filled semi-transparent covariance ellipses around each keypoint. Args: scene: The image to annotate. ``ImageType`` accepts either ``numpy.ndarray`` or ``PIL.Image.Image``. key_points: Key points with covariance data in ``key_points.data["covariance"]``. Returns: The annotated image, matching the type of ``scene``. Example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... data={ ... "covariance": np.array( ... [[[[800, 0], [0, 400]], ... [[400, 0], [0, 800]], ... [[600, 0], [0, 600]]]], ... dtype=np.float32, ... ) ... }, ... ) >>> annotator = sv.VertexEllipseAreaAnnotator( ... sigma=[1.0, 2.0], ... color=[sv.Color.GREEN, sv.Color.RED], ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` rhr* r+r,rr startAngleendAngler&r-lineTyperI)dst) r.r/r0r1copyrr6ellipser9LINE_AA addWeightedr) rrroverlaylevelr,rr_sigmar&s rrz#VertexEllipseAreaAnnotator.annotatesV%,,, z?a L**,..z: E>C : eVU !%  ,,.  [[    ua$,,6FuU r rorr&rrrkrprrr>r rr r!r@r rrrr(rr __classcell__rs@rrrrsr *9*/++u||UYY)O!% &'     ,'>'>rrceZdZdZdej ej ejfddf dfd Ze ddZ xZ S) VertexEllipseOutlineAnnotatorz Draws stroke-only concentric covariance ellipse rings at multiple sigma levels around each keypoint. !!! warning This annotator uses `key_points.data["covariance"]` with shape `(N, K, 2, 2)` in pixel coordinates. r\rDNc8t||||||_y)aA Args: sigma: Sigma multipliers for each ring, drawn from outermost to innermost. Accepts a single float or a sequence of floats. Defaults to ``(1.0, 2.0, 3.0)``. color: The color for each sigma level. Accepts a single ``Color`` or a sequence of colors (one per sigma level). Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. thickness: Line thickness of the ellipse outlines. max_axis: Optional cap for ellipse semi-axis lengths in pixels. rN)rr(r-)rror&r-rprs rr(z&VertexEllipseOutlineAnnotator.__init__s $ uEHE"rc ,t|tjsJt|dk(r|S|j |D]S}|D]L\}}}}}t j ||||dd|j|jt j NU|S)a Draws stroke-only covariance ellipse outlines around each keypoint. Args: scene: The image to annotate. ``ImageType`` accepts either ``numpy.ndarray`` or ``PIL.Image.Image``. key_points: Key points with covariance data in ``key_points.data["covariance"]``. Returns: The annotated image, matching the type of ``scene``. Example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... data={ ... "covariance": np.array( ... [[[[800, 0], [0, 400]], ... [[400, 0], [0, 800]], ... [[600, 0], [0, 600]]]], ... dtype=np.float32, ... ) ... }, ... ) >>> annotator = sv.VertexEllipseOutlineAnnotator( ... sigma=[1.0, 2.0], ... color=[sv.Color.GREEN, sv.Color.RED], ... thickness=2, ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` rrr) r.r/r0r1rr6rr9r-r) rrrrr,rrrr&s rrz&VertexEllipseOutlineAnnotator.annotatesX%,,, z?a L..z: E>C : eVU !%  ,,."nn [[    r) rorr&rr-r8rprrr>rrrs@rrrsr*9*/++u||UYY)O!% #&#'# #  #  #*'='=rrceZdZUdZdZded<dejejejfddf d fd Z e d d Z xZ S) VertexEllipseHaloAnnotatora Draws filled covariance ellipses with a radial fade: full opacity at the center, smoothly falling off to zero at the ellipse boundary. The falloff follows a power curve controlled by ``decay``, producing a soft glow that is strongest near the keypoint. !!! warning This annotator uses `key_points.data["covariance"]` with shape `(N, K, 2, 2)` in pixel coordinates. r^rk_DECAYr\g333333?Nc8t||||||_y)al Args: sigma: Sigma multipliers for each ring, drawn from outermost to innermost. Accepts a single float or a sequence of floats. Defaults to ``(1.0, 2.0, 3.0)``. color: The color for each sigma level. Accepts a single ``Color`` or a sequence of colors (one per sigma level). Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``. opacity: Peak opacity at the ellipse center. Must be between ``0`` and ``1``. max_axis: Optional cap for ellipse semi-axis lengths in pixels. rNrrs rr(z#VertexEllipseHaloAnnotator.__init__Grrc<t|tjsJt|dk(r|S|jdd\}}|j tj }|j|D]}|D]\}}} } } |\} } | dk(s| dk(rd}| |z}| |z}|\}}t||z d}t||z|}t||z d}t||z|}||k\s||k\rrtj||tj |z }tj||tj |z }tj||\}}tj| }tj|}tj|}||z||zz }||z||zz}|| z dz|| z dzz} | dk}!tj| }"d| |!z |j z|"|!<|"|j"z}#tj$| j'tj }$|||||f}%|#ddddtj(f}&|%d|&z z|$|&zz|%ddtj*||j tj,|S)a Draws radially-fading covariance ellipses around each keypoint. Args: scene: The image to annotate. ``ImageType`` accepts either ``numpy.ndarray`` or ``PIL.Image.Image``. key_points: Key points with covariance data in ``key_points.data["covariance"]``. Returns: The annotated image, matching the type of ``scene``. Example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... data={ ... "covariance": np.array( ... [[[[800, 0], [0, 400]], ... [[400, 0], [0, 800]], ... [[600, 0], [0, 600]]]], ... dtype=np.float32, ... ) ... }, ... ) >>> annotator = sv.VertexEllipseHaloAnnotator( ... sigma=[1.0, 2.0], ... color=[sv.Color.GREEN, sv.Color.RED], ... ) >>> result = annotator.annotate(image.copy(), key_points) ``` rNrDrur]rI)r.r/r0r1r|rrzrrminarangemeshgridradianscossin zeros_likerrarrayr9newaxiscopytouint8)'rrrhw compositerr,rrrr&axaypad roi_half_w roi_half_hcxcyx_minx_maxy_miny_maxysxsgrid_xgrid_y angle_radcos_asin_arxrydist_sqinsidefalloff scaled_alphabgrroialpha_3s' rrz#VertexEllipseHaloAnnotator.annotate]sV%,,, z?a L{{2A1-2\\"**-E ..z:' =E>C& =: eVU%B7bAg#X #X BBOQ/BOQ/BOQ/BOQ/E>Ue^YYue2::>CYYue2::>C!#R!4JJv. y)y)e^fun4e^fun47q.BG>9 C--0#&#8T[["H&5 hhu||~RZZ@e U5[ 89&q!RZZ'78G ,sW}<AM& =' =R %))"((34 rrr)rr r!r@r__annotations__r rrrr(rrrrs@rrr8s FE*9*/++u||UYY)O!% &'     ,'['[rrceZdZdZej ej dddddf d dZ d dd Ze dd Z e d dd Z e dd Z y)VertexLabelAnnotatorz A class that draws labels of skeleton vertices on images. It uses specified key points to determine the locations where the vertices should be drawn. g?rI rFcf||_||_||_||_||_||_||_y)a Args: color: The color to use for each keypoint label. If a list is provided, the colors will be used in order for each keypoint. text_color: The color to use for the labels. If a list is provided, the colors will be used in order for each keypoint. text_scale: The scale of the text. text_thickness: The thickness of the text. text_padding: The padding around the text. border_radius: The radius of the rounded corners of the boxes. Set to a high value to produce circles. smart_position: Spread out the labels to avoid overlap. N) border_radiusr& text_color text_scaletext_thickness text_paddingsmart_position)rr&rrrrrrs rr(zVertexLabelAnnotator.__init__s9.#0*/ /9!+#1!-,rNc t|tjsJtj}|j j \}}}|dk(r|Sg}g} g} g} t|D]:} |j | } |jt|j| nd}|j|||}|j|j|}|j|j|}t|D]}|j|j| |fs!tj| |dr;t| |dt| |df}|j!|| j!||| j!||| j!||=|s|Stj"t%|| Dcgc]/\}}|j'|||j(|j*|1c}}}t-||j.}|j0r#t3|}t-||j. }t%| | | ||D]\}}}}}t5|t7j8|||j:tj<|||d|df||j(|j?|j*tj@|Scc}}w) aB Draws labels at skeleton vertex positions on the image. Vertices marked not visible via ``key_points.visible`` are skipped. Args: scene: The image where vertex labels will be drawn. `ImageType` is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`. key_points: A collection of key points where each key point consists of x and y coordinates. labels: Labels to display at each keypoint. If ``None``, keypoint indices are used. A ``list[str]`` applies the same labels to every instance. A ``dict[int, list[str]]`` maps ``class_id`` to per-class label lists, enabling correct labeling for datasets with multiple skeleton types. Returns: The annotated image, matching the type of `scene` (`numpy.ndarray` or `PIL.Image.Image`) Example: Single-skeleton example: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]]], ... dtype=np.float32, ... ), ... class_id=np.array([0]), ... visible=np.array([[True, True, True]]), ... ) >>> annotator = sv.VertexLabelAnnotator( ... color=sv.Color.ROBOFLOW, ... text_color=sv.Color.WHITE, ... border_radius=5, ... ) >>> result = annotator.annotate( ... scene=image.copy(), ... key_points=key_points, ... labels=["head", "L-foot", "R-foot"], ... ) ``` Multi-skeleton example with per-class labels: ```pycon >>> import numpy as np >>> import supervision as sv >>> image = np.zeros((800, 800, 3), dtype=np.uint8) >>> key_points = sv.KeyPoints( ... xy=np.array( ... [[[400, 200], [300, 500], [500, 500]], ... [[700, 300], [650, 500], [0, 0]]], ... dtype=np.float32, ... ), ... class_id=np.array([0, 1]), ... visible=np.array( ... [[True, True, True], ... [True, True, False]], ... ), ... ) >>> annotator = sv.VertexLabelAnnotator( ... color=sv.Color.ROBOFLOW, ... text_color=sv.Color.WHITE, ... border_radius=5, ... ) >>> result = annotator.annotate( ... scene=image.copy(), ... key_points=key_points, ... labels={ ... 0: ["head", "L-foot", "R-foot"], ... 1: ["top", "bottom", "pad"], ... }, ... ) ``` rNrI)textfontrrcenter_coordinates)xyxypx)rrectr&r)r+rorgfontFace fontScaler&r-r)!r.r/r0r6FONT_HERSHEY_SIMPLEXr3r|rnrMr8_resolve_labels_resolve_color_listr&rr5r4rrrget_text_bounding_boxrrrrrr r r from_xyxyrputTextr9r)rrrlabelsrskeletons_count points_countr all_anchors all_labels all_colorsall_text_colorsrfr3rMinstance_labelsinstance_colorsinstance_text_colorsjanchorlabelr xyxy_paddedrr&rbox box_paddeds rrzVertexLabelAnnotator.annotatesn%,,,''+5==+>+>(q a L-/ " "$ ')' @Aq!B0:/B/B/NJ''*+TX #226<RO"66tzz<PO#'#;#;$ <( @%%1%--ad3 [[A*beAh-RU1X7""6*!!/!"45!!/!"45&&';A'>? @ @2Lxx&)j%A "FE**##'#6#6'- +    Td.?.?@   *;7K+43D3D2DED8;  OT;9   4D%S* #^^J/"00   KKVSV$// '')--  ( K s4K ctj||||d\}}|\}}||dzz ||dzz ||dzz||dzzfS)N)rrr r-rrD)r6 getTextSize) rrrrrtext_wtext_hcenter_xcenter_ys rr z*VertexLabelAnnotator.get_text_bounding_boxsr $    0( v{ " v{ " v{ " v{ "   rc|"t|Dcgc] }t|c}St|tr&| t d||vrt d|d||}n|}t ||k7rt dt |d|d|Scc}w)z,Return the label list for a single instance.zHlabels is a dict but class_id is None; KeyPoints must have class_id set.zNo labels defined for class_id=rHzNumber of labels (#) must match number of key points ().)rnstrr.rLrNr1)rrrMrresolveds rr z$VertexLabelAnnotator._resolve_labelss >$),$78qCF8 8 fd # 8v% #B8*A!NOOh'HH x=L ($S]O4))5b: )9sBct|tr+t||k7rtdt|d|d|S|g|zS)z7Return a per-keypoint color list for a single instance.zNumber of colors (r'r()r.listr1rN)colorsrs rr z(VertexLabelAnnotator._resolve_color_listsW fd #6{l* (V 6--9N">Mx,&&r)r&Color | list[Color]rr.rrkrr8rr8rr8rboolr)rr rrr'list[str] | dict[int, list[str]] | Nonerr ) rr)rr8rrkrr8rztuple[int, int]rztuple[int, int, int, int])rr0rr8rMz int | Nonerz list[str])r-r.rr8rz list[Color]) rr r!r@r rAWHITEr(r staticmethodr r r rrrrrs]&+^^*/++$-"-(- -  -  ---F;? eee8 e  eN      ,  #   * $7  : '# ' '  ' 'rr), __future__rabcrrcollections.abcrtypingrr6numpyr/ numpy.typingrx!supervision.detection.utils.boxesrr supervision.draw.baser supervision.draw.colorr supervision.draw.utilsr supervision.geometry.corer supervision.key_points.corer supervision.key_points.skeletonsrsupervision.utils.conversionrsupervision.utils.loggerrrrPrr#rCr[rrrVertexEllipseAnnotatorrrrrrCs"#$ I+(9*1FJ0 X  C N+NbS)Slj"7jZb!<bJ^$?^BA!<AH4M'M'r