^j JddlmZddlZddlZddlmZddlmZmZddl m Z ddl Z ddl m ZddlmZddlmZddlmZdd lmZmZdd lmZmZdd lmZdd lmZdd lm Z m!Z!ddl"m#Z# d ddZ$GddZ%y)) annotationsN)Callable)ThreadPoolExecutor as_completed)Any)ORIENTED_BOX_COORDINATES) CompactMask) Detections) move_boxesmove_oriented_boxes) OverlapFilter OverlapMetric) move_masks) ImageType) crop_imageget_image_resolution_wh)SupervisionWarningsct|j||_t|jvr/t |jt||jt<|j | t dt|j trE|j jt|dt|d|d|df|_|St|j |||_|S)a^ Args: detections: Detections object to be moved. offset: An array of shape `(2,)` containing offset values in the format `[dx, dy]`. resolution_wh: The width and height of the desired mask resolution. Required for segmentation detections. Returns: Repositioned Detections object. )xyxyoffset)xyxyxyxyrzResolution width and height are required for moving segmentation detections. This should be the same as (width, height) of image shape.r)dxdynew_image_shape)masksr resolution_wh) r rrdatar mask ValueError isinstancer with_offsetintr detectionsrrs w/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/supervision/detection/tools/inference_slicer.pymove_detectionsr's !joofEJO:??24G__%=>v5 01"  Y  joo{ 3(oo99vay>vay>!.q!1=3C D:JO ) oofMJO ceZdZdZddej dejddf ddZddZ dd Z e dd Z e dd Z e dd Ze dd Zy)InferenceSliceruN Perform tiled inference on large images by slicing them into overlapping patches. This class divides an input image into overlapping slices of configurable size and overlap, runs inference on each slice through a user-provided callback, and merges the resulting detections. The slicing process allows efficient processing of large images with limited resources while preserving detection accuracy via configurable overlap and post-processing of overlaps. Uses multi-threading for parallel slice inference. Args: callback: Inference function that takes a sliced image and returns a `Detections` object. slice_wh: Size of each slice `(width, height)`. If int, both width and height are set to this value. overlap_wh: Overlap size `(width, height)` between slices. If int, both width and height are set to this value. overlap_filter: Strategy to merge overlapping detections (`NON_MAX_SUPPRESSION`, `NON_MAX_MERGE`, or `NONE`). iou_threshold: IOU threshold used in merging overlap filtering. overlap_metric: Metric to compute overlap (`IOU` or `IOS`). thread_workers: Number of threads for concurrent slice inference. Must be a positive integer. When the first slice returns oriented bounding boxes (OBB), Supervision probes additional slices until a non-empty result is found, then falls back to sequential processing for all remaining slices to avoid thread-safety issues in common OBB inference backends. Note: the first slice always runs synchronously regardless of this setting, so for grids with few slices (e.g. two-slice images) effective parallelism is reduced. compact_masks: If ``True``, dense ``(N, H, W)`` boolean mask arrays returned by the callback are immediately converted to a :class:`~supervision.detection.compact_mask.CompactMask`. This keeps masks in run-length-encoded form for the entire pipeline — merge, NMS, and annotation — avoiding the large ``(N, H, W)`` allocations that cause OOM on high-resolution images with many objects. IoU and NMS are computed directly on the RLE crops without ever materialising a full ``(N, H, W)`` array. Defaults to ``False`` for backward compatibility. Raises: ValueError: If `slice_wh`, `overlap_wh`, or `thread_workers` are invalid or inconsistent. Example: ```python import cv2 import supervision as sv from rfdetr import RFDETRMedium model = RFDETRMedium() def callback(tile): return model.predict(tile) slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100) image = cv2.imread("example.png") detections = slicer(image) ``` ```python import supervision as sv from PIL import Image from ultralytics import YOLO model = YOLO("yolo11m.pt") def callback(tile): results = model(tile)[0] return sv.Detections.from_ultralytics(results) slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100) image = Image.open("example.png") detections = slicer(image) ``` idg?rFc |j|} |j|} |j| | |dkrtd|| |_| |_||_tj||_ tj||_ ||_ ||_ ||_d|_t!j"|_d|_t!j"|_y)N)slice_wh overlap_whrz7`thread_workers` must be a positive integer. Received: F)_normalize_slice_wh_normalize_overlap_wh_validate_overlapr r-r. iou_thresholdr from_valueoverlap_metricr overlap_filtercallbackthread_workers compact_masks_out_of_slice_bounds_warned threadingLock_out_of_slice_bounds_lock_obb_thread_workers_warned_obb_thread_workers_lock) selfr6r-r.r5r2r4r7r8 slice_wh_normoverlap_wh_norms r&__init__zInferenceSlicer.__init__s00: 44Z@  /R A +,.  & )*+66~F+66~F;C ,*16()2)9&05'(1(8%r(c g}t|}|j||j|j}|d}|j ||}|j ||dd}t |jv}|jdkxs|} d} | s~t|dk(rp| t|krb|| } |j || } |j | | dz } t | jvrd}d} nt| dkDrn| t|krb|| d}| r~|jdkDrF|rD|j5|js#d|_ tjdtdddd|D]#} |j |j || %nyt|j 5}|D cgc]} |j!|j|| !}} t#|D]!}|j |j%# dddt'j(| }|j*t,j.k(r|S|j*t,j0k(r'|j3|j4|j6 S|j*t,j8k(r'|j;|j4|j6 Stjd |j*t |S#1swYxYwcc} w#1swYxYw)a Perform tiled inference on the full image and return merged detections. The first slice always runs synchronously so the output type can be inspected before committing to a threading strategy. Detections are merged in a deterministic order: the first slice is always at index 0, followed by any probe slices, then the remaining slices in source order. If oriented bounding boxes are detected, all remaining slices are processed sequentially and a ``SupervisionWarnings`` warning is emitted once per slicer instance. Args: image: The full image to run inference on. Returns: Merged detections across all slices. )rr-r.rrNTzInferenceSlicer detected oriented bounding boxes while `thread_workers > 1`. Remaining slices will be processed sequentially because many OBB inference backends are not thread-safe and can crash when shared across threads.category stacklevel) max_workers)detections_list) thresholdr4z!Invalid overlap filter strategy: )rF)r_generate_offsetr-r. _run_callbackappendrrr7lenr>r=warningswarnrrsubmitrresultr merger5r NONENON_MAX_SUPPRESSIONwith_nmsr2r4 NON_MAX_MERGEwith_nmm)r?imagerIroffsets first_offsetfirst_detectionsremaining_offsets obb_detectedshould_run_sequentially probe_index probe_offsetprobe_detectionsrexecutorfuturesfuturemergeds r&__call__zInferenceSlicer.__call__s$-//6 ''']](  qz --e\B/0#ABK/3C3H3HH "&"5"5":"Jl &3/?+@A+E$5 660= #'#5#5e\#J &&'78q +/?/D/DD#'L.2+'(1,$5 66.kl; """Q&<22 :::>7 T&9'(  , J&&t'9'9%'HI J$0C0CD <#4OOD$6$6vF+73InferenceSlicer._generate_offset.._compute_axis_startss Z's #BIIaV<CCEFF#j0J $RYYq*f%E%L%L%N OFVBZ:5 j)Mr()rrrrr)axis)rr#rr#rr#returnz list[int])rkmeshgridclipstackreshape)rr-r.rsrt image_width image_height overlap_widthoverlap_heightstride_xstride_yrx_startsy_startsx_miny_minx_maxy_maxrZs r&rKz InferenceSlicer._generate_offsets$%-! \$1! \(2% ~..0      "(""  (##  {{8X6 u +Q < ,a>$&HH E5% (%  '"a.  r(c|\}}|\}}|dks|dkrtd|||k\s||k\rtd|d|dy)Nrz=Overlap values must be greater than or equal to 0. Received: zo`overlap_wh` must be smaller than `slice_wh` in both dimensions to keep a positive stride. Received overlap_wh=z , slice_wh=.)r )r-r.rrrprqs r&r1z!InferenceSlicer._validate_overlaps * 9# q=IM'L*   9#7BBLN$:Q( $8r(N)r6z!Callable[[ImageType], Detections]r-int | tuple[int, int]r.rr5zOverlapFilter | strr2floatr4zOverlapMetric | strr7r#r8bool)rYrrr )rYrrnpt.NDArray[Any]rr )r-rrtuple[int, int])r.rrr)rrr-rr.rrr)r-rr.rrNone)__name__ __module__ __qualname____doc__r rUrIOUrBrgrL staticmethodr/r0rKr1r(r&r*r*@s<Lb+.,/.;.O.O".;.?.?#!93!9(!9* !9 , !9  !9,!9!9!9F_B<| '   0 )   2=&=!=$=  ==~!# r(r*)N)r%r rrrztuple[int, int] | Nonerr )& __future__rr:rOcollections.abcrconcurrent.futuresrrtypingrnumpyrk numpy.typingnptsupervision.configr"supervision.detection.compact_maskr supervision.detection.corer !supervision.detection.utils.boxesr r 'supervision.detection.utils.iou_and_nmsr r!supervision.detection.utils.masksrsupervision.draw.basersupervision.utils.imagerrsupervision.utils.internalrr'r*rr(r&rss"$?7:1MP8+G: -1&& &*& &RWWr(