^j&ddlmZddlZddlmZddlmZddlmZm Z ddl Z ddl Z ddl mZddlmZddlmZGdd eZGd d eZej*f d'd Zej*f d(d Zd)dZ d*dZd+dZd+dZ d,dZej*f d-dZej*f d.dZej*f d/dZej*df d0dZ dej*df d1dZ! d2dZ" d3dZ#dej*f d4dZ$dej*f d5dZ%ddej*f d6dZ& d7d Z' d8d!Z(dej*f d9d"Z)dej*f d9d#Z*dej*f d:d$Z+dej*f d;d%Z,dej*f d;d&Z-y)<) annotationsN)Callable)Enum)Anycast) CompactMask) resize_masksc@eZdZdZdZdZdZeddZed dZ y) OverlapFiltera; Enum specifying the strategy for filtering overlapping detections. Attributes: NONE: Do not filter detections based on overlap. NON_MAX_SUPPRESSION: Filter detections using non-max suppression. This means, detections that overlap by more than a set threshold will be discarded, except for the one with the highest confidence. NON_MAX_MERGE: Merge detections with non-max merging. This means, detections that overlap by more than a set threshold will be merged into a single detection. nonenon_max_suppression non_max_mergec.ttd|S)Nc|jSNvaluemembers r/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/detection/utils/iou_and_nms.pyz$OverlapFilter.list..$ v||listmapclss rrzOverlapFilter.list"C3S9::rct||r|St|tr|j} ||Stdt |d|j d#t$r td|d|j wxYwNzInvalid value: z. Must be one of zInvalid value type: z. Must be an instance of z or str.) isinstancestrlower ValueErrorrtype__name__rrs r from_valuezOverlapFilter.from_value& eS !L eS !KKME Y5z!"4;-/H||nH &   Y ?5'9J388:,!WXX Y A)BNreturnz list[str])rzOverlapFilter | strr-r ) r' __module__ __qualname____doc__NONENON_MAX_SUPPRESSION NON_MAX_MERGE classmethodrr)rrr r s?  D/#M;;    rr c<eZdZdZdZdZeddZeddZy) OverlapMetrica Enum specifying the metric for measuring overlap between detections. Attributes: IOU: Intersection over Union. A region-overlap metric that compares two shapes (usually bounding boxes or masks) by normalising the shared area with the area of their union. IOS: Intersection over Smaller, a region-overlap metric that compares two shapes (usually bounding boxes or masks) by normalising the shared area with the smaller of the two shapes. IOUIOSc.ttd|S)Nc|jSrrrs rrz$OverlapMetric.list..Hrrrrs rrzOverlapMetric.listFrrct||r|St|tr|j} ||Stdt |d|j d#t$r td|d|j wxYwr!)r"r#upperr%rr&r'r(s rr)zOverlapMetric.from_valueJr*r+Nr,)rOverlapMetric | strr-r7) r'r.r/r0r8r9r4rr)r5rrr7r76s9  C C;;    rr7c$tj|}tj|\}}}}tj|\}}} } t ||} t ||} t || } t || }t d| | z }t d|| z }||z}||z ||z z}| |z | |z z}|tj k(r ||z|z }n/|tjk(r t ||}ntd|d|dkryt||z S)a. Compute overlap metric between two bounding boxes. Supports standard IOU (intersection-over-union) and IOS (intersection-over-smaller-area) metrics. Returns the overlap value in range `[0, 1]`. Args: box_true: Ground truth box in format `(x_min, y_min, x_max, y_max)`. box_detection: Detected box in format `(x_min, y_min, x_max, y_max)`. overlap_metric: Overlap type. Use `OverlapMetric.IOU` for IOU or `OverlapMetric.IOS` for IOS. Defaults to `OverlapMetric.IOU`. Returns: Overlap value between boxes in `[0, 1]`. Raises: ValueError: If `overlap_metric` is not IOU or IOS. Examples: ```pycon >>> import supervision as sv >>> box_true = [100, 100, 200, 200] >>> box_detection = [150, 150, 250, 250] >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOU) 0.142857... >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOS) 0.25 ``` overlap_metric 5 is not supported, only 'IOU' and 'IOS' are supported) r7r)nparraymaxminr8r9r%float)box_true box_detectionoverlap_metric x_min_true y_min_true x_max_true y_max_true x_min_det y_min_det x_max_det y_max_det x_min_inter y_min_inter x_max_inter y_max_interinter_winter_h area_inter area_truearea_det area_norms rbox_iour]Zs:N#--n=N57XXh5G2J J 13-1H.Iy)Yj),Kj),Kj),Kj),K#{[01G#{[01G7"Jj(Z*-DEII%)i*?@H***(:5 =,, , 8, n-.1 1  C i' ((rctj|}|j\}}}}|j\}}} } |jd|jd} } | dk(s| dk(rPt t j tjtj| | ftjStj| | ftj} tj| }tj| }tj| }tj|dddf|dddf| tj|dddf| dddf|tj|dddf|dddf|tj|dddf| dddf|tj|| |tj|||tj|dd|tj|dd|||z}||z ||z z}| |z | |z z}|tjk(r|dddf|dddfz|z }nG|tj k(r%tj|dddf|dddf}nt#d|dtj$|tj}tj&||||dkD|S) a/ Compute pairwise overlap scores between batches of bounding boxes. Supports standard IOU (intersection-over-union) and IOS (intersection-over-smaller-area) metrics for all `boxes_true` and `boxes_detection` pairs. Returns a matrix of overlap values in range `[0, 1]`, matching each box from the first batch to each from the second. Args: boxes_true: Array of reference boxes in shape `(N, 4)` as `(x_min, y_min, x_max, y_max)`. boxes_detection: Array of detected boxes in shape `(M, 4)` as `(x_min, y_min, x_max, y_max)`. overlap_metric: Overlap type. Use `OverlapMetric.IOU` for intersection-over-union, `OverlapMetric.IOS` for intersection-over-smaller-area. Defaults to `OverlapMetric.IOU`. Returns: Overlap matrix of shape `(N, M)`, where entry `[i, j]` is the overlap between `boxes_true[i]` and `boxes_detection[j]`. Raises: ValueError: If `overlap_metric` is not IOU or IOS. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> boxes_true = np.array([ ... [100, 100, 200, 200], ... [300, 300, 400, 400] ... ]) >>> boxes_detection = np.array([ ... [150, 150, 250, 250], ... [320, 320, 420, 420] ... ]) >>> sv.box_iou_batch( ... boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOU ... ) array([[0.14285..., 0. ], [0. , 0.47058...]], dtype=float32) >>> sv.box_iou_batch( ... boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOS ... ) array([[0.25, 0. ], [0. , 0.64]], dtype=float32) ``` rdtypeN)outr@rArBrawhere)r7r)TshapernptNDArrayrCfloat32empty empty_likemaximumminimumsubtractclipr8r9r% zeros_likedivide) boxes_trueboxes_detectionrJrKrLrMrNrOrPrQrR count_true count_detrSrUrTrVrYrZr[r\ras r box_iou_batchrusp#--n=N5?\\2J J 1@1B1B.Iy)Y&,,Q/1F1Fq1I JQ)q. KK #RXXz9.ERZZ%X  ((J 2"**EK-- ,K-- ,K-- ,KJJz!T'"IdAg$6KHJJz!T'"IdAg$6KHJJz!T'"IdAg$6KHJJz!T'"IdAg$6KHKK [k:KK [k:GGKd 4GGKd 4{*Jj(Z*-DEII%)i*?@H***ag&$')::ZG =,, ,JJyD18D!G3DE n-.1 1  $&==2::#NCIIj)IMB Jrc&tjd}|d|d|d|dz|d|dzf\}}}}|d|d|d|dz|d|dzf\}} } } t||} t|| } t|| }t|| }t||z dt||z dz}t| |z dt| | z dz}t| | z dt||z dz}|rt |||zz St |||z|z |zz S)ax Calculate the Jaccard index (intersection over union) between two bounding boxes. If a gt object is marked as "iscrowd", a dt is allowed to match any subregion of the gt. Choosing gt'=intersect(dt,gt). Since by definition union(gt',dt)=dt, computing iou(gt,dt,iscrowd) = iou(gt',dt) = area(intersect(gt,dt)) / area(dt) Args: box_a: Box coordinates in the format [x, y, width, height]. box_b: Box coordinates in the format [x, y, width, height]. iscrowd: Flag indicating if the second box is a crowd region or not. Returns: Jaccard index between the two bounding boxes. rr@)rCspacingrErFrG)box_abox_bis_crowdEPSxayax2ay2axbybx2by2bxix2iyiy2iAaAbAis r_jaccardrsH **Q-CQxq58eAh+>a5QR8@SSBCQxq58eAh+>a5QR8@SSBC RB c3-C RB c3-C S2Xs c#(C0 0B S2Xs c#(C0 0B S2Xs c#(C0 0BR28_%% rBw|c)* ++rct|t|k(sJdt|dk(st|dk(r>ttjtj t j gSt jt|t|ftj }t|D]-\}}t|D]\}}t|||||||f</|S)a Calculate the intersection over union (IoU) between detection bounding boxes (dt) and ground-truth bounding boxes (gt). Reference: https://github.com/rafaelpadilla/review_object_detection_metrics Args: boxes_true: List of ground-truth bounding boxes in the format [x, y, width, height]. boxes_detection: List of detection bounding boxes in the format [x, y, width, height]. is_crowd: List indicating if each ground-truth bounding box is a crowd region or not. Returns: Array of IoU values of shape (len(dt), len(gt)). Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> boxes_true = [ ... [10, 20, 30, 40], # x, y, w, h ... [15, 25, 35, 45] ... ] >>> boxes_detection = [ ... [12, 22, 28, 38], ... [16, 26, 36, 46] ... ] >>> is_crowd = [False, False] >>> ious = sv.box_iou_batch_with_jaccard( ... boxes_true=boxes_true, ... boxes_detection=boxes_detection, ... is_crowd=is_crowd ... ) >>> ious # doctest: +ELLIPSIS array([[0.886..., 0.496...], [0.4 ..., 0.862...]]) ``` z4`is_crowd` must have the same length as `boxes_true`rr_) lenrrfrgrCfloat64rDzeros enumerater)rqrrr}iousgt_idxgt_boxdet_idxdet_boxs rbox_iou_batch_with_jaccardr0sZ x=C O +> + ?q C Oq$8CKK +RXXb\::$&HH _ s:/rzz%D$J/P )/ : P GW$,Wfhv>N$OD& ! PP Krc B|dddddf}|dddddf}|tj|ddztj|dd|zz }ttjtj dtj |jdzS)zCompute the area of each oriented-box polygon using the shoelace formula. Args: polygons: ``(N, 4, 2)`` array of polygon corners. Returns: ``(N,)`` array of polygon areas. Nrrwaxis?)rCrollrrfrgfloatingabssum)polygonsxycrosss r_polygon_areasrks AqAAqA 2A& &BQ)?!)C CE  BKK(#uyyay7H0I*I JJrc|dddddf}|dddddf}tj|jd|jd|jd|jdgdS)zCompute the axis-aligned bounding envelope of each oriented box. Args: polygons: ``(N, 4, 2)`` array of polygon corners. Returns: ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)`` envelopes. Nrrwr)rCstackrFrE)rxsyss r_aabb_envelopesrzsk !Q' B !Q' B 88 QQQQHq rc|dddddf}|dddddf}tj|d|dtj|d|dkDtj|d|dtj|d|dkDz}ttt j tjt j tjftj|S)a*Return index pairs ``(i, j)`` whose axis-aligned envelopes overlap. Uses a fused boolean evaluation to halve peak transient memory compared to named-intermediate form (4 separate NxM float64 arrays vs 1 boolean array). Note: This gate is a correctness guarantee, not an approximation: if two axis-aligned bounding boxes do not overlap, the convex polygons they contain cannot overlap either. Args: envelopes_true: ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)`` envelopes for the ground-truth boxes. envelopes_detection: ``(M, 4)`` array of ``(x_min, y_min, x_max, y_max)`` envelopes for the detection boxes. Returns: A pair of 1-D index arrays ``(rows, cols)`` identifying the overlapping pairs. N).rx).r).ry).rw) rCrlrkrtuplerfrgintpnonzero)envelopes_trueenvelopes_detectionetedoverlaps r_overlapping_envelope_pairsrs0 4 #B T1aZ (B 2f:r&z*RZZ6 BvJ-OO BvJ6 +bjjFRZ.P PRG ckk"''*CKK,@@A2::gCV WWrcVd|fd|ffD]\}}|jdk(r.|jdddk7rtd|d|jd |jd k(r.|jdd k7rtd|d|jd |jd vstd|d|jd|tjk(rd}n%|tj k(rd}ntd|d||u}|j ddd jtj}|j ddd jtj}t|t|}}|dk(s|dk(r'tj||ftjSt|} t|} t|} |r| n t|} t| | \} }|r| |k}| |||}} |Dcgc]!}|jtj#}}|Dcgc]!}|jtj#}}tj||ftj}t!| |D]h\}}t#j$||||\}}|dkr+|r| || |z|z nt'| || |}|dkDsS||z }||||f<|sb||||f<jt)t*j,tj.tj0|ddScc}wcc}w)u Compute pairwise overlap scores between two sets of oriented bounding boxes using the configured `overlap_metric`. Overlap areas are computed exactly via convex-polygon intersection, gated by a cheap axis-aligned envelope pre-filter — no rasterization is involved, so the result is exact (free of pixel-quantization error) and independent of the coordinate magnitudes. `boxes_true` and `boxes_detection` are expected to be in `((x1, y1), (x2, y2), (x3, y3), (x4, y4))` format. Note: Inputs must be **convex** quads with finite coordinates. Self-intersecting or non-convex polygons produce undefined results via ``cv2.intersectConvexConvex``. NaN or Inf coordinates propagate silently as ``0.0`` — validate inputs before calling if needed. When ``boxes_true is boxes_detection`` (the same Python object, not just equal values), the function computes only the upper triangle of the matrix and mirrors it. This optimization is used automatically by the NMS/NMM callers that pass the same array twice. A defensive ``.copy()`` at the call site would disable the optimization silently — see the NMS caller comment for context. Args: boxes_true: A `np.ndarray` representing ground-truth boxes. `shape = (N, 4, 2)` where `N` is number of true objects. Last axis convention: `[..., 0]` = x-coordinates, `[..., 1]` = y-coordinates. boxes_detection: A `np.ndarray` representing detection boxes. `shape = (M, 4, 2)` where `M` is number of detected objects. Last axis convention: `[..., 0]` = x-coordinates, `[..., 1]` = y-coordinates. overlap_metric: Metric used to compute the degree of overlap between pairs of oriented boxes (e.g., IoU, IoS). Returns: Overlap matrix of shape `(N, M)`, where entry `[i, j]` is the overlap score between `boxes_true[i]` and `boxes_detection[j]`, in the range `[0, 1]` under the configured :attr:`overlap_metric`. Raises: ValueError: If ``boxes_true`` or ``boxes_detection`` is 3-D with inner dimensions other than ``(4, 2)``. ValueError: If ``boxes_true`` or ``boxes_detection`` is 2-D with a column count other than 8. ValueError: If ``boxes_true`` or ``boxes_detection`` is not 2-D or 3-D. ValueError: If ``overlap_metric`` is not :attr:`~supervision.config.OverlapMetric.IOU` or :attr:`~supervision.config.OverlapMetric.IOS`. Examples: >>> import numpy as np >>> import supervision as sv >>> a = np.array([[[0, 0], [2, 0], [2, 2], [0, 2]]], dtype=np.float32) >>> b = np.array([[[1, 0], [3, 0], [3, 2], [1, 2]]], dtype=np.float32) >>> sv.oriented_box_iou_batch(a, b) # doctest: +ELLIPSIS array([[0.333...]]) rqrrryrwNrx` ` has shape V; expected (N, 4, 2) — each box must have exactly 4 corners with (x, y) coordinates.rxF; expected (N, 8) for flat YOLO format or (N, 4, 2) for corner format.rxry1` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape .TFrArBrrrr_r@g?)ndimrer%r7r8r9reshapeastyperCrrrrrrrhzipcv2intersectConvexConvexrFrrfrgrrn)rqrrrJnamearrnormalize_by_unionis_self_comparisonnm areas_trueareas_detectionrrrowscolsr=box polygons_truepolygons_detectionrij intersection_ denominatorscores roriented_box_iou_batchrsRD$Z03Do2VW c 88q=SYYqr]f4D6cii[1TU XX]syy|q0D6cii[1>? XXV #D6J399+UVW  ***! =,, ,"n-.1 1  $6##B1-44RZZ@J%--b!Q7>>rzzJO z?C0qAAvaxxAbjj11 +J$_5O$Z0N,//2R-^=PQJD$ %[$u+d7ABSZZ +BMBttj|jdd}|dkrtjntj }|j |jd|j|d}|j |jd|j|d}tjddd5||jz}ddd|jd }|jd } |tjk(rE|dddf| zz } tj|| tj|t | dk7 } nu|tj k(rStj"|dddf| } tj| tj|t | dk7 } nt%d |d tj&| } t)t*j,tj.| S#1swY;xYw)a Internal function. Compute Intersection over Union (IoU) of two sets of masks - `masks_true` and `masks_detection`. Args: masks_true: 3D `np.ndarray` representing ground-truth masks. masks_detection: 3D `np.ndarray` representing detection masks. overlap_metric: Metric used to compute the degree of overlap between pairs of masks (e.g., IoU, IoS). Returns: Pairwise IoU of masks from `masks_true` and `masks_detection`. rwNrF)copyignore)rpoverinvalidrr_rbrArB)rrCprodrerhrrrerrstaterdrr7r8rprorGr9rlr% nan_to_numrrfrgr) rrrJpixels count_dtype true_flatdetection_flatintersection_areamasks_true_areamasks_detection_area union_arear small_areas r_mask_iou_batch_splitrs.))!"-. /F &%"**RZZK"":#3#3A#6?FF%GI%,,_-B-B1-EvNUU%VN H8X FX;D~GWGW;WX mmm+O)--1-5***$QW-0DDGXX yy   /u=/   =,, ,ZZ4 8:NO yy   /u=/  n-.1 1  == D  BKK($ //=XXs HHic t|trt|tr t|||St|trtj|}t|trtj|}|j dk7s|j dk7r&t d|j d|j d|jdd|jddk7r,t d|jddd|jddd|jd d k(s|jd d k(r t|||S|jd|jd z}|d krd nd }|dzdz}|jd |z|z}||zd|jd zd zz}||cxkDrd kDr,nn)tjd|dzdzd|dtd ||jd |zz|kr t|||Sg} t||z |zd} td |jd | D]$} | jt|| | | z||&tt j"tj$tj&| S)a Compute Intersection over Union (IoU) of two sets of masks - `masks_true` and `masks_detection`. Accepts both dense ``(N, H, W)`` boolean arrays and :class:`~supervision.detection.compact_mask.CompactMask` objects. When both inputs are :class:`~supervision.detection.compact_mask.CompactMask`, the computation uses :func:`compact_mask_iou_batch` to avoid materialising full ``(N, H, W)`` arrays. Args: masks_true: 3D `np.ndarray` representing ground-truth masks. masks_detection: 3D `np.ndarray` representing detection masks. overlap_metric: Metric used to compute the degree of overlap between pairs of masks (e.g., IoU, IoS). memory_limit: Memory limit in MB, default is 1024 * 5 MB (5GB). Controls chunking of ``masks_true`` so that flattened detection masks plus each chunk's buffers stay within this limit. A ``UserWarning`` is raised when ``masks_detection`` alone exceeds the limit, as chunking cannot reduce peak memory below that floor. Ignored when both inputs are :class:`~supervision.detection.compact_mask.CompactMask`. Returns: Pairwise IoU of masks from `masks_true` and `masks_detection`. Raises: ValueError: If ``masks_true`` or ``masks_detection`` are not 3D ``(N, H, W)`` arrays, or if they do not share the same spatial dimensions ``(H, W)``. ryz>masks_true and masks_detection must be 3D (N, H, W); got ndim=z and ndim=rrwNz?masks_true and masks_detection must share the same (H, W); got  and rrxr rrizdetection masks (z MB) exceed memory_limit (z: MB); chunking cannot reduce peak memory below this floor.) stacklevel)r"rr rCasarrayrr%rerwarningswarn UserWarningrErangeappendrrfrgrvstack) rrrJ memory_limitritemsize limit_bytesdetection_bytes per_true_rowrstep chunk_starts rmask_iou_batchr/sL*k*z/;/W%j/>RR*k*ZZ + /;/**_5!33q8 OO$J/C/C.DA G  44QR88 M#$E/*?*?*C)DA G  a?#8#8#;q#@$Z.QQ  a :#3#3A#6 6FeOqH%,K%++A.7(BOH$q?+@+@+C'Ca'GGL(q( 4 74 ?@A)N+' '   ))!,|;;{J$Z.QQ D  o-,> BDQ 0 0 3T:  !;t);<     BKK("))D/ ::rricrd|cxkrdks nJd|d|j\}}|dk(r(tj|tj|f}|dddfj ddd}||}||}t |||}|dddf} tj |t } t|D]B} | | s || |kD| | | k(z} tj| | dzdd | | dzd| | dzdDttjtj| |j S) u Perform Non-Maximum Suppression (NMS) on segmentation predictions. IoU is computed exactly on the full-resolution masks for both dense and :class:`~supervision.detection.compact_mask.CompactMask` inputs. The ``mask_dimension`` parameter is kept for backward compatibility but is no longer used — dense masks are **not** resized before IoU computation. Args: predictions: A 2D 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)`. Shape: `(N, 5)` or `(N, 6)`, where N is the number of predictions. masks: A 3D array of binary masks corresponding to the predictions. Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the dimensions of each mask. iou_threshold: The intersection-over-union threshold to use for non-maximum suppression. overlap_metric: Metric used to compute the degree of overlap between pairs of masks (e.g., IoU, IoS). mask_dimension: Deprecated, no longer used. Kept for backward compatibility. Returns: A boolean array indicating which predictions to keep after non-maximum suppression. Raises: AssertionError: If `iou_threshold` is not within the closed range from `0` to `1`. rrwBValue of `iou_threshold` must be in the closed range from 0 to 1,  given.Nrrr_F)rerCc_rargsortr/onesboolr%rcrrfrgbool_) predictionsmasks iou_thresholdrJmask_dimensionrcolumns sort_indexr categorieskeeprow_idx conditions rmask_non_max_suppressionrC@s]L " "L / " " %%MD'!|eeK$78 QT"**,TrT2Jj)K * E % 7DQT"J 774t $D; =g67#z1I#%(('A+-(%gkm1D#D1    BHH%tJ,>,>,@'A BBrc|j\}}|dk(r(tj|tj|f}tj|dddfj }||}|dddf}|||fS)zAdd an agnostic class column when missing, sort by descending score. Returns the score-descending sort index, the reordered predictions, and the category vector for the loop callers to consume. r3Nr)rerCr4rflipr5)r9rr=r>r?s r_prepare_predictions_for_nmsrFsz %%MD'!|eeK$78 QT*2245Jj)KQT"J {J ..rct|}|tj|z }tj|t}t t ||D]\}\}}||s||kD||k(z}||z}!|S)aGreedy NMS suppression loop given a precomputed pairwise IoU matrix. Assumes `ious` is square with row/column order matching `categories`. Detections sharing a category whose IoU exceeds `iou_threshold` are dropped in favour of the higher-confidence entry. r_)rrCeyer6r7rr) rr?r;rr@indexioucategoryrBs r_nms_loop_from_iou_matrixrLs t9D "&&, D"$''$d";D"+Cj,A"B!XE{ =(Z8-CD yj  ! Krc d|cxkrdks nJd|dt|\}}}t|ddddf|ddddf|}t|||}ttj t j||jS)a Perform Non-Maximum Suppression (NMS) on object detection predictions. Args: predictions: 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: The intersection-over-union threshold to use for non-maximum suppression. overlap_metric: Metric used to compute the degree of overlap between pairs of boxes (e.g., IoU, IoS). Returns: A boolean array indicating which predictions to keep after non-maximum suppression. Raises: AssertionError: If `iou_threshold` is not within the closed range from `0` to `1`. rrwr1r2Nr) rFrurLrrfrgrCr8r5)r9r;rJr>r?rr@s rbox_non_max_suppressionrNs2 " "L / " "+G{*S'J Z QU+[BQB-? PD $T:} ED  BHH%tJ,>,>,@'A BBrcg}|dddf}|j}t|dkDr*t|d}|dd}t|dk(r|j|g |S||d}|g} t|dkDrt ||||} | j |k\} | j sn|| } tjjtj|| |gdd}| jtj| j|| }t|dkDr|j| t|dkDr*|S)a Apply greedy version of non-maximum merging to avoid detecting too many Args: predictions: An array of shape `(n, 5)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]` and the confidence scores. masks: A 3D array of binary masks corresponding to the predictions. iou_threshold: The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. overlap_metric: Metric used to compute the degree of overlap between pairs of masks (e.g., IoU, IoS). Returns: Groups of prediction indices to be merged. Each group may have 1 or more elements. NrrrN.T)rkeepdims)r5rrr&r/flattenanyrC logical_orreduce concatenateextendrEtolist) r9r:r;rJ merge_groupsscoresorderidxmerge_candidatecandidate_groupsrabove_threshold above_idxs r_group_overlapping_masksrasa0%'L A F NN E e*q.%)ncr  u:?    & & # *Y/5%j1n!%,PD59\\^}5TO"&&(o.I mm22i 0/BC3O  # #BGGI$6$=$=$? @?*+E%j1n ,-1 e*q.2 rct|tr ttj||}n t||}|}|j ddk(rt ||||S|dddf}g}tj|D]Z}tj||k(d} t || || ||} | D]$} |j| | j&\|D]} t| dk(std||S)aH Perform Non-Maximum Merging (NMM) on segmentation predictions. Args: predictions: A 2D 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)`. Shape: `(N, 5)` or `(N, 6)`, where N is the number of predictions. masks: A 3D array of binary masks corresponding to the predictions. Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the dimensions of each mask. iou_threshold: The intersection-over-union threshold to use for non-maximum suppression. mask_dimension: The dimension to which the masks should be resized before computing IOU values. Defaults to 640. overlap_metric: Metric used to compute the degree of overlap between pairs of masks (e.g., IoU, IoS). Returns: A list of groups of prediction indices. Each inner list contains the indices of predictions whose masks overlap above `iou_threshold` according to the chosen `overlap_metric`, and should be merged or kept together as a single detection by non-maximum merging. Raises: AssertionError: If `iou_threshold` is not within the closed range from `0` to `1`. rwr3Nr6Empty group detected when non-max-merging detections: ) r"rr rCr!rerauniquercr&rXrr%) r9r:r;r<rJ masks_resized category_idsrY category_id curr_indicesmerge_class_groupsmerge_class_group merge_groups rmask_non_max_mergerls6H%%RZZ.?UN3Mq '  ~  q!t$LLyy. J xx ; ? F F H I J J$ { q HW  rc~g}|dddf}|j}t|dkDrt|d}|dd}t|dk(r|j|g |S|||}||k\}|gt j ||j } |j| ||}t|dkDr|S)aUGreedy non-maximum merging loop, independent of how overlap is computed. ``iou_against_candidate(order_indices, candidate_idx)`` must return the IoU vector between every prediction in ``order_indices`` and the candidate at ``candidate_idx``. Predictions whose IoU meets ``iou_threshold`` are grouped with the candidate. Nrrr)r5rrr&rCrErX) r9iou_against_candidater;rYrZr[r\rr_rks r_greedy_nmm_via_iou_callbackroQs%'L A F NN E e*q.%)ncr  u:?    &   %UC0-/FRWWU?%;<CCEF K(&' e*q. rc|jddk(rKtjt|t}||Dcgc]}||j c}S|dddf}g}tj |D]L}tj||k(d}||D]$}|j||j &N|D]} t| dk(std||Scc}w)aDispatch NMM grouping per class, then translate local indices back to the global row positions of ``predictions``. ``group_within(global_indices)`` must return merge groups expressed in terms of *positions inside `global_indices`*, not absolute row positions. When ``predictions`` has no class column, a single pass over all rows is performed instead of per-category iteration. rwr3r_Nrrc) rerCarangerrrXrdrcr&r%) r9 group_withinglobal_indicesgrouprfrYrgrh local_grouprks r_non_max_merge_per_categoryrvpsq 3{#33?8D^8T /4N5 ! ( ( *  q!t$L$&Lyy.D xx ;.iou_against_candidatesL  q"1"u % cAg rr) *   ')  rr[npt.NDArray[np.int_]r\rr-npt.NDArray[np.floating]ro)r9r;rJrns` ` r_group_overlapping_boxesr}s7.#*- ! (*M rc0dfd }t|S)a0 Apply greedy version of non-maximum merging per category to avoid detecting too many overlapping bounding boxes for a given object. Args: predictions: An array of shape `(n, 5)` or `(n, 6)` containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`, the confidence scores and class_ids. Omit class_id column to allow detections of different classes to be merged. iou_threshold: The intersection-over-union threshold to use for non-maximum suppression. Defaults to 0.5. overlap_metric: Metric used to compute the degree of overlap between pairs of boxes (e.g., IoU, IoS). Returns: list[list[int]]: Groups of prediction indices be merged. Each group may have 1 or more elements. c$t|Sr)r})rsr;rJr9s rrrz'box_non_max_merge..group_withins'  '  rrsrzr-list[list[int]])rv)r9r;rJrrs``` rbox_non_max_mergers0 '{L AArchd|cxkrdks nJd|dd|fd|ffD]\}}|dk(r=|jdk7s|jddvrtd |d |jd H|jd k(r.|jdd dk7rtd |d |jd|jdk(r.|jddk7rtd |d |jd|jdvstd |d|jdt|t|k7r$tdt|dt|dt |\}}}||}t |||} t | ||} ttjtj| |jS)u Perform Non-Maximum Suppression on oriented bounding box predictions. Overlap is computed via :func:`oriented_box_iou_batch` on the four corners of each box, so detections whose axis-aligned bounding boxes overlap heavily but whose oriented bodies do not are kept — unlike :func:`box_non_max_suppression`, which would suppress them. Args: predictions: An array of object detection predictions in the format ``(x_min, y_min, x_max, y_max, score)`` or ``(x_min, y_min, x_max, y_max, score, class)``. Shape ``(N, 5)`` or ``(N, 6)``. Only the score (column 4) and optional class (column 5) are read; the axis-aligned coordinates are not used. oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four ``(x, y)`` corners of each oriented box, aligned with ``predictions`` row-by-row. iou_threshold: The intersection-over-union threshold to use for non-maximum suppression. overlap_metric: Metric used to compute the degree of overlap between pairs of oriented boxes (e.g., IoU, IoS). Returns: A boolean array of shape ``(N,)`` indicating which predictions to keep after non-maximum suppression. Raises: AssertionError: If ``iou_threshold`` is not within the closed range from 0 to 1. ValueError: If ``predictions`` and ``oriented_boxes`` have mismatched lengths or invalid shapes. Examples: >>> import numpy as np >>> import supervision as sv >>> oriented_boxes = np.array([ ... [[10, 10], [50, 10], [50, 30], [10, 30]], ... [[11, 11], [51, 11], [51, 31], [11, 31]], ... ], dtype=np.float32) >>> predictions = np.array([ ... [10, 10, 50, 30, 0.9, 0], ... [11, 11, 51, 31, 0.8, 0], ... ], dtype=np.float32) >>> keep = sv.oriented_box_non_max_suppression( ... predictions=predictions, ... oriented_boxes=oriented_boxes, ... iou_threshold=0.5, ... ) >>> keep array([ True, False]) rrwr1r2r9oriented_boxesrxr3rr; expected (N, 5) or (N, 6).ryNrrrrrrrB`predictions` and `oriented_boxes` must have the same length, got r) rrer%rrFrrLrrfrgrCr8r5) r9rr;rJrrr>rr?rr@s r oriented_box_non_max_suppressionrsr " "L / " "%k25E~4VW c = xx1} ! F : v\#))4PQ  88q=SYYqr]f4D6cii[1TU XX]syy|q0D6cii[1>? XXV #D6J399+UVW %* ;3~..{#$E#n*=)>a A  !=[ IJ:#J/N !... QD $T:} ED  BHH%tJ,>,>,@'A BBrc: dfd }t|||S)z Greedy non-maximum merging on oriented boxes. Mirrors :func:`_group_overlapping_boxes` but uses :func:`oriented_box_iou_batch`. cLt||djS)NrP)rrR)r[r\rrJs rrnz@_group_overlapping_oriented_boxes..iou_against_candidate@s3& 5 ! 3  *   ')  rryr|)r9rr;rJrns ` ` r!_group_overlapping_oriented_boxesr5s7#*- ! (*M rcdfdffD]\}}|dk(r=|jdk7s|jddvrtd|d|jdH|jd k(r.|jdd d k7rtd|d|jd |jdk(r.|jdd k7rtd|d|jd|jdvstd|d|jdttk7r$tdtdtddcxkrdks nJdddfd }t |S)u Perform Non-Maximum Merging on oriented bounding box predictions, grouped per category. Mirrors :func:`box_non_max_merge` but uses oriented-box IoU, so groups of rotated detections sharing the same body — rather than the same axis-aligned bounding box — are merged. Args: predictions: An array of shape ``(n, 5)`` or ``(n, 6)`` containing the axis-aligned coordinates ``[x1, y1, x2, y2]``, confidence scores, and optionally class ids. Only the score and optional class are used by the grouping logic; overlap is computed on ``oriented_boxes``. oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four ``(x, y)`` corners of each oriented box. iou_threshold: The intersection-over-union threshold to use for non-maximum merging. overlap_metric: Metric used to compute the degree of overlap between pairs of oriented boxes (e.g., IoU, IoS). Returns: Groups of prediction indices to be merged. Each group may have 1 or more elements. Raises: AssertionError: If ``iou_threshold`` is not within the closed range from 0 to 1. ValueError: If ``predictions`` and ``oriented_boxes`` have mismatched lengths or invalid shapes. Examples: >>> import numpy as np >>> import supervision as sv >>> oriented_boxes = np.array([ ... [[10, 10], [50, 10], [50, 30], [10, 30]], ... [[11, 11], [51, 11], [51, 31], [11, 31]], ... ], dtype=np.float32) >>> predictions = np.array([ ... [10, 10, 50, 30, 0.9, 0], ... [11, 11, 51, 31, 0.8, 0], ... ], dtype=np.float32) >>> groups = sv.oriented_box_non_max_merge( ... predictions=predictions, ... oriented_boxes=oriented_boxes, ... iou_threshold=0.5, ... ) >>> len(groups) 1 r9rrxrwrrrrryNrrrrrrrrrrr1r2c,t||Sr)r)rsr;rrJr9s rrrz0oriented_box_non_max_merge..group_withins&0  ' > *     rr)rrer%rrv)r9rr;rJrrrrs```` roriented_box_non_max_mergerNsp%k25E~4VW c = xx1} ! F : v\#))4PQ  88q=SYYqr]f4D6cii[1TU XX]syy|q0D6cii[1>? XXV #D6J399+UVW %* ;3~..{#$E#n*=)>a A   " "L / " "    '{L AAr)rH&list[float] | npt.NDArray[np.floating]rIrrJr>r-rG)rqnpt.NDArray[np.number]rrrrJr>r-znpt.NDArray[np.float32])r{ list[float]r|rr}r7r-rG)rqlist[list[float]]rrrr}z list[bool]r-npt.NDArray[np.float64])rr{r-r{)rr{rr{r-z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])rqrrrrrJr7r-r{)rrrrrJr7r-r{)rnpt.NDArray[Any]rrrJr7r-r{) rrrrrJr7r(rr-r{) r9r{r:rr;rGrJr7r<rr-npt.NDArray[np.bool_])r9r{r-zOtuple[npt.NDArray[np.int_], npt.NDArray[np.floating], npt.NDArray[np.floating]])rr{r?r{r;rGr-r)r9r{r;rGrJr7r-r) r9rr:rr;rGrJr7r-r) r9r{r:rr;rGr<rrJr7r-r)r9rrnz?Callable[[npt.NDArray[np.int_], int], npt.NDArray[np.floating]]r;rGr-r)r9rrrz1Callable[[npt.NDArray[np.int_]], list[list[int]]]r-r)r9rr;rGrJr7r-r) r9r{rr{r;rGrJr7r-r) r9r{rr{r;rGrJr7r-r). __future__rr"collections.abcrenumrtypingrrrnumpyrC numpy.typingrf"supervision.detection.compact_maskr!supervision.detection.utils.masksr r r7r8r]rurrrrrrr rr/rCrFrLrNrarlrorvr}rrrrr5rrrs"$ ::# D# L! D! N+8*;*;E)4E)9E)(E) E)V+8*;*;c&c+c(c cL%,P8!8&88 8v K  X,X1X7XF%2$5$5LC&LC+LC"LC LCd%2$5$5ddd"d dT%2$5$5=0 =0%=0"=0 =0F%2$5$5 ]; ];%];"]; ];  ];F$1$5$5 @C)@C @C@C" @C  @C  @CF/)/T/" "( 0$1$5$5 C) C C" C CL$1$5$5 6(6 "66" 6  6x$1$5$5 H)H HH H " H  HV(    >(CF$1$5$5"("""" "N$1$5$5B(BB"B BF$1$5$5 \C)\C,\C\C" \C  \CD$1$5$5 ),"   8$1$5$5 _B)_B,_B_B" _B  _Br