o e@ @sddlmZmZmZddlZddlZdZdejdee e fdejfddZ d ejd ejdejfd d Z d7dejde dejfddZ dejdee e fdejfddZdejdejfddZdejdejfddZdejdeejfddZ  d8deejdee d ee deejfd!d"Zdejdejfd#d$Z %d9dejd&e d'e dejfd(d)Zdeejfd*d+Zd,edeejejejeejejffd-d.Zdejd/ejdejfd0d1Zdejd2e dejfd3d4Zdejdejfd5d6ZdS):)ListOptionalTupleNpolygon resolution_whreturncCs,|\}}t||f}tj||gdd|S)aGenerate a mask from a polygon. Args: polygon (np.ndarray): The polygon for which the mask should be generated, given as a list of vertices. resolution_wh (Tuple[int, int]): The width and height of the desired resolution. Returns: np.ndarray: The generated 2D mask, where the polygon is marked with `1`'s and the rest is filled with `0`'s. )color)npzeroscv2fillPoly)rrwidthheightmaskrJ/var/www/myenv/lib/python3.10/site-packages/supervision/detection/utils.pypolygon_to_mask s r boxes_trueboxes_detectioncCsdd}||j}||j}t|dddddf|ddddf}t|dddddf|ddddf}ttj||dddd}||dddf||S)a Compute Intersection over Union (IoU) of two sets of bounding boxes - `boxes_true` and `boxes_detection`. Both sets of boxes are expected to be in `(x_min, y_min, x_max, y_max)` format. Args: boxes_true (np.ndarray): 2D `np.ndarray` representing ground-truth boxes. `shape = (N, 4)` where `N` is number of true objects. boxes_detection (np.ndarray): 2D `np.ndarray` representing detection boxes. `shape = (M, 4)` where `M` is number of detected objects. Returns: np.ndarray: Pairwise IoU of boxes from `boxes_true` and `boxes_detection`. `shape = (N, M)` where `N` is number of true objects and `M` is number of detected objects. cSs |d|d|d|dS)Nrrr r)boxrrrbox_area.s zbox_iou_batch..box_areaNrr)a_mina_max)Tr maximumminimumprodclip)rrr area_truearea_detectiontop_left bottom_right area_interrrr box_iou_batchs  ..r&? predictions iou_thresholdc Csd|kr dksnJd|d|j\}}|dkr&tj|t|f}t|dddf}||}|ddddf}|dddf}t||}|t|}tj|t d}t t ||D]\} \} } || snqc| |k|| k@} || @}qc||S) a Perform Non-Maximum Suppression (NMS) on object detection predictions. Args: predictions (np.ndarray): An array of object detection predictions in the format of `(x_min, y_min, x_max, y_max, score)` or `(x_min, y_min, x_max, y_max, score, class)`. iou_threshold (float, optional): The intersection-over-union threshold to use for non-maximum suppression. Returns: np.ndarray: A boolean array indicating which predictions to keep after n on-maximum suppression. Raises: AssertionError: If `iou_threshold` is not within the closed range from `0` to `1`. rr zBValue of `iou_threshold` must be in the closed range from 0 to 1, z given.Ndtype) shaper c_r flipargsortr&eyeonesbool enumeratezip) r(r)rowscolumns sort_indexboxes categoriesiouskeepindexioucategory conditionrrrnon_max_suppression;s*    rBxyxycCsnt|}|\}}|ddddgfd||ddddgf<|ddddgfd||ddddgf<|S)aL Clips bounding boxes coordinates to fit within the frame resolution. Args: xyxy (np.ndarray): A numpy array of shape `(N, 4)` where each row corresponds to a bounding box in the format `(x_min, y_min, x_max, y_max)`. resolution_wh (Tuple[int, int]): A tuple of the form `(width, height)` representing the resolution of the frame. Returns: np.ndarray: A numpy array of shape `(N, 4)` where each row corresponds to a bounding box with coordinates clipped to fit within the frame resolution. Nrrr r)r copyr )rCrresultrrrrr clip_boxesqs ,,rF boxes_xywhcCsd|}|dddf|dddf|dddf<|dddf|dddf|dddf<|S)Nrrr r)rD)rGrCrrr xywh_to_xyxys,,rHmasksc Cs|jd}tj|dftd}t|D]9\}}t|\}}t|dkrKt|dkrKt|t|}}t|t|} } || || g||ddf<q|S)am Converts a 3D `np.array` of 2D bool masks into a 2D `np.array` of bounding boxes. Parameters: masks (np.ndarray): A 3D `np.array` of shape `(N, W, H)` containing 2D bool masks Returns: np.ndarray: A 2D `np.array` of shape `(N, 4)` containing the bounding boxes `(x_min, y_min, x_max, y_max)` for each mask rr+r,N) r.r r intr5wherelenminmax) rInbboxesirr7colsx_minx_maxy_miny_maxrrr mask_to_xyxys rWrcCs,t|tjtjtj\}}dd|DS)a3 Converts a binary mask to a list of polygons. Parameters: mask (np.ndarray): A binary mask represented as a 2D NumPy array of shape `(H, W)`, where H and W are the height and width of the mask, respectively. Returns: List[np.ndarray]: A list of polygons, where each polygon is represented by a NumPy array of shape `(N, 2)`, containing the `x`, `y` coordinates of the points. Polygons with fewer points than `MIN_POLYGON_POINT_COUNT = 3` are excluded from the output. cSs(g|]}|jdtkrtj|ddqS)rr axis)r.MIN_POLYGON_POINT_COUNTr squeeze).0contourrrr s  z$mask_to_polygons..)r findContoursastyper uint8 RETR_TREECHAIN_APPROX_SIMPLE)rcontours_rrrmask_to_polygonss rfpolygonsmin_areamax_areacs<dur dur |Sdd|D}fddt||DS)a Filters a list of polygons based on their area. Parameters: polygons (List[np.ndarray]): A list of polygons, where each polygon is represented by a NumPy array of shape `(N, 2)`, containing the `x`, `y` coordinates of the points. min_area (Optional[float]): The minimum area threshold. Only polygons with an area greater than or equal to this value will be included in the output. If set to None, no minimum area constraint will be applied. max_area (Optional[float]): The maximum area threshold. Only polygons with an area less than or equal to this value will be included in the output. If set to None, no maximum area constraint will be applied. Returns: List[np.ndarray]: A new list of polygons containing only those with areas within the specified thresholds. NcSsg|]}t|qSr)r contourArea)r\rrrrr^sz+filter_polygons_by_area..cs4g|]\}}dus|krdus|kr|qS)Nr)r\rarearirhrrr^s )r6)rgrhriaresrrlrfilter_polygons_by_areas  rncCs6tj|dd\}}tj|dd\}}t||||gS)a Converts a polygon represented by a NumPy array into a bounding box. Parameters: polygon (np.ndarray): A polygon represented by a NumPy array of shape `(N, 2)`, containing the `x`, `y` coordinates of the points. Returns: np.ndarray: A 1D NumPy array containing the bounding box `(x_min, y_min, x_max, y_max)` of the input polygon. rrX)r rMrNarray)rrSrUrTrVrrrpolygon_to_xyxys rp皙? percentage epsilon_stepcCs|dks|dkr tdttt|d|d}t||kr!|Sd}|} ||7}tj||dd}t||kr;|}nnq&tj|ddS)a Approximates a given polygon by reducing a certain percentage of points. This function uses the Ramer-Douglas-Peucker algorithm to simplify the input polygon by reducing the number of points while preserving the general shape. Parameters: polygon (np.ndarray): A 2D NumPy array of shape `(N, 2)` containing the `x`, `y` coordinates of the input polygon's points. percentage (float): The percentage of points to be removed from the input polygon, in the range `[0, 1)`. epsilon_step (float): Approximation accuracy step. Epsilon is the maximum distance between the original curve and its approximation. Returns: np.ndarray: A new 2D NumPy array of shape `(M, 2)`, where `M <= N * (1 - percentage)`, containing the `x`, `y` coordinates of the approximated polygon's points. rr z'Percentage must be in the range [0, 1).rT)closedrX) ValueErrorrNrJrLr approxPolyDPr r[)rrrrs target_pointsepsilonapproximated_pointsnew_approximated_pointsrrrapproximate_polygons  r{c CsJ|jsdS|j}t|jjjdd}d}d}||krDt|d|d|d|d}|d|d|d|d|d|df}t|dt|d}}t|d|dt|d|d}}g} |jj} t | jdD]&} | | } | ||||f} | j|krt | |d|df} | | qwt j| tdS)Nr r)rrrr,)rI orig_shapetupledatar.rMrJcpunumpyranger resizeappendr asarrayr4) yolov8_resultsr|inference_shapegainpadtopleftbottomright mask_mapsrIrQrrrrextract_ultralytics_masks's2*  rroboflow_resultcCs@|dstdtdtdddfSg}g}g}g}g}t|dd}t|dd}|dD]}|d} |d} |d} |d} | | d } | | d }| | }|| }d |vr|| |||g||d ||d d |vr~||d q2t|d dkrtjdd|d Dtd}t|||fd}|| |||g||d ||d ||d |vr||d q2t|dkrt|ntd}t|dkrt|ntd}t|dkrt|tntd}t|dkrtj|tdnd}t|dkrt|tnd}|||||fS)Nr()rr+rimagerrxyrpointsclass_id confidence tracker_idrcSsg|] }|d|dgqS)rrr)r\pointrrrr^msz+process_roboflow_result..r,)r) r emptyrJrrLrorr`r4)rrCrrrI tracker_ids image_width image_height predictionrrrrrSrUrTrVrrrrrrprocess_roboflow_resultLsV       & "roffsetcCs|t||gS)a Parameters: xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]` offset (np.array): An array of shape `(2,)` containing offset values in format is `[dx, dy]`. Returns: np.ndarray: Repositioned bounding boxes. Example: ```python >>> import numpy as np >>> import supervision as sv >>> boxes = np.array([[10, 10, 20, 20], [30, 30, 40, 40]]) >>> offset = np.array([5, 5]) >>> sv.move_boxes(boxes, offset) ... array([ ... [15, 15, 25, 25], ... [35, 35, 45, 45] ... ]) ``` )r hstack)rCrrrr move_boxessrfactorcCsz|ddddf|ddddfd}|ddddf|ddddf|}tj||d||dfddS)aD Scale the dimensions of bounding boxes. Parameters: xyxy (np.ndarray): An array of shape `(n, 4)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]` factor (float): A float value representing the factor by which the box dimensions are scaled. A factor greater than 1 enlarges the boxes, while a factor less than 1 shrinks them. Returns: np.ndarray: Scaled bounding boxes. Example: ```python >>> import numpy as np >>> import supervision as sv >>> boxes = np.array([[10, 10, 20, 20], [30, 30, 40, 40]]) >>> factor = 1.5 >>> sv.scale_boxes(boxes, factor) ... array([ ... [ 7.5, 7.5, 22.5, 22.5], ... [27.5, 27.5, 42.5, 42.5] ... ]) ``` Nrr rX)r concatenate)rCrcenters new_sizesrrr scale_boxess,,"rc sj\}}}jdd}t||fd\}}d||dk<dtjdtdtjffd d }dd gddgf}||||} ||||} t| | ftS) a Calculate the centroids of binary masks in a tensor. Parameters: masks (np.ndarray): A 3D NumPy array of shape (num_masks, height, width). Each 2D array in the tensor represents a binary mask. Returns: A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y coordinates (in that order) of the centroid of the corresponding mask. )r rrXr'r rindicesrYrcstj||dS)N)axes)r tensordot)rrYrIrr sum_over_masksz0calculate_masks_centroids..sum_over_maskr) r.sumr rndarrayr} column_stackr`rJ) rI num_masksrr total_pixelsvertical_indiceshorizontal_indicesraggregation_axis centroid_x centroid_yrrrcalculate_masks_centroidss  r)r')NN)rq)typingrrrr rr rZrrJrr&floatrBrFrHrWrfrnrpr{rdictrrrrrrrrsb"  "6 $ /% 4!