^jLVddlmZddlZddlmZmZddlmZmZddl m Z m Z m Z ddl Zddlm ZddlmZddlmZddlmZmZdd lmZmZdd lmZdd lmZej>e Z!e e"e#e$e"e$e%ejLejNejLejPfZ)e*e)e)fZ+e e"ejXe ejLejZe$e e#fZ.e ejLejZe$e e#fZ/ dd Z0 dd Z1edGddZ2y)) annotationsN)IterableIterator) dataclassfield)AnyUnioncast)CLASS_NAME_DATA_FIELD) Detections) get_data_item is_data_equal) OverlapMetricbox_non_max_suppression)warn_deprecated)_validate_keypoints_fieldscJ|| |duxr|duStj||SN)np array_equal)firstseconds f/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/key_points/core.py_optional_array_equalr*s1 }}/4/ >>% ((ct|ttjfr-t t tj t|gSt|tjrD|jtk(r1t t tj|jSt|tjr.|jdk(rt t |jdSt|trJ|rHtd|Dr6t t tjtj |S|S)aNormalise *i* to a 1-D row index for 1-D per-object fields. Handles: - Python int or np.integer scalar -> np.array([int(i)]) - boolean np.ndarray (any shape) -> np.flatnonzero(i.ravel()) - non-bool 0-d np.ndarray -> reshaped to shape (1,) - list of bool -> np.flatnonzero(np.array(i)) - slice, list of ints, 1-D ndarray -> returned as-is rc3<K|]}t|tywr isinstancebool.0xs r z'_normalize_row_index..Es(HAt)<(H)r intrintegerr _NormalizedRowIndexarrayndarraydtyper! flatnonzeroravelndimreshapelistall)is r_normalize_row_indexr43s!c2::&''3q6();<<!RZZ QWW_' )BCC!RZZ QVVq['166!TqS(Ha(H%H' )DEE HrF)initceZdZUdZded<dZded<dZded<dZded <dZd ed <e e Z d ed< d&dd d'dZ d(dZ ed)dZej d*dZd+dZ d,dZd-dZed.dZe d/dZed0dZed1dZed2dZed3dZd4dZ d5dZd6dZed7d Zd8d!Zd"d#e jBf d9d$Z" d: d;d%Z#y)< KeyPointsu# The `sv.KeyPoints` class in the Supervision library standardizes results from various keypoint detection and pose estimation models into a consistent format. This class simplifies data manipulation and filtering, providing a uniform API for integration with Supervision [keypoints annotators](/latest/keypoint/annotators). === "RF-DETR" [RF-DETR](https://github.com/roboflow/rf-detr) keypoint models return `sv.KeyPoints` directly from `model.predict()` — no additional conversion is needed. ```python import cv2 import supervision as sv from rfdetr import RFDETRKeypointPreview image = cv2.imread("") model = RFDETRKeypointPreview() key_points = model.predict(image) ``` === "Ultralytics" Use [`sv.KeyPoints.from_ultralytics`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_ultralytics) method, which accepts [YOLOv8-pose](https://docs.ultralytics.com/models/yolov8/), [YOLO11-pose](https://docs.ultralytics.com/models/yolo11/) [pose](https://docs.ultralytics.com/tasks/pose/) result. ```python import cv2 import supervision as sv from ultralytics import YOLO image = cv2.imread("") model = YOLO('yolo11s-pose.pt') result = model(image)[0] key_points = sv.KeyPoints.from_ultralytics(result) ``` === "Inference" Use [`sv.KeyPoints.from_inference`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_inference) method, which accepts [Inference](https://inference.roboflow.com/) pose result. ```python import cv2 import supervision as sv from inference import get_model image = cv2.imread("") model = get_model(model_id="", api_key="") result = model.infer(image)[0] key_points = sv.KeyPoints.from_inference(result) ``` === "MediaPipe" Use [`sv.KeyPoints.from_mediapipe`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_mediapipe) method, which accepts [MediaPipe](https://github.com/google-ai-edge/mediapipe) pose result. ```python import cv2 import mediapipe as mp import supervision as sv image = cv2.imread("") image_height, image_width, _ = image.shape mediapipe_image = mp.Image( image_format=mp.ImageFormat.SRGB, data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) options = mp.tasks.vision.PoseLandmarkerOptions( base_options=mp.tasks.BaseOptions( model_asset_path="pose_landmarker_heavy.task" ), running_mode=mp.tasks.vision.RunningMode.IMAGE, num_poses=2) PoseLandmarker = mp.tasks.vision.PoseLandmarker with PoseLandmarker.create_from_options(options) as landmarker: pose_landmarker_result = landmarker.detect(mediapipe_image) key_points = sv.KeyPoints.from_mediapipe( pose_landmarker_result, (image_width, image_height)) ``` === "Transformers" Use [`sv.KeyPoints.from_transformers`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_transformers) method, which accepts [ViTPose](https://huggingface.co/docs/transformers/en/model_doc/vitpose) result. ```python from PIL import Image import requests import supervision as sv import torch from transformers import ( AutoProcessor, RTDetrForObjectDetection, VitPoseForPoseEstimation, ) device = "cuda" if torch.cuda.is_available() else "cpu" image = Image.open("") DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365" detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True) detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=DEVICE) inputs = detection_processor(images=frame, return_tensors="pt").to(DEVICE) with torch.no_grad(): outputs = detection_model(**inputs) target_size = torch.tensor([(frame.height, frame.width)]) results = detection_processor.post_process_object_detection( outputs, target_sizes=target_size, threshold=0.3) detections = sv.Detections.from_transformers(results[0]) boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy) POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple" pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID) pose_estimation_model = VitPoseForPoseEstimation.from_pretrained( POSE_ESTIMATION_MODEL_ID, device_map=DEVICE) inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(DEVICE) with torch.no_grad(): outputs = pose_estimation_model(**inputs) results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes]) key_point = sv.KeyPoints.from_transformers(results[0]) ``` Attributes: xy: An array of shape `(n, m, 2)` containing `n` detected objects, each composed of `m` equally-sized sets of key points, where each point is `[x, y]`. class_id: An array of shape `(n,)` containing the class ids of the detected objects. keypoint_confidence: An array of shape `(n, m)` containing the confidence scores of each keypoint. detection_confidence: An array of shape `(n,)` containing the detection-level confidence scores. visible: An optional boolean array of shape `(n, m)` indicating which keypoints are visible. When ``None``, all keypoints are treated as visible. Set this to filter anchors without removing data: ``key_points.visible = key_points.keypoint_confidence > 0.3``. data: A dictionary containing additional data where each key is a string representing the data type, and the value is either a NumPy array or a list of corresponding data of length `n` (one entry per detected object). npt.NDArray[np.float32]xyNnpt.NDArray[np.int_] | Noneclass_idnpt.NDArray[np.float32] | Nonekeypoint_confidencedetection_confidencenpt.NDArray[np.bool_] | Nonevisible)default_factoryz.dict[str, npt.NDArray[np.generic] | list[Any]]data) confidencec|| tdtd|}||_||_||_||_||_||ni|_|jy)aInitialize KeyPoints. Args: xy: Array of shape `(n, m, 2)` with keypoint coordinates. class_id: Array of shape `(n,)` with class IDs. Defaults to None. keypoint_confidence: Array of shape `(n, m)` with per-keypoint confidence scores. Defaults to None. detection_confidence: Array of shape `(n,)` with detection-level confidence scores. Defaults to None. visible: Boolean array of shape `(n, m)` indicating visible keypoints. Defaults to None. data: Dictionary of additional per-detection data arrays. Defaults to an empty dict. confidence: Deprecated since `0.29.0`, removed in `0.32.0`. Use ``keypoint_confidence`` instead. Raises ``ValueError`` if passed together with ``keypoint_confidence``. Raises: ValueError: If both ``confidence`` and ``keypoint_confidence`` are provided. NuwCannot pass both 'confidence' and 'keypoint_confidence'. 'confidence' is deprecated — use 'keypoint_confidence' only.z'confidence' parameter in `KeyPoints()` is deprecated since `0.29.0` and will be removed in `0.32.0`. Use 'keypoint_confidence' instead.) ValueErrorrr9r;r=r>r@rB __post_init__)selfr9r;r=r>r@rBrCs r__init__zKeyPoints.__init__sz@  !". U 1  #-   #6 $8!  ,D"  rct|j|j|j|j|j |j y)N)r9r;rCr>r@rB)rr9r;r=r>r@rBrGs rrFzKeyPoints.__post_init__*s8"ww]]//!%!:!:LL  rc0td|jS)z=Deprecated since 0.29.0. Use ``keypoint_confidence`` instead.}'KeyPoints.confidence' is deprecated since 0.29.0 and will be removed in 0.32.0. Use 'KeyPoints.keypoint_confidence' instead.rr=rJs rrCzKeyPoints.confidence4s   N '''rc(td||_y)NrLrM)rGvalues rrCzKeyPoints.confidence=s N $) rc,t|jS)a Returns the number of objects in the `sv.KeyPoints` object. Returns: The number of objects. Example: ```pycon >>> import numpy as np >>> import supervision as sv >>> xy = np.array([[[10, 20], [30, 40]]], dtype=np.float32) >>> key_points = sv.KeyPoints(xy=xy) >>> len(key_points) 1 ``` )lenr9rJs r__len__zKeyPoints.__len__Es$477|rc#Ktt|jD]a}|j||j|j|nd|j|j|ndt |j |fcyw)z Iterates over the Keypoint object and yield a tuple of `(xy, keypoint_confidence, class_id, data)` for each object detection. N)rangerQr9r=r;r rB)rGr3s r__iter__zKeyPoints.__iter__Ys}s477|$ A ++7((+$(MM$= a 4dii+   sBBc t|tstStt j |j |j t|j|jt|j|jt|j|jt|j|jt|j|jgSr)r r7NotImplementedr2rrr9rr;r=r>r@rrB)rGothers r__eq__zKeyPoints.__eq__qs%+! !tww1%dmmU^^D%,,e.G.G&--u/I/I&dllEMMBdii4   rc,t|tr tdt|dr|j dd}nt|dr|j }|j ds|jSg}g}g}g}|dD]}g}g}|dD]/} |j| d| d g|j| d 1|j||j||j|d |j|d ttj|i} |tj|tj tj|tj tj|t | S)a Create a `sv.KeyPoints` object from the [Roboflow](https://roboflow.com/) API inference result or the [Inference](https://inference.roboflow.com/) package results. Args: inference_result: The result from the Roboflow API or Inference package containing predictions with keypoints. Returns: A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, and class names, and confidences of each keypoint. Examples: ```python import cv2 import supervision as sv from inference import get_model image = cv2.imread("") model = get_model(model_id="", api_key="") result = model.infer(image)[0] key_points = sv.KeyPoints.from_inference(result) ``` ```python import cv2 import supervision as sv from inference_sdk import InferenceHTTPClient image = cv2.imread("") client = InferenceHTTPClient( api_url="https://detect.roboflow.com", api_key="" ) result = client.infer(image, model_id="") key_points = sv.KeyPoints.from_inference(result) ``` z}from_inference() operates on a single result at a time.You can retrieve it like so: inference_result = model.infer(image)[0]dictT) exclude_noneby_aliasjson predictions keypointsr$yrCr;classr,r9r=r;rB)r r1rEhasattrr[r^getemptyappendr rr*float32r') clsinference_resultr9rCr; class_names prediction prediction_xyprediction_confidencekeypointrBs rfrom_inferencezKeyPoints.from_inferencesV & -Y  #V ,/44$QU4V  %v ./446 ##M299;    *=9 4JM$& !&{3 E$$hsmXc]%CD%,,Xl-CD E IIm $   3 4 OOJz2 3   z'2 3 4 "288K#8@ xx"**- "2:: FXXhc2   rc~t|dr[|j}t|jts|jg}n}|jjDcgc]}|c}g}nWt|dr |j }n>t|dr2|j g}n#|j Dcgc]}|j}}tdk(r|jSg}g}|D]}g} g} |D]R}|j|dz|j|dzg} | j| | j|jT|j| |j| |tj|tjtj|tjScc}wcc}w)a Creates a `sv.KeyPoints` instance from a [MediaPipe](https://github.com/google-ai-edge/mediapipe) pose landmark detection inference result. Args: mediapipe_results: The output results from Mediapipe. It supports pose and face landmarks from `PoseLandmarker`, `FaceLandmarker` and the legacy ones from `Pose` and `FaceMesh`. resolution_wh: A tuple of the form `(width, height)` representing the resolution of the frame. Returns: A `sv.KeyPoints` object containing the keypoint coordinates and confidences of each keypoint. !!! tip Before you start, download model bundles from the [MediaPipe website](https://ai.google.dev/edge/mediapipe/solutions/vision/pose_landmarker/index#models). Examples: ```python import cv2 import mediapipe as mp import supervision as sv image = cv2.imread("") image_height, image_width, _ = image.shape mediapipe_image = mp.Image( image_format=mp.ImageFormat.SRGB, data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) options = mp.tasks.vision.PoseLandmarkerOptions( base_options=mp.tasks.BaseOptions( model_asset_path="pose_landmarker_heavy.task" ), running_mode=mp.tasks.vision.RunningMode.IMAGE, num_poses=2) PoseLandmarker = mp.tasks.vision.PoseLandmarker with PoseLandmarker.create_from_options(options) as landmarker: pose_landmarker_result = landmarker.detect(mediapipe_image) key_points = sv.KeyPoints.from_mediapipe( pose_landmarker_result, (image_width, image_height)) ``` ```python import cv2 import mediapipe as mp import supervision as sv image = cv2.imread("") image_height, image_width, _ = image.shape mediapipe_image = mp.Image( image_format=mp.ImageFormat.SRGB, data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) options = mp.tasks.vision.FaceLandmarkerOptions( base_options=mp.tasks.BaseOptions( model_asset_path="face_landmarker.task" ), output_face_blendshapes=True, output_facial_transformation_matrixes=True, num_faces=2) FaceLandmarker = mp.tasks.vision.FaceLandmarker with FaceLandmarker.create_from_options(options) as landmarker: face_landmarker_result = landmarker.detect(mediapipe_image) key_points = sv.KeyPoints.from_mediapipe( face_landmarker_result, (image_width, image_height)) ``` pose_landmarksface_landmarksmulti_face_landmarksrrrc)r9r=)rersr r1landmarkrtrurQrgr$rarh visibilityrr*ri) rjmediapipe_results resolution_whresultsrv face_landmarkr9rCposernro keypoint_xys rfrom_mediapipezKeyPoints.from_mediapipes^ $&6 7'66G/>>E$33; G ->,L,L,U,U (%G &(8 9'66G &(> ? 55=*;)O)O%"** w<1 99;    5DM$& !  BJJq!11JJq!11 $$[1%,,X-@-@A  B IIm $   3 4 5xx"**- "2:: F  Gs  F5*F:cT|jjjdk(r|jS|jjj j }|j jj j jt}tj|Dcgc]}|j|c}}|jjj j }t|i}|||||Scc}w)a Creates a `sv.KeyPoints` instance from a [YOLOv8](https://github.com/ultralytics/ultralytics) pose inference result. Args: ultralytics_results: The output Results instance from YOLOv8. Returns: A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, and class names, and confidences of each keypoint. Examples: ```python import cv2 import supervision as sv from ultralytics import YOLO image = cv2.imread("") model = YOLO('yolov8s-pose.pt') result = model(image)[0] key_points = sv.KeyPoints.from_ultralytics(result) ``` r)r9r;r=rB)r`r9numelrgcpunumpyboxesrjastyper'rr*namesconfr )rjultralytics_resultsr9r;r3rlrCrBs rfrom_ultralyticszKeyPoints.from_ultralyticsUs4  ( ( + + 1 1 3q 899;  * * - - 1 1 3 9 9 ;&,,00446<<>EEcJhhhO 3 9 9! <OP (2277;;=CCE !;@ b8RVWW PsD%ct|jjdk(r|jS|jjddddddf}|jjdddddf}t |jdr|jj }nd}i}|>|j 2g}|D]"}|j |}|j|$||t<|||||S)a Create a `sv.KeyPoints` instance from a [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS-POSE.md) pose inference results. Args: yolo_nas_results: The output object from YOLO NAS. Returns: A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, and class names, and confidences of each keypoint. Examples: ```python import cv2 import torch import supervision as sv import super_gradients image = cv2.imread("") device = "cuda" if torch.cuda.is_available() else "cpu" model = super_gradients.training.models.get( "yolo_nas_pose_s", pretrained_weights="coco_pose").to(device) results = model.predict(image, conf=0.1) key_points = sv.KeyPoints.from_yolo_nas(results) ``` rNlabelsrd) rQrmposesrgrerrlrhr ) rjyolo_nas_resultsr9rCr;rBrlc_idnames r from_yolo_naszKeyPoints.from_yolo_nas|s< **00 1Q 699;   ( ( . .q!RaRx 8%0066q!Qw?  #.. 9'2299HH?A  $4$@$@$LK  )'33D9""4( )+6D& ' *   rc.t|ddr|djjjjdk(r|j S||djjjddddddf|djjjdddddf|dj jjjtS|j S)a Create a `sv.KeyPoints` object from the [Detectron2](https://github.com/facebookresearch/detectron2) inference result. Args: detectron2_results: The output of a Detectron2 model containing instances with prediction data. Returns: A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, and class names, and confidences of each keypoint. Examples: ```python import cv2 import supervision as sv from detectron2.engine import DefaultPredictor from detectron2.config import get_cfg image = cv2.imread("") cfg = get_cfg() cfg.merge_from_file("") cfg.MODEL.WEIGHTS = "" predictor = DefaultPredictor(cfg) result = predictor(image) keypoints = sv.KeyPoints.from_detectron2(result) ``` instancespred_keypointsrNrr9r=r;) rerrrsizerg pred_classesrr')rjdetectron2_resultss rfrom_detectron2zKeyPoints.from_detectron2sB %k24D E!+.==AACIIKPPTUUyy{"%k2Arr#%7{$CAq%",K8cce  99; rc d|dvr5|ddjjjdk(r|jS|Dcgc]D}|djj|djjfF}}t |\}}|t j |jt jt j |jt jt jt|jtS|jScc}w)ap Create a `sv.KeyPoints` object from the [Transformers](https://github.com/huggingface/transformers) inference result. Args: transformers_results: The output of a Transformers model containing instances with prediction data. Returns: A `sv.KeyPoints` object containing the keypoint coordinates, class IDs, and class names, and confidences of each keypoint. Examples: ```python from PIL import Image import requests import supervision as sv import torch from transformers import ( AutoProcessor, RTDetrForObjectDetection, VitPoseForPoseEstimation, ) device = "cuda" if torch.cuda.is_available() else "cpu" image = Image.open("") DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365" detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True) detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=device) inputs = detection_processor(images=frame, return_tensors="pt").to(device) with torch.no_grad(): outputs = detection_model(**inputs) target_size = torch.tensor([(frame.height, frame.width)]) results = detection_processor.post_process_object_detection( outputs, target_sizes=target_size, threshold=0.3) detections = sv.Detections.from_transformers(results[0]) boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy) POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple" pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID) pose_estimation_model = VitPoseForPoseEstimation.from_pretrained( POSE_ESTIMATION_MODEL_ID, device_map=device) inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(device) with torch.no_grad(): outputs = pose_estimation_model(**inputs) results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes]) key_point = sv.KeyPoints.from_transformers(results[0]) ``` r`rscoresr) rrrrgziprstackrriarangerQr')rjtransformers_resultsresult result_datar9rs rfrom_transformerszKeyPoints.from_transformerss ~ .q1 1#A&{3779??AFF!Kyy{"3  ;'++-3358$((*002Kk*JB88B<&&rzz2$&HHV$4$;$;BJJ$G3r7+2237  99; !sA Ect|j}|jd|k7rtd|jdd|d|jd|jjdk7r6td|jdd|jjddt j |d}|dkDr7t j ||dk(std |j|dkDrt|dnd}t j|||jjd f|jj }d }|jVttjtjt j||f|jj }d }|j t j||ft" }t%|D]t}t j&||} |j|| f||<| |j|j|| f||<|T|j a|j || f||<vd } |j(|j(j+} d } |j,|j,j+} t/|j0t3d } t5||| || | S)uFilter keypoints using a 2D boolean mask of shape `(n, m)`. This method selects the **same set of keypoints from every object**, so every row of `mask` must contain the same number of `True` values. The result is a new `KeyPoints` whose keypoint count is that uniform `k`. This is suitable for use cases such as *"keep only the left-side joints for all persons"* — where the selected joint indices are identical across objects. It is **not** suitable for per-object confidence filtering (`kp[kp.confidence > 0.5]`) when the threshold yields a different number of passing keypoints per object, because NumPy cannot represent a ragged `(n, ?, 2)` array. For that pattern either process objects individually or zero out low-confidence entries in-place via `kp.confidence`. For the single-object case (`n == 1`) any boolean mask always satisfies the uniform-count requirement, so `kp[kp.confidence > 0.5]` works as expected. Args: mask: A boolean array of shape `(n, m)` where `n` is the number of objects and `m` is the number of keypoints per object. Every row must select the same number of keypoints so that the result can be stored in a uniform `(n, k, ...)` array. Returns: A new `KeyPoints` instance containing only the keypoints selected by the mask for each object. Raises: ValueError: If `mask.shape[0]` does not match the number of objects, if `mask.shape[1]` does not match the number of keypoints, or if different rows of the mask select different numbers of `True` values. rz2D boolean mask row count z does not match object count .rz2D boolean mask column count z does not match keypoint count axiszCannot filter keypoints with a 2D boolean mask where rows have different numbers of True values. All objects must select the same number of keypoints. Got counts per object: rrcNr9r=r>r@r;rB)rQr9shaperErsumr2tolistr'zerosr,r=r nptNDArrayrir@r!rTr-r>copyr;r rBslicer7) rGmaskncountsk xy_selectedkeypoint_confidence_selectedvisible_selectedrow row_indicesdetection_confidence_selectedclass_id_selected data_selecteds r_get_by_2d_bool_maskzKeyPoints._get_by_2d_bool_mask>sD L ::a=A ,TZZ]O< !s!%  ::a=DGGMM!, ,/ 1 ?""&''--"2!316 1% q5&) 34*+1--/):<   !eCq Nhh1dggmmA&67tww}}M GK$  # # /+/ BJJ'!Qt'?'?'E'EF, (:> << #!xxAd; 8 GC..c3K#wwsK'78K ,8,,8484L4L$5,S1 + 0H(, S+5E(F % G)-%  $ $ 0,0,E,E,J,J,L )  == $ $ 2 2 4 %diit=  $&   rc t|tr|jj|St|tj r\|j dk(rM|jtk(r:|jttjtj|St|ts |tdf}|\}}t|t r|g}t|t"r't%d|Drt j&|}t|t"r't%d|Drt j&|}t|tj r(|jtk(rt j(|}t|tj r(|jtk(rt j(|}|}t|t"tj frt|t"tj frt j*|sjt j*|sUt j,tt.|tt.|\}}tt.|}tt.|}t1|}|j2||f}d} |j4|j4||f} d} |j6|j6|} d} |j8|j8||f} |j:|j:|nd} t=|jtt.|} |j dk(r>|j?ddd}| | j?dd} | B| j?dd} n.|j dk(rt j*|ds/t|dtj rV|dj dk(rD|tj@df}| | tj@df} | | tj@df} nt j*|ds/t|dtj r^|dj dk(rL|ddtj@ddf}| | ddtj@f} | | ddtj@f} tC|| | | | | S) a  Get a subset of the KeyPoints object or access an item from its data field. Supports detection-level (skeleton) filtering, keypoint-level (anchor) filtering, combined tuple indexing, and data field access by string key. Args: index: The index, indices, or key to access a subset of the KeyPoints or an item from the data. Returns: A subset of the KeyPoints object or an item from the data field. Examples: ```python import supervision as sv key_points = sv.KeyPoints(...) # detection-level filtering (returns KeyPoints) high_conf = key_points[key_points.detection_confidence > 0.5] class_0 = key_points[key_points.class_id == 0] # keypoint-level filtering (returns KeyPoints) visible = key_points[key_points.keypoint_confidence > 0.3] # indexing first = key_points[0] first_two = key_points[0:2] subset = key_points[[0, 2]] # anchor selection (uniform across all skeletons) nose_and_eyes = key_points[:, [0, 1, 2]] # data field access class_names = key_points['class_name'] ``` rNc3<K|]}t|tywrrr"s rr%z(KeyPoints.__getitem__..&Fqz!T':&Fr&c3<K|]}t|tywrrr"s rr%z(KeyPoints.__getitem__..rr&rr.r)"r strrBrfrr+r/r,r!rr rrbool_tuplerr'r1r2r*r-isscalarix_rr4r9r=r>r@r;r r0newaxisr7)rGindexr3jraw_ii_ixj_ixrow_irrrrrrs r __getitem__zKeyPoints.__getitem__sT eS !99==' ' eRZZ (UZZ1_PTAT,,T#++bhh2G-OP P%'E$K(E1 a A a 3&FA&F#F A a 3&FA&F#F A a $Dq!A a $Dq!A q4, -1tRZZ01KKNKKNS! d3l;JD$S$AS$A$U+ggadm '+$  # # /+/+C+CAqD+I ((,%  $ $ 0,0,E,Ee,L ) << ##||AqD1 48MM4MDMM%0SW%diic51AB   q %--aA6K+7/K/S/Sq0, +#3#;#;Aq#A    "{{58$58RZZ0U1X]]a5G)"**c/: /;3O C40$/'7 C'H$U1X&58RZZ0U1X]]a5G)!RZZ*:; /;3O2:: 40$/'72:: 'F$ $&   rct|tjtfs t dt|trtj |}||j |<y)a Set a value in the data dictionary of the `sv.KeyPoints` object. Args: key: The key in the data dictionary to set. value: The value to set for the key. Examples: ```python import cv2 import supervision as sv from ultralytics import YOLO image = cv2.imread("") model = YOLO('yolov8s.pt') result = model(image)[0] key_points = sv.KeyPoints.from_ultralytics(result) key_points['class_name'] = [ model.model.names[class_id] for class_id in key_points.class_id ] ``` z$Value must be a np.ndarray or a listN)r rr+r1 TypeErrorr*rB)rGkeyrOs r __setitem__zKeyPoints.__setitem__&sG6%"**d!34BC C eT "HHUOE #rcZ|tjdtjS)aF Create an empty KeyPoints object with no key points. Returns: An empty `sv.KeyPoints` object. Examples: ```pycon >>> import supervision as sv >>> key_points = sv.KeyPoints.empty() >>> len(key_points) 0 ``` )rrrrc)r9)rrgri)rjs rrgzKeyPoints.emptyIs"bhhy ;<>> import supervision as sv >>> key_points = sv.KeyPoints.empty() >>> key_points.is_empty() True ``` )r7rgrB)rGempty_key_pointss ris_emptyzKeyPoints.is_empty\s* %??, $ '''rg?Fct|dk(r|S|j td|s|j td|j}t j |dk(d}|j||jz}t jt j||dt jd}t jt j||dt jd}t jt j||dt j d}t jt j||dt j d} t j|||| gdjt j} |r2t j| |jj!ddg} nwt#t$j&t j(|j} t j| |jj!dd| j!ddg} t+| || } t#t,|| S) a Performs non-max suppression on the keypoint detections. Bounding boxes are derived from valid keypoints of each skeleton, and standard box NMS is applied. A keypoint is considered valid when its coordinates are not all-zero and its `visible` flag is `True` (if `visible` is set). Args: threshold: The intersection-over-union threshold to use for non-maximum suppression. Must be in [0, 1]. Defaults to 0.5. class_agnostic: Whether to perform class-agnostic non-maximum suppression. If True, the class_id of each detection will be ignored. Defaults to False. overlap_metric: Metric used to compute the degree of overlap between pairs of bounding boxes. Defaults to `OverlapMetric.IOU`. Returns: A new `sv.KeyPoints` object after non-maximum suppression. Raises: ValueError: If `detection_confidence` is None. ValueError: If `class_agnostic` is False and `class_id` is None. Examples: ```python import cv2 import supervision as sv from rfdetr import RFDETRKeypointPreview image = cv2.imread("") model = RFDETRKeypointPreview() key_points = model.predict(image) key_points = key_points.with_nms(threshold=0.5) ``` rzDKeyPoints detection_confidence must be given for NMS to be executed.zKeyPoints class_id must be given for NMS to be executed. If you intended to perform class agnostic NMS set class_agnostic=True.r).rr).r)r_ iou_thresholdoverlap_metric)rQr>rEr;r9rr2r@minwhereinfmaxrrrihstackr0r rrint_rr7)rG thresholdclass_agnosticrr9validx_miny_minx_maxy_maxxyxyr_r;keeps rwith_nmszKeyPoints.with_nmspsV t9>K  $ $ ,V $--"7'  WWab)) << #DLL(Erxxr&z266:Crxxr&z266:Crxxr&zBFF7;!Drxxr&zBFF7;!Dxxue41=DDRZZP ))T4+D+D+L+LRQR+S$TUKCKK0$--@H))--55b!<$$R+K'##)  ItDz**rc`|jrtjS|j}|r:t j t |tj}|dd|ddf}t j|dk(d}|jd}|dddddf|dddddf}}t j||tjjd}t j||tjjd} t j||tj jd} t j||tj jd} t j|| | | fdjtj } d| |<|j"*|j"jtj } nU|j$G|j$}|r |ddf}|j'djtj } nd} t| | }|j(|_|j*|_t-t|t-t.|j0dkD}|S) a; Convert a KeyPoints object to a Detections object. This approximates the bounding box of the detected object by taking the bounding box that fits all key points. Args: selected_keypoint_indices: The indices of the key points to include in the bounding box calculation. This helps focus on a subset of key points, e.g. when some are occluded. Captures all key points by default. An empty sequence (`[]`) is treated the same as `None` and selects all key points. Returns: detections: The converted detections object. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> key_points = sv.KeyPoints( ... xy=np.array([[[10, 20], [30, 40]]], dtype=np.float32) ... ) >>> detections = key_points.as_detections() >>> detections.xyxy array([[10., 20., 30., 40.]], dtype=float32) ``` rcNrrrrg)rrC)rr rgr9rasarrayr1intpr2anyrrrrrrrir>r=meanr;rBr rarea)rGselected_keypoint_indicesr9indicesr has_validr$rarrrrrrCr= detectionss r as_detectionszKeyPoints.as_detectionss"@ ==?##% % WW $jj&?!@PGAwM"Baa((II1I% !Q'{Bq!QwK1266*..A.6266*..A.6BFF7+//Q/7BFF7+//Q/7xxue41=DDRZZPiZ  $ $ 02299"**EJ  % % 1"&":": (&9!W*&E#,11q19@@LJJTjA "mm )) *jc:??1Ka1O&PQ r)NNNNN)r9r8r;r:r=r<r>r<r@r?rBz5dict[str, npt.NDArray[np.generic] | list[Any]] | NonerCr<returnNone)rr)rr<)rOr<rr)rr')rzIterator[tuple[npt.NDArray[np.float32], npt.NDArray[np.float32] | None, npt.NDArray[np.int_] | None, dict[str, npt.NDArray[np.generic] | list[Any]]]])rXobjectrr!)rkrrr7)rxrryztuple[int, int]rr7)rrrr7)rrrr7)rrrr7)rrrr7)rznpt.NDArray[np.bool_]rr7)rzIndex1D | Index2D | strrz6KeyPoints | npt.NDArray[np.generic] | list[Any] | None)rrrOz#npt.NDArray[np.generic] | list[Any]rr)rr7)rr!)rfloatrr!rrrr7r)rzIterable[int] | Nonerr )$__name__ __module__ __qualname____doc____annotations__r;r=r>r@rr[rBrHrFpropertyrCsetterrRrUrY classmethodrqr~rrrrrrrrgrrIOUrrrrr7r7JsP`D ,0H)0:>7>;?8?,0G )0;@QU;VD 8V 15>B?C04FJ36:3 #3.3< 3 = 3 . 3D333 3j (())( 0 $Q Q f{ #{ 4C{ { { z$X$XL7 7 r00dRRh] ~G &G  @G R!F==$(,$(5(9(9 V+V+V+& V+  V+rAEF)=F Frr7)rnpt.NDArray[np.generic] | Nonerrrr!)r3_RowIndexInputrr))3 __future__rloggingcollections.abcrr dataclassesrrtypingrr r rr numpy.typingrsupervision.configr supervision.detection.corer $supervision.detection.utils.internalr r'supervision.detection.utils.iou_and_nmsrrsupervision.utils.internalrsupervision.validatorsr getLoggerrloggerr'rr1r!rrrIndex1DrIndex2Dr(genericrr)rr4r7rrrrsJ".(##41M7=   8 $  IJKKKK    !JJsOKK I  CKK 3T#YEF) )) *) )   . CCCr