§
    >²¸jÖ[  ã                   ó&  — d dl mZmZmZ d dlZd dlm Z d dlm	Z
 d dlmZ d dlmZ dej        ej                 dej        ej                 fd„Zdej        ej                 d	ej        ej                 d
eeef         dej        ej                 fd„Zdej        ej                 ez  dej        ej                 fd„Zdej        ej                 defd„Z	 d$dej        ej                 dedefd„Z	 d%dej        ej                 dedej        ej                 fd„Zdej        ej                 dej        ej                 fd„Z	 	 	 	 d&dej        ej                 dedz  dedz  deded         dej        ej                 fd„Zdej        ej                 deeeeef         dz  fd„Z e Z!ded eeef         deeeeef         dz  fd!„Z"	 d'deej        e         z  d eeef         d"ej        ej#                 dz  deeeeef         dz  fd#„Z$dS )(é    )ÚAnyÚLiteralÚcastN)Ú_cv2©Ú_contains_holes)ÚCompactMaskÚmasksÚreturnc                 ór   — t          j        d„ | D ¦   «         t           j        t          | ¦  «        ¬¦  «        S )aÆ  Count the number of True pixels in each mask.

    Uses ``np.count_nonzero`` (no axis), which dispatches to a SIMD popcount
    over the raw bool buffer and is ~6x faster than ``np.sum(mask, axis=(1, 2))``.

    Args:
        masks: Boolean mask array of shape ``(N, H, W)``.

    Returns:
        Int64 array of shape ``(N,)`` with the True-pixel count per mask.

    Example:
        ```pycon
        >>> import numpy as np
        >>> from supervision.detection.utils.masks import count_mask_pixels
        >>> m = np.zeros((2, 4, 4), dtype=bool)
        >>> m[0, :2, :2] = True  # 4 pixels
        >>> m[1, :3, :3] = True  # 9 pixels
        >>> count_mask_pixels(m)
        array([4, 9])

        ```
    c              3   ó>   K  — | ]}t          j        |¦  «        V — Œd S ©N)ÚnpÚcount_nonzero)Ú.0Úms     úq/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/supervision/detection/utils/masks.pyú	<genexpr>z$count_mask_pixels.<locals>.<genexpr>$   s-   è è € Ð,Ð, �Ô	˜!Ñ	Ô	Ð,Ð,Ð,Ð,Ð,Ð,ó    )ÚdtypeÚcount)r   ÚfromiterÚint64Úlen)r
   s    r   Úcount_mask_pixelsr      s:   € õ0 Œ;Ø,Ð, eÐ,Ñ,Ô,µB´HÅCÈÁJÄJðñ ô ð r   ÚoffsetÚresolution_whc                 ón  — t          j        | j        d         |d         |d         fd¦  «        }|d         dk     r`|d          }t          | j        d         |d         |d         z
  ¦  «        }d}t          |d         | j        d         |d         z   ¦  «        }nBd}t          | j        d         |d         |d         z
  ¦  «        }|d         }|d         |z   |z
  }|d         dk     r`|d          }t          | j        d         |d         |d         z
  ¦  «        }	d}
t          |d         | j        d         |d         z   ¦  «        }nBd}t          | j        d         |d         |d         z
  ¦  «        }	|d         }
|d         |	z   |z
  }||k    r#|	|k    r| dd…||	…||…f         |dd…|
|…||…f<   |S )a  
    Offset the masks in an array by the specified (x, y) amount.

    Args:
        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.
        offset: An array of shape `(2,)` containing int values
            `[dx, dy]`. Supports both positive and negative values for bidirectional
            movement.
        resolution_wh: The width and height of the desired mask
            resolution.

    Returns:
        Repositioned masks, optionally padded to the specified shape.

    Examples:
        ```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]]], dtype=bool)
        >>> offset = np.array([1, 1])
        >>> sv.move_masks(mask, offset, resolution_wh=(4, 4))
        array([[[False, False, False, False],
                [False, False, False, False],
                [False, False,  True,  True],
                [False, False,  True,  True]]])
        >>> offset = np.array([-2, 2])
        >>> sv.move_masks(mask, offset, resolution_wh=(4, 4))
        array([[[False, False, False, False],
                [False, False, False, False],
                [False, False, False, False],
                [ True, False, False, False]]])

        ```
    r   é   Fé   N)r   ÚfullÚshapeÚmin)r
   r   r   Ú
mask_arrayÚsource_x_startÚsource_x_endÚdestination_x_startÚdestination_x_endÚsource_y_startÚsource_y_endÚdestination_y_startÚdestination_y_ends               r   Ú
move_masksr-   (   sí  € õX ”˜%œ+ aœ.¨-¸Ô*:¸MÈ!Ô<LÐMÈuÑUÔU€Jàˆa„y�1‚}€}Ø  œ)˜ˆÝ˜5œ; qœ>¨=¸Ô+;¸fÀQ¼iÑ+GÑHÔHˆØÐÝ ¨aÔ 0°%´+¸a´.À6È!Ä9Ñ2LÑMÔMÐÐàˆÝ˜5œ; qœ>¨=¸Ô+;¸fÀQ¼iÑ+GÑHÔHˆØ$ QœiÐØ" 1œI¨Ñ4°~ÑEÐàˆa„y�1‚}€}Ø  œ)˜ˆÝ˜5œ; qœ>¨=¸Ô+;¸fÀQ¼iÑ+GÑHÔHˆØÐÝ ¨aÔ 0°%´+¸a´.À6È!Ä9Ñ2LÑMÔMÐÐàˆÝ˜5œ; qœ>¨=¸Ô+;¸fÀQ¼iÑ+GÑHÔHˆØ$ QœiÐØ" 1œI¨Ñ4°~ÑEÐà�nÒ$Ð$¨¸Ò)FÐ)Fð
 �!�!�!�^ LÐ0°.ÀÐ2MÐMÔNð	 	ØˆAˆAØÐ 1Ð1ØÐ 1Ð1ð3ñ	
ð Ðr   c                 ó,  ‡ — t          ‰ t          ¦  «        �rÖt          ‰ ¦  «        }|dk    rCt          t          j        t          j                 t          j        dt          ¬¦  «        ¦  «        S t          j
        |dft          j        ¬¦  «        }t          |¦  «        D �]	}‰                      |¦  «        }|j        \  }}t          ‰ j        |df         ¦  «        }t          ‰ j        |df         ¦  «        }t          |                     ¦   «         ¦  «        }	|	dk    rddg||<   Œ‰t          j        ||f¦  «        \  }
}t%          t          j        |dz   |         ¦  «        ¦  «        |	z  |z   }t%          t          j        |
dz   |         ¦  «        ¦  «        |	z  |z   }||g||<   �Œt          t          j        t          j                 |                     t          ¦  «        ¦  «        S ‰ j        \  }}}t)          ‰ ¦  «        }t          j        ||f¦  «        dz   \  }}d||dk    <   dt          j        t          j                 d	t,          t.          t                   t.          t                   f         d
t          j        t          j                 fˆ fd„}ddgddgf} |||¦  «        |z  } |||¦  «        |z  }t          t          j        t          j                 t          j        ||f¦  «                             t          ¦  «        ¦  «        S )añ  
    Calculate the centroids of binary masks in a tensor.

    Args:
        masks: A 3D NumPy array of shape (num_masks, height, width).
            Each 2D array in the tensor represents a binary mask.
            Also accepts a :class:`~supervision.detection.compact_mask.CompactMask`.

    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.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> import supervision as sv
        >>> masks = np.zeros((1, 10, 10), dtype=bool)
        >>> masks[0, 2:6, 2:6] = True
        >>> sv.calculate_masks_centroids(masks)
        array([[4, 4]])

        ```
    r   )r   r    ©r   r    r   g        g      à?ÚindicesÚaxisr   c                 ó‚   •— t          t          j        t          j                 t          j        ‰| |¬¦  «        ¦  «        S )N)Úaxes)r   ÚnptÚNDArrayr   ÚfloatingÚ	tensordot)r0   r1   r
   s     €r   Úsum_over_maskz0calculate_masks_centroids.<locals>.sum_over_mask°   s0   ø€ õ •C”K¥¤Ô,­b¬l¸5À'ÐPTÐ.UÑ.UÔ.UÑVÔVÐVr   )Ú
isinstancer	   r   r   r4   r5   r   Úint_ÚemptyÚintÚzerosÚfloat64ÚrangeÚcropr"   ÚoffsetsÚsumr0   ÚfloatÚastyper   r6   ÚtupleÚlistÚcolumn_stack)r
   ÚnÚ	centroidsÚir@   Úcrop_hÚcrop_wÚx1Úy1ÚtotalÚ	crop_rowsÚ	crop_colsÚcxÚcyÚ
_num_masksÚheightÚwidthÚtotal_pixelsÚvertical_indicesÚhorizontal_indicesr8   Úaggregation_axisÚ
centroid_xÚ
centroid_ys   `                       r   Úcalculate_masks_centroidsr]   v   sÌ  ø€ õ4 �%�Ñ%Ô%ñ Aå�‰JŒJˆØ�Š6ˆ6Ý�œ¥B¤GÔ,­b¬h°vÅSÐ.IÑ.IÔ.IÑJÔJÐJå-/¬X°q¸!°fÅBÄJÐ-OÑ-OÔ-Oˆ	Ý�q‘”ð 	$ñ 	$ˆAØ—:’:˜a‘=”=ˆDØ!œZ‰NˆF�FÝ�U”] 1 a 4Ô(Ñ)Ô)ˆBÝ�U”] 1 a 4Ô(Ñ)Ô)ˆBÝ˜Ÿš™
œ
‘O”OˆEØ˜ŠzˆzØ # S˜z�	˜!‘Øå#%¤:¨v°vÐ.>Ñ#?Ô#?Ñ ˆI�yÝ•r”v˜y¨3™°Ô5Ñ6Ô6Ñ7Ô7¸%Ñ?À"ÑDˆBÝ•r”v˜y¨3™°Ô5Ñ6Ô6Ñ7Ô7¸%Ñ?À"ÑDˆBØ ˜8ˆI�a‰L‰Lå•C”K¥¤Ô(¨)×*:Ò*:½3Ñ*?Ô*?Ñ@Ô@Ð@à %¤Ñ€J�˜Ý*;¸EÑ*BÔ*B€Lõ ,.¬:°v¸u°oÑ+FÔ+FÈÑ+LÑ(ÐÐ(à&'€L� Ò"Ñ#ðWÝ”�Rœ[Ô)ðWÝ16µt½C´yÅ$ÅsÄ)Ð7KÔ1LðWå	Œ•R”[Ô	!ðWð Wð Wð Wð Wð Wð
 78¸°V¸aÀ¸VÐ4DÐØ�Ð1Ð3CÑDÔDÀ|ÑS€JØ�Ð/Ð1AÑBÔBÀ\ÑQ€JåÝŒ•B”GÔ�bœo¨z¸:Ð.FÑGÔG×NÒNÍsÑSÔSñô ð r   Úmaskc                 ó    — t          | ¦  «        S )a>  
    Checks if the binary mask contains holes (background pixels fully enclosed by
    foreground pixels).

    Args:
        mask: 2D binary mask where `True` indicates foreground
            object and `False` indicates background.

    Returns:
        True if holes are detected, False otherwise.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> import supervision as sv
        >>> mask = np.array([
        ...     [0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0],
        ...     [0, 1, 0, 1, 0],
        ...     [0, 1, 1, 1, 0],
        ...     [0, 0, 0, 0, 0]
        ... ]).astype(bool)
        >>> sv.contains_holes(mask=mask)
        True
        >>> mask = np.array([
        ...     [0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0],
        ...     [0, 1, 1, 1, 0],
        ...     [0, 1, 1, 1, 0],
        ...     [0, 0, 0, 0, 0]
        ... ]).astype(bool)
        >>> sv.contains_holes(mask=mask)
        False

        ```

    ![contains_holes](https://media.roboflow.com/supervision-docs/contains-holes.png){ align=center width="800" }
    r   )r^   s    r   Úcontains_holesr`   ¾   s   € õN ˜4Ñ Ô Ð r   é   Úconnectivityc                 ó  — |dk    r|dk    rt          d¦  «        ‚|                      t          j        ¦  «        }t          j        |t          j        ¬¦  «        }t          j        |||¬¦  «        \  }}t          |dk    ¦  «        S )aŽ  
    Checks if the binary mask contains multiple unconnected foreground segments.

    Args:
        mask: 2D binary mask where `True` indicates foreground
            object and `False` indicates background.
        connectivity: Default: 4 is 4-way connectivity, which means that
            foreground pixels are the part of the same segment/component
            if their edges touch.
            Alternatively: 8 for 8-way connectivity, when foreground pixels are
            connected by their edges or corners touch.

    Returns:
        True when the mask contains multiple not connected components, False otherwise.

    Raises:
        ValueError: If connectivity(int) parameter value is not 4 or 8.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> import supervision as sv
        >>> mask = np.array([
        ...     [0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 0, 1, 1],
        ...     [0, 1, 1, 0, 1, 1],
        ...     [0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0, 0],
        ...     [0, 1, 1, 1, 0, 0]
        ... ]).astype(bool)
        >>> sv.contains_multiple_segments(mask=mask, connectivity=4)
        True
        >>> mask = np.array([
        ...     [0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 1, 1],
        ...     [0, 1, 1, 1, 1, 1],
        ...     [0, 1, 1, 1, 1, 1],
        ...     [0, 1, 1, 1, 1, 1],
        ...     [0, 0, 0, 0, 0, 0]
        ... ]).astype(bool)
        >>> sv.contains_multiple_segments(mask=mask, connectivity=4)
        False

        ```

    ![contains_multiple_segments](https://media.roboflow.com/supervision-docs/contains-multiple-segments.png){ align=center width="800" }
    ra   é   zCIncorrect connectivity value. Possible connectivity values: 4 or 8.r/   ©rb   r    )	Ú
ValueErrorrD   r   Úuint8Ú
zeros_likeÚint32Úcv2ÚconnectedComponentsÚbool)r^   rb   Ú
mask_uint8ÚlabelsÚnumber_of_labelsÚ_s         r   Úcontains_multiple_segmentsrq   è   s”   € ðd �qÒÐ˜\¨QÒ.Ð.ÝØQñ
ô 
ð 	
ð —’�RœXÑ&Ô&€JÝŒ]˜:­R¬XÐ6Ñ6Ô6€FÝÔ1Ø�F¨ðñ ô ÑÐ�aõ Ð  1Ò$Ñ%Ô%Ð%r   é€  Úmax_dimensionc                 ó  — | j         d         }| j         d         }t          d||z  ||z  ¦  «        }|dk    r| S t          ||z  ¦  «        }t          ||z  ¦  «        }t          j        d|dz
  |¦  «                             t          ¦  «        }t          j        d|dz
  |¦  «                             t          ¦  «        }t          j        ||¦  «        \  }	}
| dd…|
|	f         }|                     | j         d         ||¦  «        S )a.  
    Resize all masks in the array to have a maximum dimension of max_dimension,
    maintaining aspect ratio.

    Args:
        masks: 3D array of binary masks with shape (N, H, W).
        max_dimension: The maximum dimension for the resized masks.

    Returns:
        Array of resized masks.
    r   r    g      ð?r   N)r"   r#   r<   r   ÚlinspacerD   ÚmeshgridÚreshape)r
   rs   Ú
max_heightÚ	max_widthÚscaleÚ
new_heightÚ	new_widthÚxÚyÚxvÚyvÚresized_maskss               r   Úresize_masksr‚   &  sø   € ð ”k !”n€JØ”[ ”^€IÝ��] ZÑ/°ÀÑ1JÑKÔK€EØ�‚|€|Øˆå�U˜ZÑ'Ñ(Ô(€JÝ�E˜IÑ%Ñ&Ô&€Iå
Œ�A�y 1‘} iÑ0Ô0×7Ò7½Ñ<Ô<€AÝ
Œ�A�z A‘~ zÑ2Ô2×9Ò9½#Ñ>Ô>€AÝŒ[˜˜AÑÔ�F€Bˆà˜!˜!˜!˜R ˜)Ô$€Mà× Ò  ¤¨Q¤°¸YÑGÔGÐGr   Ú	main_maskc                 óÆ  — | j         \  }}d}d}t          j        t          j        ¦  «        j        dz  }t          j        | d|¦  «                             t          j        ¦  «        }t          j        |t          j        ¬¦  «        |z  }t          |¦  «        D ]Ë}||         }	|r—||dz
           }
t          j	        ||t          j        ¬¦  «        }t          j	        ||t          j        ¬¦  «        }|
dd…         |z   |dd…<   |
dd…         |z   |dd…<   t          j
                             |	|
|z   ||f¦  «        }	t          j
                             |	|z
  ¦  «        |z   ||<   ŒÌt          |dz
  dd¦  «        D ]æ}||         }	|dz   |k     r—||dz            }t          j	        ||t          j        ¬¦  «        }t          j	        ||t          j        ¬¦  «        }|dd…         |z   |dd…<   |dd…         |z   |dd…<   t          j
                             |	||z   ||f¦  «        }	|	ddd…         }t          j
                             ||z
  ¦  «        |z   ddd…         ||<   Œç|S )	z?Return OpenCV 3x3 L2 chamfer distances as fixed-point integers.i{ô  iŠ^ ra   r   r/   r   Néÿÿÿÿ)r"   r   Úiinfor   ÚmaxÚwhererD   Úaranger?   r!   ÚminimumÚreduceÚ
accumulate)rƒ   rU   rV   Úhorizontal_verticalÚdiagonalÚinfinityÚ	distancesÚhorizontal_costsÚrowÚcurrentÚpreviousÚ
upper_leftÚupper_rightÚ	followingÚ
lower_leftÚlower_rightÚreversed_currents                    r   Ú_chamfer_distancesr›   F  s†  € à”O�M€FˆEØÐØ€HÝŒx�œÑ!Ô!Ô%¨Ñ*€HÝ”˜ A xÑ0Ô0×7Ò7½¼ÑAÔA€IÝ”y ­b¬hÐ7Ñ7Ô7Ð:MÑMÐå�V‰}Œ}ð 
ð 
ˆØ˜C”.ˆØð 	Ø   q¡Ô)ˆHÝœ ¨½¼ÐAÑAÔAˆJÝœ' %¨½¼ÐBÑBÔBˆKØ% c r cœ]¨XÑ5ˆJ�q�r�r‰NØ'¨¨¨œ|¨hÑ6ˆK˜˜˜ÑÝ”j×'Ò'Ø˜(Ð%8Ñ8¸*ÀkÐRñô ˆGõ ŒJ×!Ò! 'Ð,<Ñ"<Ñ=Ô=Ð@PÑPð 	�#‰ˆõ �V˜a‘Z  RÑ(Ô(ð ð ˆØ˜C”.ˆØ�‰7�VÒÐØ! #¨¡'Ô*ˆIÝœ ¨½¼ÐAÑAÔAˆJÝœ' %¨½¼ÐBÑBÔBˆKØ& s¨ sœ^¨hÑ6ˆJ�q�r�r‰NØ(¨¨¨œ}¨xÑ7ˆK˜˜˜ÑÝ”j×'Ò'Ø˜)Ð&9Ñ9¸:À{ÐSñô ˆGð # 4 4 R 4œ=ÐåŒJ×!Ò!Ð"2Ð5EÑ"EÑFÔFØñà
ˆ$ˆBˆ$ôˆ	�#‰ˆð
 Ðr   ç      Y@rd   ÚedgeÚabsolute_distanceÚrelative_distanceÚmode)r�   Úcentroidc                 ó,  ‡— | j         t          k    rt          d¦  «        ‚| j        \  }}t	          j        | ¦  «        s<t          t          j        t          j	                 |  
                    ¦   «         ¦  «        S t          t          j        t          j                 |                      t          j        ¦  «        ¦  «        }t          j        ||¬¦  «        }t          |d         ¦  «        }	t          t          j        t          j                 |d         ¦  «        }
t          t          j        t          j                 |d         ¦  «        Št          t          j        t          j                 |d         ¦  «        }|	dk    r<t          t          j        t          j	                 |  
                    ¦   «         ¦  «        S ‰dd…t          j        f         }t          |                     ¦   «         ¦  «        }dt	          j        ||k    ¦  «        z   }t+          d„ |D ¦   «         ˆfd	„¬
¦  «        }|�5t-          t	          j        ||¦  «        ¦  «        }t-          |¦  «        |z  }n!|�t-          |¦  «        }nt1          d¦  «        ‚t	          j        |	t          ¬¦  «        }d||<   |dk    re|dd…         ||         z
  }t	          j        t	          j        |dz  d¬¦  «        ¦  «        }dt	          j        ||k    ¦  «        d         z   }d||<   nü|dk    rç|
|k    }t	          j        |¦  «        s|dk     rt	          j        |¦  «        }n`t	          j        |¦  «        rt	          j         |¦  «        }n7tC          |¦  «        }|                     t          j"        ¦  «        dz  }||k    }tG          d|	¦  «        D ]@}||k    rŒ	|
|k    }t	          j        |¦  «        sŒ$t	          j        ||z  ¦  «        rd||<   ŒAnt1          d¦  «        ‚||
         S )aš  
    Keep the largest connected component and any other components within a distance
    threshold.

    Distance can be absolute in pixels or relative to the image diagonal.

    Args:
        mask: Boolean mask HxW.
        absolute_distance: Max allowed distance in pixels to the main component.
            Ignored if `relative_distance` is provided.
        relative_distance: Fraction of the diagonal. If set, threshold = fraction * sqrt(H^2 + W^2).
        connectivity: Defines which neighboring pixels are considered connected.
            - 4-connectedness: Only orthogonal neighbors.
              ```
              [ ][X][ ]
              [X][O][X]
              [ ][X][ ]
              ```
            - 8-connectedness: Includes diagonal neighbors.
              ```
              [X][X][X]
              [X][O][X]
              [X][X][X]
              ```
            Default is 8.
        mode: Defines how distance between components is measured.
            - "edge": Uses distance between nearest edges (via distance transform).
            - "centroid": Uses distance between component centroids.

    Returns:
        Boolean mask after filtering.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> import supervision as sv
        >>> mask = np.array([
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        ... ], dtype=bool)
        >>> sv.filter_segments_by_distance(
        ...     mask,
        ...     absolute_distance=3,
        ...     mode="edge",
        ...     connectivity=8
        ... ).astype(int)
        array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])

        ```

        The nearby 2x2 block at columns 6-7 is kept because its edge distance
        is within 3 pixels. The distant block at columns 9-10 is removed.
    zmask must be booleanre   r   r   r    é   Nc              3   ó4   K  — | ]}t          |¦  «        V — Œd S r   ©r<   )r   Úlabels     r   r   z.filter_segments_by_distance.<locals>.<genexpr>Ù  s(   è è € Ð,Ð,˜�ˆU‰ŒÐ,Ð,Ð,Ð,Ð,Ð,r   c                 ób   •— t          ‰| df         ¦  «        t          ‰| df         ¦  «        | fS )Nr   r   r¥   )r¦   Ústatss    €r   ú<lambda>z-filter_segments_by_distance.<locals>.<lambda>Ú  s.   ø€ �3˜u U¨A XœÑ/Ô/µ°U¸5À!¸8´_Ñ1EÔ1EÀuÐM€ r   )Úkeyz:Either absolute_distance or relative_distance must be set.r/   Tr¡   ©r1   r�   i   z!mode must be 'edge' or 'centroid')$r   rl   Ú	TypeErrorr"   r   Úanyr   r4   r5   Úbool_Úcopyrg   rD   rj   ÚconnectedComponentsWithStatsr<   ri   r>   ÚCC_STAT_AREAr‡   Úflatnonzeror#   rC   Úhypotrf   r=   ÚsqrtrB   rˆ   Úisnanrh   ÚisposinfÚ	ones_liker›   Úfloat32r?   )r^   rž   rŸ   rb   r    rU   rV   ÚimageÚ
componentsÚ
num_labelsrn   rI   ÚareasÚmax_areaÚ
candidatesÚ
main_labelrŽ   Ú	thresholdÚkeep_labelsÚdifferencesr�   Únearbyrƒ   Únearby_mainÚfixed_distancesr¦   Ú	componentr¨   s                              @r   Úfilter_segments_by_distancerÇ   r  sŸ  ø€ ðb „z•TÒÐÝÐ.Ñ/Ô/Ð/à”J�M€FˆEÝŒ6�$‰<Œ<ð 8Ý•C”K¥¤Ô)¨4¯9ª9©;¬;Ñ7Ô7Ð7å•”�RœXÔ&¨¯ªµB´HÑ(=Ô(=Ñ>Ô>€EÝÔ1°%ÀlÐSÑSÔS€JÝ�Z ”]Ñ#Ô#€JÝ•#”+�bœhÔ'¨°A¬Ñ7Ô7€FÝ•”�RœXÔ&¨
°1¬Ñ6Ô6€EÝ•S”[¥¤Ô,¨j¸¬mÑ<Ô<€Ià�Q‚€Ý•C”K¥¤Ô)¨4¯9ª9©;¬;Ñ7Ô7Ð7à�!�"�"•cÔ&Ð&Ô'€EÝ�5—9’9‘;”;ÑÔ€HØ•R”^ E¨XÒ$5Ñ6Ô6Ñ6€JåØ,Ð, Ð,Ñ,Ô,ØMÐMÐMÐMðñ ô €Jð
 Ð$Ý�œ &¨%Ñ0Ô0Ñ1Ô1ˆÝÐ+Ñ,Ô,¨xÑ7ˆ	ˆ	Ø	Ð	&ÝÐ+Ñ,Ô,ˆ	ˆ	åÐUÑVÔVÐVå)+¬°*ÅDÐ)IÑ)IÔ)I€KØ"€K�
ÑàˆzÒÐØ   ”m i°
Ô&;Ñ;ˆÝ”G�BœF ;°¡>¸Ð:Ñ:Ô:Ñ;Ô;ˆ	Ø•R”X˜i¨9Ò4Ñ5Ô5°aÔ8Ñ8ˆØ"ˆ�FÑÐØ	�ŠˆØ˜jÒ(ˆ	ÝŒ8�IÑÔð 	1 )¨a¢- -Ýœ-¨	Ñ2Ô2ˆKˆKÝŒ[˜Ñ#Ô#ð 	1Ýœ, yÑ1Ô1ˆKˆKå0°Ñ;Ô;ˆOØ'×.Ò.­r¬zÑ:Ô:¸UÑBˆIØ# yÒ0ˆKÝ˜1˜jÑ)Ô)ð 	*ð 	*ˆEØ˜
Ò"Ð"ØØ %šˆIÝ”6˜)Ñ$Ô$ð ØÝŒv�k IÑ-Ñ.Ô.ð *Ø%)�˜EÑ"øð	*õ Ð<Ñ=Ô=Ð=à�vÔÐr   c                 ó|  — t          j        t          j        | d¬¦  «        ¦  «        }t          |¦  «        dk    rdS t          j        t          j        | d¬¦  «        ¦  «        }t	          |d         ¦  «        t	          |d         ¦  «        t	          |d         ¦  «        dz   t	          |d         ¦  «        dz   fS )a  Return exclusive ``(x1, y1, x2, y2)`` bounds for true mask pixels.

    Use this helper when you need NumPy slice semantics. Unlike
    :func:`~supervision.detection.utils.converters.mask_to_xyxy`, this
    function uses exclusive upper bounds (``+1``) and returns ``None`` for
    empty masks instead of zeros. The inclusive ``mask_to_xyxy`` convention
    stays in place for compatibility with CompactMask and box-based adapters.

    Args:
        mask: 2D boolean array of shape ``(H, W)``.

    Returns:
        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when the mask
        has no true pixels.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> from supervision.detection.utils.masks import mask_to_roi
        >>> mask = np.zeros((10, 10), dtype=bool)
        >>> mask[2:5, 3:6] = True
        >>> mask_to_roi(mask)
        (3, 2, 6, 5)

        ```
    r   r«   r   Nr…   )r   r²   r­   r   r<   )r^   ÚrowsÚcolss      r   Úmask_to_roirË     s•   € õ6 Œ>�"œ& ¨AÐ.Ñ.Ô.Ñ/Ô/€DÝ
ˆ4�y„y�A‚~€~ØˆtÝŒ>�"œ& ¨AÐ.Ñ.Ô.Ñ/Ô/€DÝˆt�AŒw‰<Œ<�˜T !œW™œ¥s¨4°¬8¡}¤}°qÑ'8½#¸dÀ2¼h¹-¼-È!Ñ:KÐKÐKr   Úimage_shapec                 ó$  — t          | ¦  «        dk    rdS |\  }}| j        }t          |dd…df                              ¦   «         ¦  «        }t          |dd…df                              ¦   «         ¦  «        }t          |dd…df                              ¦   «         ¦  «        dz   }t          |dd…df                              ¦   «         ¦  «        dz   }t	          d|¦  «        t	          d|¦  «        t          ||¦  «        t          ||¦  «        fS )uH  Return exclusive bounding-box union for compact masks.

    Uses crop metadata (offsets + shapes) â€” no RLE decode required.

    Args:
        masks: Compact mask collection.
        image_shape: Image dimensions as ``(height, width)``.

    Returns:
        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when empty.
    r   Nr   r    r£   )r   Ú	bbox_xyxyr<   r#   r‡   )	r
   rÌ   Úimage_hÚimage_wÚbboxesÚx_minÚy_minÚx_maxÚy_maxs	            r   Ú_compact_masks_to_roirÖ   *  s  € õ ˆ5�z„z�Q‚€ØˆtØ"Ñ€GˆWØŒ_€FÝ��q�q�q˜!�t”× Ò Ñ"Ô"Ñ#Ô#€EÝ��q�q�q˜!�t”× Ò Ñ"Ô"Ñ#Ô#€EÝ��q�q�q˜!�t”× Ò Ñ"Ô"Ñ#Ô# aÑ'€EÝ��q�q�q˜!�t”× Ò Ñ"Ô"Ñ#Ô# aÑ'€EåˆAˆu‰ŒÝˆAˆu‰ŒÝˆG�UÑÔÝˆG�UÑÔð	ð r   Úxyxyc                 ó‚  — t          | t          ¦  «        rt          | |¬¦  «        S t          j        | t
          ¬¦  «        }|j        dk    s|                     ¦   «         sdS |��(t          |¦  «        dk    �r|\  }}t          dt          t          j        |dd…df                              ¦   «         ¦  «        ¦  «        ¦  «        t          dt          t          j        |dd…df                              ¦   «         ¦  «        ¦  «        ¦  «        t          |t          t          j        |dd…df          	                    ¦   «         ¦  «        ¦  «        dz   ¦  «        t          |t          t          j        |dd…df          	                    ¦   «         ¦  «        ¦  «        dz   ¦  «        f}|\  }}}	}
||	k     rÒ||
k     rÌ|j        dk    r|nt          j        |d¬¦  «        }|||
…||	…f                              ¦   «         rz|d|…                              ¦   «         s^||
d…                              ¦   «         sB|||
…d|…f                              ¦   «         s"|||
…|	d…f                              ¦   «         s|S t          |¦  «        S |j        dk    r|}nt          j        |d¬¦  «        }t          |¦  «        S )	a«  Return exclusive true-pixel bounds for dense or compact masks.

    Args:
        masks: Dense boolean mask array of shape ``(N, H, W)`` or ``(H, W)``,
            or a :class:`~supervision.detection.compact_mask.CompactMask`.
        image_shape: Image dimensions as ``(height, width)``.
        xyxy: Optional detection boxes of shape ``(N, 4)`` in
            ``[x1, y1, x2, y2]`` format. When provided, the dense path
            first checks whether all true pixels fall within the box union;
            if so the box bounds are returned without a full pixel scan.

    Returns:
        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when no true
        pixels exist.
    )r
   rÌ   r/   r   Nr   r    r£   r«   )r9   r	   rÖ   r   Úasarrayrl   Úsizer­   r   r‡   r<   Úfloorr#   ÚndimrË   )r
   rÌ   r×   r$   rÏ   rÐ   Úbox_roirM   rN   Úx2Úy2Úunions               r   Ú_masks_to_roirá   I  sŸ  € õ( �%�Ñ%Ô%ð KÝ$¨5¸kÐJÑJÔJÐJÝ”˜E­Ð.Ñ.Ô.€JØ„˜!ÒÐ :§>¢>Ñ#3Ô#3ÐØˆtð Ñ�C ™IœI¨šM™MØ&Ñˆ�å�•3•r”x  Q Q Q¨ T¤
§¢Ñ 0Ô 0Ñ1Ô1Ñ2Ô2Ñ3Ô3Ý�•3•r”x  Q Q Q¨ T¤
§¢Ñ 0Ô 0Ñ1Ô1Ñ2Ô2Ñ3Ô3Ý���RœX d¨1¨1¨1¨a¨4¤j§n¢nÑ&6Ô&6Ñ7Ô7Ñ8Ô8¸1Ñ<Ñ=Ô=Ý���RœX d¨1¨1¨1¨a¨4¤j§n¢nÑ&6Ô&6Ñ7Ô7Ñ8Ô8¸1Ñ<Ñ=Ô=ð	
ˆð !‰ˆˆB��BØ�Š7ˆ7�r˜B’w�wØ",¤/°QÒ"6Ð"6�J�J½B¼FÀ:ÐTUÐ<VÑ<VÔ<VˆEð �b˜�e˜R ˜U�lÔ#×'Ò'Ñ)Ô)ðà˜c˜r˜cœ
ŸšÑ(Ô(ðð ˜b˜c˜cœ
ŸšÑ(Ô(ðð ˜b ˜e S b S˜jÔ)×-Ò-Ñ/Ô/ð	ð
 ˜b ˜e R S S˜jÔ)×-Ò-Ñ/Ô/ðð �Ý˜uÑ%Ô%Ð%Ø„˜!ÒÐØˆˆå”�z¨Ð*Ñ*Ô*ˆÝ�uÑÔÐr   )ra   )rr   )rœ   Nrd   r�   r   )%Útypingr   r   r   Únumpyr   Únumpy.typingr4   Úsupervisionr   rj   Úsupervision._cv2._componentsr   Ú"supervision.detection.compact_maskr	   r5   r®   r   r   ÚintegerrE   r<   r-   r:   r]   rl   r`   rq   r‚   r›   rC   rÇ   rË   Ú_mask_to_roirÖ   Únumberrá   © r   r   ú<module>rì      så  ðØ %Ð %Ð %Ð %Ð %Ð %Ð %Ð %Ð %Ð %à Ð Ð Ð Ø Ð Ð Ð Ð Ð à #Ð #Ð #Ð #Ð #Ð #Ø 8Ð 8Ð 8Ð 8Ð 8Ð 8Ø :Ð :Ð :Ð :Ð :Ð :ð˜Sœ[¨¬Ô2ð °s´{À2Ä8Ô7Lð ð ð ð ð:KØŒ;�r”xÔ ðKàŒK˜œ
Ô#ðKð ˜˜c˜”?ðKð 	„[�”Ôð	Kð Kð Kð Kð\EØŒ;�r”xÔ  ;Ñ.ðEà„[�”ÔðEð Eð Eð EðP'!˜œ R¤XÔ.ð '!°4ð '!ð '!ð '!ð '!ðV 67ð;&ð ;&Ø
Œ+�b”hÔ
ð;&Ø/2ð;&à	ð;&ð ;&ð ;&ð ;&ð~ 8;ðHð HØŒ;�r”xÔ ðHØ14ðHà„[�”ÔðHð Hð Hð Hð@) #¤+¨b¬hÔ"7ð )¸C¼KÈÌÔ<Qð )ð )ð )ð )ð\ ',Ø&*ØØ(.ðPð PØ
Œ+�b”hÔ
ðPà˜t‘|ðPð ˜t‘|ðPð ð	Pð
 Ð$Ô
%ðPð 	„[�”ÔðPð Pð Pð PðfL�c”k "¤(Ô+ð L°°c¸3ÀÀSÐ6HÔ0IÈDÑ0Pð Lð Lð Lð LðD €ðØðà�s˜C�x”ðð ˆ3��S˜#ÐÔ Ñ%ðð ð ð ðD +/ð6ð 6Ø˜œ SÔ)Ñ)ð6à�s˜C�x”ð6ð Œ+�b”iÔ
  4Ñ
'ð6ð ˆ3��S˜#ÐÔ Ñ%ð	6ð 6ð 6ð 6ð 6ð 6r   