FPh zddlZddlZddlZddlZddlZddlZddlZddlm cm Z ddl Z ddl mZGddejZd#dZd$dZdZ d%dZd Zd Zd&d Zd Zd Zd'dZd(dZdZdZdZdZdZ dZ!dZ"d)dZ#dZ$dZ%d*dZ&dZ'd+dZ(d,dZ)d-dZ*dejVd ejXfd!Z-d"Z.y).N)LOGGERc0eZdZdZddZdZdZdZdZy) Profilea\ YOLOv8 Profile class. Use as a decorator with @Profile() or as a context manager with 'with Profile():'. Example: ```python from ultralytics.utils.ops import Profile with Profile() as dt: pass # slow operation here print(dt) # prints "Elapsed time is 9.5367431640625e-07 s" ``` cX||_tjj|_y)zt Initialize the Profile class. Args: t (float): Initial time. Defaults to 0.0. N)ttorchcuda is_available)selfrs `C:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\ultralytics/utils/ops.py__init__zProfile.__init__ sJJ++- c0|j|_|S)z Start timing.)timestartr s r __enter__zProfile.__enter__*sYY[  rc|j|jz |_|xj|jz c_y)z Stop timing.N)rrdtr)r typevalue tracebacks r __exit__zProfile.__exit__/s*))+ * $''rc"d|jdS)zZReturns a human-readable string representing the accumulated elapsed time in the profiler.zElapsed time is z s)rrs r __str__zProfile.__str__4s!$&&,,rc~|jrtjjtjS)zGet current time.)r r synchronizerrs r rz Profile.time8s% 99 JJ " " $yy{rN)) __name__ __module__ __qualname____doc__r rrrrrr rrs  .  -rrct|j\}}|dk\|dk\z||kz||kz}||||}}t|r]tj|j |j |j |j g|j Stjd|j S)a Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy). Args: segment (torch.Tensor): the segment label width (int): the width of the image. Defaults to 640 height (int): The height of the image. Defaults to 640 Returns: (np.ndarray): the minimum and maximum x and y values of the segment. rdtype)Tanynparrayminmaxr&zeros)segmentwidthheightxyinsides r segment2boxr5?s 99DAq1fa AJ /1; ?F fIqyqARUVWRX288QUUWaeegquuw8 N ^`^f^f _  rcd|Yt|d|dz |d|dz }t|d|d|zz dz dz t|d|d|zz dz dz f}n |dd}|d}|r(|dddgfxx|dzcc<|dddgfxx|dzcc<|dddfxx|zcc<t|||S) a Rescales bounding boxes (in the format of xyxy) from the shape of the image they were originally specified in (img1_shape) to the shape of a different image (img0_shape). Args: img1_shape (tuple): The shape of the image that the bounding boxes are for, in the format of (height, width). boxes (torch.Tensor): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2) img0_shape (tuple): the shape of the target image, in the format of (height, width). ratio_pad (tuple): a tuple of (ratio, pad) for scaling the boxes. If not provided, the ratio and pad will be calculated based on the size difference between the two images. padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular rescaling. Returns: boxes (torch.Tensor): The scaled bounding boxes, in the format of (x1, y1, x2, y2) Nrg?.r')r,round clip_boxes) img1_shapeboxes img0_shape ratio_padpaddinggainpads r scale_boxesrCSs":a=:a=0*Q-*Q-2OPZ]Z]T%99Q>DEu ]Z]T1 1Q 6 <H>>|Al cAq6kc!f$ cAq6kc!f$ #rr'NdNuj! Lrct|tjrt|j }t j ||z |zS)a Returns the nearest number that is divisible by the given divisor. Args: x (int): The number to make divisible. divisor (int | torch.Tensor): The divisor. Returns: (int): The nearest number divisible by the divisor. ) isinstancerTensorintr-mathceil)r2divisors r make_divisiblerKts:'5<<(gkkm$ 99Q[ !G ++rc  d|cxkrdks nJd|dd|cxkrdks nJd|dt|ttfr|d}|j} d| jv} | r|j }|j d}|xs|j ddz }|j d|z dz }d|z}|ddd|fjd|kD}d | |zz}||dkDz}|jd d }t|d ddf|d ddf<tj}tjdd |zf|jg|z}t|D]\}}|||}|rt||r||}tjt|||zdzf|j}t|ddddf|ddddf<d|tt||dddfj!dzf<tj"||fd}|j ds|j%d||fd\}}}|rZtj&||kD\}}tj"||||d|zdf|dddfj)||fd}nS|j+dd\}}tj"|||j)|fd|j-d |kD}|?||dddd ftj.||jk(j1d}|j d}|s|| kDr||dddfj3dd| }|dddd f|rdn| z} |ddddf| z|dddf}"}!t4j6j9|!|"|}|d|}||||<| r||j;| ||<tj|z |kDst=j>d|dd|S|S)a Perform non-maximum suppression (NMS) on a set of boxes, with support for masks and multiple labels per box. Args: prediction (torch.Tensor): A tensor of shape (batch_size, num_classes + 4 + num_masks, num_boxes) containing the predicted boxes, classes, and masks. The tensor should be in the format output by a model, such as YOLO. conf_thres (float): The confidence threshold below which boxes will be filtered out. Valid values are between 0.0 and 1.0. iou_thres (float): The IoU threshold below which boxes will be filtered out during NMS. Valid values are between 0.0 and 1.0. classes (List[int]): A list of class indices to consider. If None, all classes will be considered. agnostic (bool): If True, the model is agnostic to the number of classes, and all classes will be considered as one. multi_label (bool): If True, each box may have multiple labels. labels (List[List[Union[int, float, torch.Tensor]]]): A list of lists, where each inner list contains the apriori labels for a given image. The list should be in the format output by a dataloader, with each label being a tuple of (class_index, x1, y1, x2, y2). max_det (int): The maximum number of boxes to keep after NMS. nc (int, optional): The number of classes output by the model. Any indices after this will be considered masks. max_time_img (float): The maximum time (seconds) for processing one image. max_nms (int): The maximum number of boxes into torchvision.ops.nms(). max_wh (int): The maximum box width and height in pixels Returns: (List[torch.Tensor]): A list of length batch_size, where each element is a tensor of shape (num_boxes, 6 + num_masks) containing the kept boxes, with columns (x1, y1, x2, y2, confidence, class, mask1, mask2, ...). rr7zInvalid Confidence threshold z&, valid values are between 0.0 and 1.0z Invalid IoU mpsr'N?.)deviceg?T)keepdim) descendinguWARNING ⚠️ NMS time limit z.3fz s exceeded) rElisttuplerRrcpushapeamax transpose xywh2xyxyrrr. enumeratelenrangelongcatsplitwherefloatr-viewtensorr)argsort torchvisionopsnmstorwarning)# prediction conf_thres iou_thresclassesagnostic multi_labellabelsmax_detnc max_time_imgmax_nmsmax_whrRrMbsnmmixc time_limitroutputxir2lbvboxclsmaskijconfncr=scoress# r non_max_suppressionrsOZ a s#@ Lr!ss  Q `,yk9_ `` *tUm,]   F 6;; C ^^%   ! B (   #a'B   ! r !A %B RB AqtG  ! !! $z 1B|b((J26K%%b"-J#JsBQBw$78JsBQBw Akk1a"f+j.?.?@ AB FF:&A bfI c&*oB SWb2gk2188DA AqsF,Aa!eH58AeCGnbAhmmo11 2 1a&!$Awwqz !Ra0S$ ;;sZ/0DAq 3q61QAt^#4a4j6F6F6H$q'RTUVAggag.GD! 3aggi6:499R=:;UVA  1Q!V9 WQXX FFKKANOA GGAJ  w;!AqD'//T/28G<=A a1fIhF 3!RaR%1 a1gv OO  vy 9 hwKqTr v.F2J IIK!Oz ) NN;Js;K:V W  M'~ Mrct|tjra|djd|d|djd|d|djd|d|djd|dy |dddgfj d|d|dddgf<|ddd gfj d|d|ddd gf<y ) z Takes a list of bounding boxes and a shape (height, width) and clips the bounding boxes to the shape. Args: boxes (torch.Tensor): the bounding boxes to clip shape (tuple): the shape of the image .rrr7.r7.r8.r9.r8r9NrErrFclamp_clip)r=rYs r r;r; s%& f Qa) f Qa) f Qa) f Qa)"3A;/44QaAcAq6k"3A;/44QaAcAq6krct|tjr1|djd|d|djd|dy|dj d|d|d<|dj d|d|d<y)a Clip line coordinates to the image boundaries. Args: coords (torch.Tensor | numpy.ndarray): A list of line coordinates. shape (tuple): A tuple of integers representing the size of the image in the format (height, width). Returns: (None): The function modifies the input `coordinates` in place, by clipping each coordinate to the image boundaries. rrr7rNr)coordsrYs r clip_coordsrs~&%,,'vaq*vaq*,,Qa9v,,Qa9vrcl|j}|dd|ddk(r|S|At|d|dz |d|dz }|d|d|zz dz |d|d|zz dz f}n |dd}|d}t|dt|d}}t|d|dz t|d|dz } }t|jdkr!t dt|j||||| f}t j ||d|df}t|jdk(r |dddddf}|S)ao Takes a mask, and resizes it to the original image size. Args: masks (np.ndarray): resized and padded masks/images, [h, w, num]/[h, w, 3]. im0_shape (tuple): the original image shape ratio_pad (tuple): the ratio of the padding to the original image. Returns: masks (torch.Tensor): The masks that are being returned. Nr8rr7z/"len of masks shape" should be 2 or 3, but got )rYr,rGr^ ValueErrorcv2resize) masks im0_shaper? im1_shaperArBtopleftbottomrights r scale_imager1sq I!} "1 % 9Q<)A,. ! y|0KL|ilT11Q61 RS W[H[9[_`8``|AlCF SQ[C ! s1v-.IaL3q64I0JEF 5;;!J3u{{K[J\]^^ #f*d5j( )E JJuy|Yq\: ;E 5;;1aDj! LrcV|jddk(sJd|jt|tjrtj|nt j|}|d|dzdz |d<|d|dzdz |d<|d|dz |d<|d|dz |d<|S) a Convert bounding box coordinates from (x1, y1, x2, y2) format to (x, y, width, height) format where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner. Args: x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x1, y1, x2, y2) format. Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in (x, y, width, height) format. rOr'9input shape last dimension expected 4 but input shape is rrr8rrrYrErrF empty_liker*r2r3s r xyxy2xywhrTs 772;! bXYZY`Y`Xabb )!U\\: a@PA6QvY&!+AfI6QvY&!+AfI& AfI%AfI& AfI%AfI HrcR|jddk(sJd|jt|tjrtj|nt j|}|ddz }|ddz }|d|z |d<|d|z |d<|d|z|d<|d|z|d<|S) a Convert bounding box coordinates from (x, y, width, height) format to (x1, y1, x2, y2) format where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner. Args: x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x, y, width, height) format. Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in (x1, y1, x2, y2) format. rOr'rrr8rrrr)r2r3dwdhs r r\r\hs 772;! bXYZY`Y`Xabb )!U\\: a@PA 6QB 6QB& BAfI& BAfI& BAfI& BAfI Hrc|jddk(sJd|jt|tjrtj|nt j|}||d|ddz z z|z|d<||d|ddz z z|z|d<||d|ddz zz|z|d<||d|ddz zz|z|d<|S) aF Convert normalized bounding box coordinates to pixel coordinates. Args: x (np.ndarray | torch.Tensor): The bounding box coordinates. w (int): Width of the image. Defaults to 640 h (int): Height of the image. Defaults to 640 padw (int): Padding width. Defaults to 0 padh (int): Padding height. Defaults to 0 Returns: y (np.ndarray | torch.Tensor): The coordinates of the bounding box in the format [x1, y1, x2, y2] where x1,y1 is the top-left corner, x2,y2 is the bottom-right corner of the bounding box. rOr'rrrr8rrr)r2whpadwpadhr3s r xywhn2xyxyr~s 772;! bXYZY`Y`Xabb )!U\\: a@PAQvY6Q./$6AfIQvY6Q./$6AfIQvY6Q./$6AfIQvY6Q./$6AfI Hrc|rt|||z ||z f|jddk(sJd|jt|tjrtj |nt j |}|d|dzdz |z |d<|d|dzdz |z |d<|d|dz |z |d<|d|dz |z |d<|S) a Convert bounding box coordinates from (x1, y1, x2, y2) format to (x, y, width, height, normalized) format. x, y, width and height are normalized to image dimensions. Args: x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x1, y1, x2, y2) format. w (int): The width of the image. Defaults to 640 h (int): The height of the image. Defaults to 640 clip (bool): If True, the boxes will be clipped to the image boundaries. Defaults to False eps (float): The minimum value of the box's width and height. Defaults to 0.0 Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in (x, y, width, height, normalized) format rOr'rrrr8rr)r;rYrErrFrr*)r2rrrepsr3s r xyxy2xywhnrs 1q3wC() 772;! bXYZY`Y`Xabb )!U\\: a@PAF)ai'1,1AfIF)ai'1,1AfI6QvY&!+AfI6QvY&!+AfI Hrct|tjr|jnt j |}|d|ddz z |d<|d|ddz z |d<|S)aX Convert the bounding box format from [x, y, w, h] to [x1, y1, w, h], where x1, y1 are the top-left coordinates. Args: x (np.ndarray | torch.Tensor): The input tensor with the bounding box coordinates in the xywh format Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in the xyltwh format rrr8rrrErrFcloner*copyrs r xywh2ltwhr_ 5<<0 bggajA& AfIM)AfI& AfIM)AfI Hrct|tjr|jnt j |}|d|dz |d<|d|dz |d<|S)aU Convert nx4 bounding boxes from [x1, y1, x2, y2] to [x1, y1, w, h], where xy1=top-left, xy2=bottom-right. Args: x (np.ndarray | torch.Tensor): The input tensor with the bounding boxes coordinates in the xyxy format Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in the xyltwh format. rrrrrrs r xyxy2ltwhrW 5<<0 bggajA& AfI%AfI& AfI%AfI Hrct|tjr|jnt j |}|d|ddz z|d<|d|ddz z|d<|S)z Convert nx4 boxes from [x1, y1, w, h] to [x, y, w, h] where xy1=top-left, xy=center. Args: x (torch.Tensor): the input tensor Returns: y (np.ndarray | torch.Tensor): The bounding box coordinates in the xywh format. rrr8rrrrs r ltwh2xywhrrrc2t|tj}|r tjtjfnt j t jf\}}|j\}}}}}} } } ||zdz } || zdz } ||z }||z }||dz|dzz}|||z dz|| z dzz}|| |}|dtjz z}|r$tj| | |||fjSt j| | |||fdS)a9 Convert batched Oriented Bounding Boxes (OBB) from [xy1, xy2, xy3, xy4] to [xywh, rotation]. Args: corners (numpy.ndarray | torch.Tensor): Input corners of shape (n, 8). Returns: (numpy.ndarray | torch.Tensor): Converted data in [cx, cy, w, h, rotation] format of shape (n, 5). r8f@r7dim) rEr*ndarrayarctan2sqrtratan2r(rHpivstackstack)cornersis_numpyrrx1y1x2y2x3y3x4y4cxcydx21dy21rrrotations r xyxyxyxy2xywhrrs'2::.H+32::rww'%++uzz9RKE4%,YY"BBBB r'QB r'QB 7D 7D TQY "#A b2g!^rBw1n ,-AdUD!H H4<299b"aH- . 0 0n%++rSUWXZ[]eNflmBnnrc |t|tj}|r tjtjfnt jt jf\}}|j \}}}}}|tjdz z}|dz } |dz } ||} ||} | | z} | | z}| | z}| | z}|| z |z }||z|z }|| z|z }||z |z }|| z|z}||z |z}|| z |z}||z|z}|r'tj||||||||fj St j||||||||fdS)a> Convert batched Oriented Bounding Boxes (OBB) from [xywh, rotation] to [xy1, xy2, xy3, xy4]. Args: center (numpy.ndarray | torch.Tensor): Input data in [cx, cy, w, h, rotation] format of shape (n, 5). Returns: (numpy.ndarray | torch.Tensor): Converted corner points of shape (n, 8). rr8r7r) rEr*rcossinrr(rHrrr)centerrrrrrrrrdxdycos_rotsin_rot dx_cos_rot dx_sin_rot dy_cos_rot dy_sin_rotrrrrrrrrs r xywhr2xyxyxyxyrsj&"**-H#+%))UYY1GHC#XXBAq( %H QB QB(mG(mGgJgJgJgJ j: %B j: %B j: %B j: %B j: %B j: %B j: %B j: %B 2 KK3q6A:q ) YYs1v nnq%RAbii2qAw&?%R+-::77>wq"~aa  $ O&Ss%C. cr|j\}}}tj|dddddfdd\}}}}tj||j|j ddddf} tj||j|j ddddf} || |k\| |kz| |k\z| |kzzS)aV It takes a mask and a bounding box, and returns a mask that is cropped to the bounding box. Args: masks (torch.Tensor): [n, h, w] tensor of masks boxes (torch.Tensor): [n, 4] tensor of bbox coordinates in relative point form Returns: (torch.Tensor): The masks are being cropped to the bounding box. Nr'r7)rRr&)rYrchunkrrRr&) rr=rrrrrrrrrs r crop_maskrWskkGAq![[q!Tz!2Aq9NBB Qu||288rc|j\}}}|\}} ||jj|dzjjd||} |j } | dddfxx|| z zcc<| dddfxx|| z zcc<| dddfxx||z zcc<| dddfxx||z zcc<t | | } |rt j| d|dd d} | jd S) a; Apply masks to bounding boxes using the output of the mask head. Args: protos (torch.Tensor): A tensor of shape [mask_dim, mask_h, mask_w]. masks_in (torch.Tensor): A tensor of shape [n, mask_dim], where n is the number of masks after NMS. bboxes (torch.Tensor): A tensor of shape [n, 4], where n is the number of masks after NMS. shape (tuple): A tuple of integers representing the size of the input image in the format (h, w). upsample (bool): A flag to indicate whether to upsample the mask to the original image size. Default is False. Returns: (torch.Tensor): A binary mask tensor of shape [n, h, w], where n is the number of masks after NMS, and h and w are the height and width of the input image. The mask is applied to the bounding boxes. rONrr8r9r7rFrrN) rYrdrerrrrrr) rrr rYupsamplerr r ihiwrdownsampled_bboxess r process_maskrs  IAr2 FB  ++Ar2 2 ; ; = B B2r2 NEq!tR'q!tR'q!tR'q!tR' e/ 0E eDk5zQVWXYZ 99S>rc|j\}}}||jj|dzjjd||}t |d|d}t ||}|j dS)a It takes the output of the mask head, and crops it after upsampling to the bounding boxes. Args: protos (torch.Tensor): [mask_dim, mask_h, mask_w] masks_in (torch.Tensor): [n, mask_dim], n is number of masks after nms bboxes (torch.Tensor): [n, 4], n is number of masks after nms shape (tuple): the size of the input image (h,w) Returns: masks (torch.Tensor): The returned masks with dimensions [h, w, n] rONrrN)rYrdrer scale_masksrrrs r process_mask_nativersw IAr2  ++Ar2 2 ; ; = B B2r2 NE d U +A .E eV $E 99S>rc|jdd\}}t||dz ||dz }||d|zz ||d|zz g}|r|dxxdzcc<|dxxdzcc<|rt|dt|dfnd\}}t||dz t||dz } } |d|| || f}tj||dd }|S) a Rescale segment masks to shape. Args: masks (torch.Tensor): (N, C, H, W). shape (tuple): Height and width. padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular rescaling. r8Nrr7)rr.rFr)rYr,rGrr) rrYr@r r rArBrrrrs r rrs[[_FB rE!H}b58m ,D a4 eAho!5 6C A!  A! .5SVc#a&k*6ICc!f%s2A;'7EF #s6z4:- .E MM%Zu ME Lrcz|At|d|dz |d|dz }|d|d|zz dz |d|d|zz dz f}n |dd}|d}|r |dxx|dzcc<|dxx|dzcc<|dxx|zcc<|dxx|zcc<t|||r |dxx|dzcc<|dxx|dzcc<|S)a Rescale segment coordinates (xy) from img1_shape to img0_shape. Args: img1_shape (tuple): The shape of the image that the coords are from. coords (torch.Tensor): the coords to be scaled of shape n,2. img0_shape (tuple): the shape of the image that the segmentation is being applied to. ratio_pad (tuple): the ratio of the image size to the padded image size. normalize (bool): If True, the coordinates will be normalized to the range [0, 1]. Defaults to False. padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular rescaling. Returns: coords (torch.Tensor): The scaled coordinates. rr7r8rr)r,r)r<rr>r? normalizer@rArBs r scale_coordsrs :a=:a=0*Q-*Q-2OP!}z!}t33q8:a=:VW=[_K_;_cd:dd|Alv#a& v#a&  6NdN 6NdN #v*Q-'v*Q-' Mrc g}|jjjjdD]}t j |tj tjd}|r|dk(r4tj|Dcgc]}|jddc}}n{|dk(rvtj|tj|Dcgc] }t|c}jjdd}ntjd}|j|jd|Scc}wcc}w) aB It takes a list of masks(n,h,w) and returns a list of segments(n,xy) Args: masks (torch.Tensor): the output of the model, which is a tensor of shape (batch_size, 160, 160) strategy (str): 'concat' or 'largest'. Defaults to largest Returns: segments (List): list of segment masks uint8rconcatrOr8largest)rr8r)rGrXnumpyastyper findContours RETR_EXTERNALCHAIN_APPROX_SIMPLEr*rrr+r^argmaxr.r)rstrategyrr2rs r masks2segmentsr%sH YY[__  $ $ & - -g 6   Q 1 133J3J KA N 8#NNa#@aAIIb!$4a#@AY&HHQrxx(;AQ(;<CCEFGOOPRTUV A+,7 O $A(;s E Ebatchreturnc|jddddjdzjddjtj j jS)as Convert a batch of FP32 torch tensors (0.0-1.0) to a NumPy uint8 array (0-255), changing from BCHW to BHWC layout. Args: batch (torch.Tensor): Input tensor batch of shape (Batch, Channels, Height, Width) and dtype torch.float32. Returns: (np.ndarray): Output NumPy array batch of shape (Batch, Height, Width, Channels) and dtype uint8. rr8r9r7)permute contiguousclamprkrrrXr)r&s r convert_torch2numpy_batchr-sU MM!Q1 % 0 0 2S 8 ? ?3 G J J5;; W [ [ ] c c eerc2tjdd|S)z Cleans a string by replacing special characters with underscore _ Args: s (str): a string needing special characters replaced Returns: (str): a string with special characters replaced by an underscore _ u"[|@#!¡·$€%&()=?¿^*;:,¨´><+]_)patternreplstring)resub)rs r clean_strr5s 66>SQR SSr)r6)NT) g?g?NFFr#i,rg?i0ui)N)r6r6rr)r6r6Fr)i)F)T)NFT)r)/ contextlibrHr3rrrr*rtorch.nn.functionalnn functionalrrhultralytics.utilsrContextDecoratorrr5rCrKrr;rrrr\rrrrrrrrrrrr rrrrr%rFrr-r5r#rr r=s  $+j))+\ (B ,$ EPB$:& F ( , . 4    o8$1N  &"(A&*@(0 F2 fU\\ fbjj f Tr