^j^ddlmZddlmZmZddlZddlZddlmZ dZ ddZ ddZ ddZ ddZdd Zdd Zdd Z dd Zd d Zd!dZd"dZd#dZd$dZd%dZd&dZ d'dZ d(dZ d) d*dZd+dZy),) annotations)AnycastNctj|jdddf|j}|ddgdf|dddddf<|ddgdf|dddddf<|S) a Convert an array of boxes to an array of polygons. Retains the input datatype. Args: box: An array of boxes (N, 4), where each box is represented as a list of four coordinates in the format `(x_min, y_min, x_max, y_max)`. Returns: An array of polygons (N, 4, 2), where each polygon is represented as a list of four coordinates in the format `(x, y)`. rdtypeN)rr r r)r rrr )npzerosshaper )boxpolygons q/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/detection/utils/converters.pyxyxy_to_polygonsr s^hh ! a+399=G1l?+GAq!G1l?+GAq!G Nctt|\}}tj||ftj}t j ||jtjgd|S)aeGenerate a mask from a polygon. Args: polygon: The polygon for which the mask should be generated, given as a list of vertices. resolution_wh: The width and height of the desired resolution. Returns: The generated 2D mask, where the polygon is marked with `1`s and the rest is filled with `0`s. r )r )color) mapintr ruint8cv2fillPolyastypeint32)r resolution_whwidthheightmasks rpolygon_to_maskr"sQ]+ME6 88VUO288 4DLLrxx01> Krc|j}|dddf|dddfz|dddf<|dddf|dddfz|dddf<|S)a Converts bounding box coordinates from `(x, y, width, height)` format to `(x_min, y_min, x_max, y_max)` format. Args: xywh: A numpy array of shape `(N, 4)` where each row corresponds to a bounding box in the format `(x, y, width, height)`. Returns: 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)`. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> xywh = np.array([ ... [10, 20, 30, 40], ... [15, 25, 35, 45] ... ]) >>> sv.xywh_to_xyxy(xywh=xywh) array([[10, 20, 40, 60], [15, 25, 50, 70]]) ``` Nrr r rcopy)xywhxyxys r xywh_to_xyxyr(4sX6 99;Dadd1a4j(DAJadd1a4j(DAJ Krc|j}|dddf|dddfz |dddf<|dddf|dddfz |dddf<|S)a  Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)` format to `(x, y, width, height)` format. Args: xyxy: 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)`. Returns: A numpy array of shape `(N, 4)` where each row corresponds to a bounding box in the format `(x, y, width, height)`. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> xyxy = np.array([ ... [10, 20, 40, 60], ... [15, 25, 50, 70] ... ]) >>> sv.xyxy_to_xywh(xyxy=xyxy) array([[10, 20, 30, 40], [15, 25, 35, 45]]) ``` Nr rrr r$)r'r&s r xyxy_to_xywhr*UsX8 99;Dadd1a4j(DAJadd1a4j(DAJ Krc|j}|dddf|dddfdz z |dddf<|dddf|dddfdz z |dddf<|dddf|dddfdz z|dddf<|dddf|dddfdz z|dddf<|S)aP Converts bounding box coordinates from `(center_x, center_y, width, height)` format to `(x_min, y_min, x_max, y_max)` format. Args: xcycwh: A numpy array of shape `(N, 4)` where each row corresponds to a bounding box in the format `(center_x, center_y, width, height)`. Returns: 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)`. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> xcycwh = np.array([ ... [50.0, 50.0, 20.0, 30.0], ... [30.0, 40.0, 10.0, 15.0] ... ]) >>> sv.xcycwh_to_xyxy(xcycwh=xcycwh) array([[40. , 35. , 60. , 65. ], [25. , 32.5, 35. , 47.5]]) ``` Nrr r rr$)xcycwhr's rxcycwh_to_xyxyr-ws8 ;;=D1q!t q 00DAJ1q!t q 00DAJ1q!t q 00DAJ1q!t q 00DAJ Krcr|jdk(rtjdtS|j\}}}}||z }||z }||dz z}||dz z}tj ||tj |t|dk7} tj||| |f} | jtS)a^ Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)` into measurement space to format `(center x, center y, aspect ratio, height)`, where the aspect ratio is `width / height`. Args: xyxy: Bounding box in format `(x1, y1, x2, y2)`. Expected shape is `(N, 4)`. Returns: Bounding box in format `(center x, center y, aspect ratio, height)`. Shape `(N, 4)`. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> xyxy = np.array([ ... [10, 20, 40, 60], ... [15, 25, 50, 70] ... ]) >>> sv.xyxy_to_xcycarh(xyxy=xyxy) # doctest: +ELLIPSIS array([[25. , 40. , 0.75 , 40. ], [32.5 , 47.5 , 0.77..., 45. ]]) ``` r)rrr r )outwhere) sizer emptyfloatTdivide zeros_like column_stackr) r'x1y1x2y2rr center_xcenter_y aspect_ratioresults rxyxy_to_xcycarhr@s8 yyA~xxe,,VVNBB GE "WFEAI~HFQJH99  MM%u -k L __h,G HF == rc|j\}}}|jdk(rtj|dftSt t jtj|jd}t t jtj|jd}|jd}|dz |dddddfjdz }|jd}|dz |dddddfjdz } tj|||| fdjt} d| |jd<| S) a Converts a 3D `np.array` of 2D bool masks into a 2D `np.array` of bounding boxes. Args: masks: A 3D `np.array` of shape `(N, H, W)` containing 2D bool masks. Returns: A 2D `np.array` of shape `(N, 4)` containing the bounding boxes `(x_min, y_min, x_max, y_max)` for each mask. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> masks = np.array([ ... [[False, False, False], ... [False, True, True], ... [False, True, True]], ... ]) >>> sv.mask_to_xyxy(masks) array([[1, 1, 2, 2]]) ``` rrr r axisr N) rr1r rrrnptNDArraybool_anyargmaxstackr) masksnr rrows_anycols_anyx_minx_maxy_miny_maxr's r mask_to_xyxyrSs12{{Avu zzQxxAc** CKK)599!9+<=HCKK)599!9+<=H OOO #E AIDbD)00a08 8E OOO #E QJ!TrT'*11q19 9E 88UE5%0q 9 @ @ ED"#D(,,A,   Krc|\}}|jd}tj|||ft}t |D]\}\}}} } t dt |}t dt |}t|dz t | } t|dz t | } | |k\sk| |k\sqd|||| dz|| dzf<|S)a1 Converts a 2D `np.ndarray` of bounding boxes into a 3D `np.ndarray` of bool masks. Args: boxes: A 2D `np.ndarray` of shape `(N, 4)` containing bounding boxes `(x_min, y_min, x_max, y_max)`. resolution_wh: A tuple `(width, height)` specifying the resolution of the output masks. Returns: A 3D `np.ndarray` of shape `(N, height, width)` containing 2D bool masks for each bounding box. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> boxes = np.array([[0, 0, 2, 2]]) >>> sv.xyxy_to_mask(boxes, (5, 5)) array([[[ True, True, True, False, False], [ True, True, True, False, False], [ True, True, True, False, False], [False, False, False, False, False], [False, False, False, False, False]]]) >>> boxes = np.array([[0, 0, 1, 1], [3, 3, 4, 4]]) >>> sv.xyxy_to_mask(boxes, (5, 5)) array([[[ True, True, False, False, False], [ True, True, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False]], [[False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, True, True], [False, False, False, True, True]]]) ``` rr r T)rr rbool enumeratemaxrmin) boxesrrr rLrKirOrQrPrRs r xyxy_to_maskr[sV"ME6 AA HHa't 4E+4U+;B' 'E5%As5z"As5z"EAIs5z*FQJE + E>eun=AE!UUQY& (99 :B Lrc(tj|jtjtj tj \}}|Dcgc]/}|jdtk\rtj|d1c}Scc}w)a Converts a binary mask to a list of polygons. Args: mask: 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: 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. rr rB) r findContoursrr r RETR_TREECHAIN_APPROX_SIMPLErMIN_POLYGON_POINT_COUNTsqueeze)r!contours_contours rmask_to_polygonsre3su"" BHHs}}c.E.EKHa     == 6 6 7#  s4BcJg}d}|t|krd}d}d}|rh|t|k\rtd|t||dz }||dzd|zzz}t|dz}|dz }|dz }|s|d zr |d d|zzz}|rh|j ||t|kr|S) u0Decode a COCO base-48 string to raw (delta-encoded) integers. Implements the variable-length base-48 codec from the COCO API (pycocotools). Each integer is encoded across one or more 6-bit characters: bits 0-4 carry data; bit 5 signals continuation; bit 4 of the final character signals a negative value. This is the pure codec layer — call :func:`_delta_decode` on the result to obtain absolute run-length counts. Args: s: COCO compressed RLE string. Returns: Raw delta-encoded integers, one per run. Raises: ValueError: If the string is truncated mid-integer. Examples: ```pycon >>> from supervision.detection.utils.converters import _base48_decode >>> _base48_decode("52203") [5, 2, 2, 0, 3] ``` rTzD FA FAQXRAE]"  a! c!f*" Mrcg}|D]G}d}|s|dz}|dz}|dzr|dk7n|dk7}|r|dz}|jt|dz|r@Id j|S) arEncode raw (delta-encoded) integers to a COCO base-48 string. The inverse of :func:`_base48_decode`. Applies the same variable-length base-48 codec used by pycocotools. Apply :func:`_delta_encode` to absolute run-length counts before calling this function to produce a valid COCO compressed RLE string. Args: values: Raw (delta-encoded) integers to encode. Returns: COCO base-48 encoded string. Examples: ```pycon >>> from supervision.detection.utils.converters import _base48_encode >>> _base48_encode([5, 2, 2, 0, 3]) '52203' ``` TrhrirkrDrrjrg)rochrjoin)rqcharsrrrtrus r_base48_encoder|~s|.E &DA !GA!"TAGaDT  LLQV % & 775>rcvt|}tdt|D]}||xx||dz z cc<|S)aUndo COCO delta encoding: ``counts[i] += counts[i - 2]`` for ``i > 2``. The COCO compressed RLE format stores run lengths as deltas relative to the count two positions earlier (starting at index 3). This function converts those relative values back to absolute run lengths. Args: values: Raw delta-encoded integers from :func:`_base48_decode`. Returns: Absolute run-length counts (alternating background / foreground). Examples: ```pycon >>> from supervision.detection.utils.converters import _delta_decode >>> _delta_decode([5, 2, 2, 0, 3]) [5, 2, 2, 2, 5] ``` rr listrangerl)rqcountsrZs r _delta_decodersB*&\F 1c&k "#q VAE]" # Mrcrt|}tdt|D]}||||dz z ||<|S)aTApply COCO delta encoding: ``d[i] = counts[i] - counts[i - 2]`` for ``i > 2``. The inverse of :func:`_delta_decode`. Converts absolute run lengths to the relative representation required by the COCO compressed RLE format. Args: counts: Absolute run-length counts (alternating background / foreground). Returns: Delta-encoded integers ready for :func:`_base48_encode`. Examples: ```pycon >>> from supervision.detection.utils.converters import _delta_encode >>> _delta_encode([5, 2, 2, 2, 5]) [5, 2, 2, 0, 3] ``` rr r~)rdeltasrZs r _delta_encodersF(&\F 1c&k ".1Iq1u -q . Mrc.t|ttfS)uReturn ``True`` if ``rle`` is a COCO compressed RLE (``str`` or ``bytes``). Use this to branch between the compressed-string pipeline (:func:`_base48_decode` → :func:`_delta_decode`) and the uncompressed integer-list / array pipeline before calling :func:`rle_to_mask`. Args: rle: Candidate RLE value to inspect. Returns: ``True`` for ``str`` or ``bytes`` inputs; ``False`` otherwise. Examples: ```pycon >>> from supervision.detection.utils.converters import is_compressed_rle >>> is_compressed_rle("52203") True >>> is_compressed_rle([5, 2, 2, 2, 5]) False ``` ) isinstancestrbytes)rles ris_compressed_rlers. cC< ((rctj|tjjd}t |dk(r&tj dgtj Stj|jtj}tj|dk7ddz}tjdg|t |gf}tj|jtj }|dr+tjtj dg|f}|S)abEncode a 2D boolean mask as COCO F-order run lengths (int32 array). Pixels are scanned column-by-column (Fortran order), matching the COCO / pycocotools RLE convention. The first value is always the count of leading ``False`` pixels (may be 0 if the mask starts with ``True``). This is the shared low-level encoder used by both :func:`mask_to_rle` and :class:`~supervision.detection.compact_mask.CompactMask`. Args: mask_2d: 2D boolean array of shape ``(H, W)``. Returns: int32 array of run lengths starting with the False count. Examples: ```pycon >>> import numpy as np >>> from supervision.detection.utils.converters import _mask_to_rle_counts >>> mask = np.array([[False, True], [True, False]]) >>> _mask_to_rle_counts(mask).tolist() [1, 2, 1] ``` r Forderrr ) r asarrayrGravelrlarrayrdiffviewrr0 concatenater)mask_2dflatchanges boundaries positions run_lengthss r_mask_to_rle_countsrs4 ::gRXX . 4 43 4 ?D 4yA~xx288,,ggdii)*G'Q,'*Q.JZ#d)=>I'')$++BHH5K Awnnrxx{m[%AB rcdtjt|dzdk(}tj||}||z}t||kr$tj|d|t|z f}t t jtj|d|j||dS)aDecode COCO F-order run lengths back to a 2D boolean mask. This is the shared low-level decoder used by both :func:`rle_to_mask` and :class:`~supervision.detection.compact_mask.CompactMask`. Args: rle: int32 array of run lengths as produced by :func:`_mask_to_rle_counts`. height: Height of the output mask. width: Width of the output mask. Returns: 2D boolean array of shape ``(height, width)``. Examples: ```pycon >>> import numpy as np >>> from supervision.detection.utils.converters import _rle_counts_to_mask >>> rle = np.array([0, 1, 2, 1], dtype=np.int32) >>> _rle_counts_to_mask(rle, 2, 2) array([[ True, False], [False, True]]) ``` r r rNrr) r arangerlrepeatpadrrErFrGreshape)rr ris_truer num_pixelss r_rle_counts_to_maskrs6iiC!A%*G"$))GS"9D%J 4y:vvdQ SY 678  BHHtKZ088c8R rct|tr|jd}t|tr8t j t t|tj}n[t|tr&t j |tj}n%t j|tj}|\}}||zt j|k7r tdt|||S)u Converts a COCO run-length encoding (RLE) to a binary mask. Implements the COCO RLE format used by ``pycocotools``: pixels are counted in **column-major (Fortran) order** — top-to-bottom within each column, left-to-right across columns. This is the opposite of the row-major order used by NumPy's default ``'C'`` layout. Passing RLE data produced by a different row-major convention will yield an incorrect mask. Args: rle: The COCO RLE data in one of the following formats: - A 1D array or list of integers (uncompressed COCO RLE, where values at even indices are background run-lengths and values at odd indices are foreground run-lengths, both counted column-major). - A compressed COCO RLE string or bytes, as produced by ``pycocotools.mask.encode``. resolution_wh: The width (w) and height (h) of the desired binary mask. Returns: The generated 2D Boolean mask of shape `(h, w)`, where the foreground object is marked with `True`'s and the rest is filled with `False`'s. Raises: ValueError: If the sum of pixels encoded in RLE differs from the number of pixels in the expected mask (computed based on resolution_wh). Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> mask = sv.rle_to_mask([5, 2, 2, 2, 5], (4, 4)) >>> mask # doctest: +NORMALIZE_WHITESPACE array([[False, False, False, False], [False, True, True, False], [False, True, True, False], [False, False, False, False]]) >>> mask = sv.rle_to_mask("52203", (4, 4)) >>> mask # doctest: +NORMALIZE_WHITESPACE array([[False, False, False, False], [False, True, True, False], [False, True, True, False], [False, False, False, False]]) ``` zutf-8r zhthe sum of the number of pixels in the RLE must be the same as the number of pixels in the expected mask)rrdecoderr rrrvrrrsumrmr)rrrrr s r rle_to_maskr?sh#ujj!#s(* .- .bhh)  C #RXX.Crxx0!ME6 v~' ;  vvu 55rc|jdk(sJd|jdk7sJdtttt |j }|rtt|S|S)u Converts a binary mask into a COCO run-length encoding (RLE). Produces RLE in the COCO format used by ``pycocotools``: pixels are counted in **column-major (Fortran) order** — top-to-bottom within each column, left-to-right across columns. The output is directly compatible with ``pycocotools.mask.decode`` and COCO annotation JSON files. Args: mask: 2D binary mask where `True` indicates foreground object and `False` indicates background. compressed: If ``True``, return a compressed COCO RLE string compatible with ``pycocotools``. If ``False`` (default), return a list of integers. Returns: The COCO run-length encoded mask. When ``compressed`` is ``False``, values of a list with even indices represent the number of pixels assigned as background (`False`), values of a list with odd indices represent the number of pixels assigned as foreground object (`True`), both counted in column-major order. When ``compressed`` is ``True``, a COCO compressed RLE string. Raises: AssertionError: If input mask is not 2D or is empty. Examples: ```pycon >>> import numpy as np >>> import supervision as sv >>> mask = np.array([ ... [True, True, True, True], ... [True, True, True, True], ... [True, True, True, True], ... [True, True, True, True], ... ]) >>> rle = sv.mask_to_rle(mask) >>> [int(x) for x in rle] [0, 16] ``` ```pycon >>> import numpy as np >>> import supervision as sv >>> mask = np.array([ ... [False, False, False, False], ... [False, True, True, False], ... [False, True, True, False], ... [False, False, False, False], ... ]) >>> rle = sv.mask_to_rle(mask) >>> [int(x) for x in rle] [5, 2, 2, 2, 5] >>> sv.mask_to_rle(mask, compressed=True) '52203' ``` ![mask_to_rle](https://media.roboflow.com/supervision-docs/ mask-to-rle.png){ align=center width="800" } r zInput mask must be 2DrzInput mask cannot be empty) ndimr1rrrrtolistr|r)r! compressedrs r mask_to_rlershD 99>222> 99>777>T#Y(;D(A(H(H(JKFmF344 Mrctj|d\}}tj|d\}}tj||||gS)ag Converts a polygon represented by a NumPy array into a bounding box. Args: polygon: A polygon represented by a NumPy array of shape `(N, 2)`, containing the `x`, `y` coordinates of the points. Returns: A 1D NumPy array containing the bounding box `(x_min, y_min, x_max, y_max)` of the input polygon. rrB)r rXrWr)rrOrQrPrRs rpolygon_to_xyxyrsD66'*LE566'*LE5 88UE5%0 11r)rnpt.NDArray[np.number]returnr)rrrtuple[int, int]rznpt.NDArray[np.uint8])r&rrr)r'rrr)r,rrr)r'rrznpt.NDArray[np.floating])rKnpt.NDArray[np.bool_]rznpt.NDArray[np.int_])rYrrrrr)r!rrzlist[npt.NDArray[np.int32]])rprr list[int])rqrrr)rqrrr)rrrr)robjectrrU)rznpt.NDArray[Any]rnpt.NDArray[np.int32])rrr rrrrr)rz6npt.NDArray[np.integer[Any]] | list[int] | str | bytesrrrr)F)r!rrrUrzlist[int] | str)rrrr) __future__rtypingrrrnumpyr numpy.typingrEr`rr"r(r*r-r@rSr[rervr|rrrrrrrrrrrs" & #"*BD!H, ^+\8 !82A88v2/d!H64)4&R" "(+"47""JG6 ?G6"G6G6V5:H H-1HHV2r