
    FPhV                     P   d dl Z d dlZd dl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 dlZd dlZd dlZd dlZd dlmZ d dlmZmZ d dlmZmZmZmZ d d	lmZ e G d
 d             Z G d d      Z G d d      Z G d d      Z  G d d      Z! G d d      Z"d Z#ee!e efZ$ddZ%y)    N)	dataclass)Path)Thread)urlparse)Image)IMG_FORMATSVID_FORMATS)LOGGERis_colab	is_kaggleops)check_requirementsc                   J    e Zd ZU dZdZeed<   dZeed<   dZeed<   dZ	eed<   y)SourceTypeszBClass to represent various types of input sources for predictions.Fwebcam
screenshotfrom_imgtensorN)
__name__
__module____qualname____doc__r   bool__annotations__r   r   r        cC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\ultralytics/data/loaders.pyr   r      s-    LFDJHdFDr   r   c                   6    e Zd ZdZd	dZd Zd Zd Zd Zd Z	y)
LoadStreamsa  
    Stream Loader for various types of video streams.

    Suitable for use with `yolo predict source='rtsp://example.com/media.mp4'`, supports RTSP, RTMP, HTTP, and TCP streams.

    Attributes:
        sources (str): The source input paths or URLs for the video streams.
        imgsz (int): The image size for processing, defaults to 640.
        vid_stride (int): Video frame-rate stride, defaults to 1.
        buffer (bool): Whether to buffer input streams, defaults to False.
        running (bool): Flag to indicate if the streaming thread is running.
        mode (str): Set to 'stream' indicating real-time capture.
        imgs (list): List of image frames for each stream.
        fps (list): List of FPS for each stream.
        frames (list): List of total frames for each stream.
        threads (list): List of threads for each stream.
        shape (list): List of shapes for each stream.
        caps (list): List of cv2.VideoCapture objects for each stream.
        bs (int): Batch size for processing.

    Methods:
        __init__: Initialize the stream loader.
        update: Read stream frames in daemon thread.
        close: Close stream loader and release resources.
        __iter__: Returns an iterator object for the class.
        __next__: Returns source paths, transformed, and original images for processing.
        __len__: Return the length of the sources object.
    c                 V   dt         j                  j                  _        || _        d| _        d| _        || _        || _        t        j                  j                  |      r't        |      j                         j                         n|g}t        |      }|D cg c]  }t!        j"                  |       c}| _        g g|z  dg|z  dg|z  dg|z  g g|z  f\  | _        | _        | _        | _        | _        dg|z  | _        t3        |      D ]  \  }}|dz    d| d| d}	t5        |      j6                  d	v rt9        |      }|j;                         rt=        |      n|}|dk(  rt?               s
tA               rtC        d
      tE        jF                  |      | j0                  |<   | j0                  |   jI                         stK        |	 d|       tM        | j0                  |   jO                  tD        jP                              }
tM        | j0                  |   jO                  tD        jR                              }| j0                  |   jO                  tD        jT                        }tW        tM        | j0                  |   jO                  tD        jX                              d      xs t[        d      | j*                  |<   tW        t]        j^                  |      r|nddz  d      xs d| j(                  |<   | j0                  |   ja                         \  }}|r|tK        |	 d|       | j&                  |   jc                  |       |j.                  | j.                  |<   te        | jf                  || j0                  |   |gd      | j,                  |<   ti        jj                  |	 d| j*                  |    d|
 d| d| j(                  |   dd
       | j,                  |   jm                           ti        jj                  d       | jo                         | _8        yc c}w )zKInitialize instance variables and check for consistent input stream shapes.Tstreamr   N   /: z... )zwww.youtube.comzyoutube.comzyoutu.bezm'source=0' webcam not supported in Colab and Kaggle notebooks. Try running 'source=0' in a local environment.zFailed to open infd      zFailed to read images from )targetargsdaemonu   Success ✅ (z frames of shape xz at z.2fz FPS) )9torchbackendscudnn	benchmarkbufferrunningmodeimgsz
vid_strideospathisfiler   	read_textrsplitlenr   	clean_strsourcesimgsfpsframesthreadsshapecaps	enumerater   hostnameget_best_youtube_url	isnumericevalr   r   NotImplementedErrorcv2VideoCaptureisOpenedConnectionErrorintgetCAP_PROP_FRAME_WIDTHCAP_PROP_FRAME_HEIGHTCAP_PROP_FPSmaxCAP_PROP_FRAME_COUNTfloatmathisfinitereadappendr   updater
   infostart__len__bs)selfr=   r4   r5   r1   nr+   isstwhr?   successims                  r   __init__zLoadStreams.__init__>   s   )-&	
$8:w8O$w-))+224V]U^L29:'Qa(':FHTAXPQsUVwYZX[^_X_bfagjkaknpmqtumuEuB	48T[$,
FQJ	g&DAqE7!A3b4(B{##'UU(+;;=QaAAv8:) +[ \ \++A.DIIaL99Q<((*%OA3&?@@DIIaL$$S%=%=>?ADIIaL$$S%>%>?@A))A,""3#3#34C TYYq\%5%5c6N6N%O!PRST X]YDKKNdmmC&8sa3FJPbDHHQK))A,++-KGRbj%,Gs&KLLIIaL#HHDJJqM$DKK499Q<QR?S]abDLLOKK2$mDKKN+;;LQCqQRPSSWX\X`X`abXcdgWhhmnoLLO!!#7 '8 	B ,,.E ;s   P&c                    d| j                   |   }}| j                  rE|j                         r3||dz
  k  r)t        | j                  |         dk  r|dz  }|j                          || j                  z  dk(  r|j                         \  }}|sXt        j                  | j                  |   t        j                        }t        j                  d       |j                  |       | j                  r| j                  |   j!                  |       n&|g| j                  |<   nt#        j$                  d       | j                  r|j                         r||dz
  k  r&yyyyyy)z(Read stream `i` frames in daemon thread.r   r"   r'   dtypeuQ   WARNING ⚠️ Video stream unresponsive, please check your IP camera connection.g{Gz?N)r@   r2   rL   r;   r>   grabr5   retrievenpzerosrB   uint8r
   warningopenr1   rY   timesleep)r_   ra   capr!   r`   frf   rg   s           r   rZ   zLoadStreams.updatel   s   $++a.1lls||~!q1u+499Q< 2%Q
t&!+"%,,.KGR"XXdjjm288D'z{({{		!++B/(*t		!

4  lls||~!q1u+~l+~lr   c                 B   d| _         | j                  D ]%  }|j                         s|j                  d       ' | j                  D ]  }	 |j                           t        j                          y# t        $ r"}t        j                  d|        Y d}~Qd}~ww xY w)z*Close stream loader and release resources.F   )timeoutu6   WARNING ⚠️ Could not release VideoCapture object: N)r2   rA   is_alivejoinrC   release	Exceptionr
   rq   rJ   destroyAllWindows)r_   threadru   es       r   closezLoadStreams.close   s    llF A& # 99C] 
 	  ]!WXYWZ[\\]s   A33	B<BBc                     d| _         | S )zCIterates through YOLO image feed and re-opens unresponsive streams.countr_   s    r   __iter__zLoadStreams.__iter__   s    
r   c                 
   | xj                   dz  c_         g }t        | j                        D ]D  \  }}|s| j                  |   j	                         r!t        j                  d      t        d      k(  r| j                          t        t        j                  dt        | j                        z         | j                  |   }|st        j                  d|        |s| j                   r!|j#                  |j%                  d             |j#                  |r|j%                  d      n1t'        j(                  | j*                  |   t&        j,                               |j/                          G | j0                  |ddfS )	zEReturns source paths, transformed and original images for processing.r"   qu"   WARNING ⚠️ Waiting for stream r   r   rj   Nr,   )r   rD   r>   rA   rz   rJ   waitKeyordr   StopIterationrs   rt   minr?   r
   rq   r1   rY   poprn   ro   rB   rp   clearr=   )r_   imagesra   r+   s       r   __next__zLoadStreams.__next__   s   

a
dii(DAq ||A//1S[[^s3x5OJJL''

1s488},-IIaLNN%Gs#KL  {{aeeAh' 1aeeBi"((4::a=PRPXPX2YZ	' )* ||VT2--r   c                 ,    t        | j                        S )z(Return the length of the sources object.)r;   r=   r   s    r   r]   zLoadStreams.__len__   s    4<<  r   N)zfile.streams  r"   F)
r   r   r   r   rh   rZ   r   r   r   r]   r   r   r   r   r       s&    :,!\!( 
.8!r   r   c                   $    e Zd ZdZddZd Zd Zy)LoadScreenshotsa  
    YOLOv8 screenshot dataloader.

    This class manages the loading of screenshot images for processing with YOLOv8.
    Suitable for use with `yolo predict source=screen`.

    Attributes:
        source (str): The source input indicating which screen to capture.
        imgsz (int): The image size for processing, defaults to 640.
        screen (int): The screen number to capture.
        left (int): The left coordinate for screen capture area.
        top (int): The top coordinate for screen capture area.
        width (int): The width of the screen capture area.
        height (int): The height of the screen capture area.
        mode (str): Set to 'stream' indicating real-time capture.
        frame (int): Counter for captured frames.
        sct (mss.mss): Screen capture object from `mss` library.
        bs (int): Batch size, set to 1.
        monitor (dict): Monitor configuration details.

    Methods:
        __iter__: Returns an iterator object.
        __next__: Captures the next screenshot and returns it.
    c                    t        d       ddl}|j                         ^}}d\  | _        }}}}t	        |      dk(  rt        |d         | _        n?t	        |      dk(  rd |D        \  }}}}n"t	        |      dk(  rd	 |D        \  | _        }}}}|| _        d
| _        d| _        |j                         | _	        d| _
        | j                  j                  | j                     }	||	d   n|	d   |z   | _        ||	d   n|	d   |z   | _        |xs |	d   | _        |xs |	d   | _        | j                  | j                  | j                  | j                  d| _        y)z8Source = [screen_number left top width height] (pixels).mssr   N)r   NNNNr"      c              3   2   K   | ]  }t        |        y wNrN   .0r+   s     r   	<genexpr>z+LoadScreenshots.__init__.<locals>.<genexpr>   s     '?1A   rx   c              3   2   K   | ]  }t        |        y wr   r   r   s     r   r   z+LoadScreenshots.__init__.<locals>.<genexpr>   s     4LVSVVr   r!   topleftwidthheight)r   r   r   r   )r   r   splitscreenr;   rN   r4   r3   framesctr^   monitorsr   r   r   r   monitor)
r_   sourcer4   r   paramsr   r   r   r   r   s
             r   rh   zLoadScreenshots.__init__   sG   5! ,,.0I-T3vv;!fQi.DK[A'?'?$D#uf[A4LV4L1DKsE6
	
779 ((##DKK0%([75>wu~7K'+|GFO'&/D:P	.gg.
1 1 $		$((TZZ[_[f[fgr   c                     | S )z"Returns an iterator of the object.r   r   s    r   r   zLoadScreenshots.__iter__   s    r   c                 r   t        j                  | j                  j                  | j                              ddddddf   }d| j
                   d| j                   d| j                   d| j                   d| j                   d}| xj                  dz  c_
        t        | j
                        g|gd|fS )z?mss screen capture: get raw pixels from the screen as np array.N   zscreen z	 (LTWH): ,r$   r"   )rn   asarrayr   rl   r   r   r   r   r   r   r   str)r_   im0rb   s      r   r   zLoadScreenshots.__next__   s    jjt||45aBQBh?dkk])DII;az4::,aPTP[P[}\^_

a
DKK !C5$11r   Nr   )r   r   r   r   rh   r   r   r   r   r   r   r      s    2h62r   r   c                   0    e Zd ZdZddZd Zd Zd Zd Zy)	
LoadImagesa0  
    YOLOv8 image/video dataloader.

    This class manages the loading and pre-processing of image and video data for YOLOv8. It supports loading from
    various formats, including single image files, video files, and lists of image and video paths.

    Attributes:
        imgsz (int): Image size, defaults to 640.
        files (list): List of image and video file paths.
        nf (int): Total number of files (images and videos).
        video_flag (list): Flags indicating whether a file is a video (True) or an image (False).
        mode (str): Current mode, 'image' or 'video'.
        vid_stride (int): Stride for video frame-rate, defaults to 1.
        bs (int): Batch size, set to 1 for this class.
        cap (cv2.VideoCapture): Video capture object for OpenCV.
        frame (int): Frame counter for video.
        frames (int): Total number of frames in the video.
        count (int): Counter for iteration, initialized at 0 during `__iter__()`.

    Methods:
        _new_video(path): Create a new cv2.VideoCapture object for a given video path.
    c                    d}t        |t              rTt        |      j                  dk(  r<t        |      j                  }t        |      j                         j                         }g }t        |t        t        f      rt        |      n|gD ]C  }t        t        |      j                               }d|v r0|j                  t        t        j                  |d                   Zt        j                  j                  |      rL|j                  t        t        j                  t        j                  j!                  |d                         t        j                  j#                  |      r|j%                  |       |r@||z  j'                         r-|j%                  t        ||z  j                                      8t)        | d       |D cg c]-  }|j+                  d      d	   j-                         t.        v s,|/ }	}|D cg c]-  }|j+                  d      d	   j-                         t0        v s,|/ }
}t3        |	      t3        |
      }}|| _        |	|
z   | _        ||z   | _        d
g|z  dg|z  z   | _        d| _        || _        d| _         tC        |
      r| jE                  |
d          nd| _#        | j8                  dk(  rt)        d dt.         dt0               yc c}w c c}w )zHInitialize the Dataloader and raise FileNotFoundError if file not found.Nz.txt*T)	recursivez*.*z does not exist.r   Fimager"   r   zNo images or videos found in z!. Supported formats are:
images: z	
videos: )$
isinstancer   r   suffixparentr9   
splitlineslisttuplesortedabsoluteextendglobr6   r7   isdirr{   r8   rY   is_fileFileNotFoundErrorr   lowerr   r	   r;   r4   filesnf
video_flagr3   r5   r^   any
_new_videoru   )r_   r7   r4   r5   r   r   par+   r   videosninvs                r   rh   zLoadImages.__init__  sk   dC T$Z%6%6&%@$Z&&F:'')446D!+D4-!@tfLADG$$&'AaxVDIIa4$@ABq!VDIIbggll1e.D$EFG"QVaZ002S&1*!6!6!89:'1#_(=>> M #NUaggcl2&6&<&<&>+&M!UN"NUaggcl2&6&<&<&>+&M!UNVc&kB
f_
r' 'B,$"4	$v;OOF1I&DH77a<#&CA3 GGGRmS]^i]j%l m m  ONs   -K/K/-K4>K4c                     d| _         | S )z:Returns an iterator object for VideoStream or ImageFolder.r   r   r   s    r   r   zLoadImages.__iter__4      
r   c                    | j                   | j                  k(  rt        | j                  | j                      }| j                  | j                      rEd| _        t        | j                        D ]  }| j                  j                           | j                  j                         \  }}|s| xj                   dz  c_         | j                  j                          | j                   | j                  k(  rt        | j                  | j                      }| j                  |       | j                  j                         \  }}|s| xj                  dz  c_        d| j                   dz    d| j                   d| j                   d| j                   d| d}nZ| xj                   dz  c_         t!        j"                  |      }|t%        d|       d	| j                    d| j                   d
| d}|g|g| j                  |fS )z2Return next image, path and metadata from dataset.videor"   zvideo r#   z (z) r$   zImage Not Found zimage  )r   r   r   r   r   r3   ranger5   ru   rl   rm   r|   r   rX   r   r@   rJ   imreadr   )r_   r7   _rf   r   rb   s         r   r   zLoadImages.__next__9  s   :: zz$**%??4::&DI4??+ ,88,,.LGS

a
  "::(''zz$**-%#xx}}  JJ!OJa($''"TZZL$++bQUPVVXYA JJ!OJ**T"C{'*:4&(ABBAdggYavR8Avudhh))r   c                     d| _         t        j                  |      | _        t	        | j                  j                  t        j                        | j                  z        | _        y)z"Create a new video capture object.r   N)	r   rJ   rK   ru   rN   rO   rT   r5   r@   )r_   r7   s     r   r   zLoadImages._new_video\  sC    
##D)$((,,s'?'?@4??RSr   c                     | j                   S )z*Returns the number of files in the object.)r   r   s    r   r]   zLoadImages.__len__b      wwr   N)r   r"   )	r   r   r   r   rh   r   r   r   r]   r   r   r   r   r      s$    .%mN
!*FTr   r   c                   :    e Zd ZdZddZed        Zd Zd Zd Z	y)	LoadPilAndNumpya<  
    Load images from PIL and Numpy arrays for batch processing.

    This class is designed to manage loading and pre-processing of image data from both PIL and Numpy formats.
    It performs basic validation and format conversion to ensure that the images are in the required format for
    downstream processing.

    Attributes:
        paths (list): List of image paths or autogenerated filenames.
        im0 (list): List of images stored as Numpy arrays.
        imgsz (int): Image size, defaults to 640.
        mode (str): Type of data being processed, defaults to 'image'.
        bs (int): Batch size, equivalent to the length of `im0`.
        count (int): Counter for iteration, initialized at 0 during `__iter__()`.

    Methods:
        _single_check(im): Validate and format a single image to a Numpy array.
    c                 <   t        |t              s|g}t        |      D cg c]  \  }}t        |dd| d       c}}| _        |D cg c]  }| j                  |       c}| _        || _        d| _        t        | j                        | _
        yc c}}w c c}w )z$Initialize PIL and Numpy Dataloader.filenamer   .jpgN)r   r   rD   getattrpaths_single_checkr   r4   r3   r;   r^   )r_   r   r4   ra   rg   s        r   rh   zLoadPilAndNumpy.__init__{  s    #t$%CLUVYN[N51bgb*aSo>N[
589SrD&&r*S9
	dhh- \9s   B
Bc                 b   t        | t        j                  t        j                  f      sJ dt	        |               t        | t        j                        rW| j
                  dk7  r| j                  d      } t        j                  |       dddddddf   } t        j                  |       } | S )z,Validate and format an image to numpy array.z,Expected PIL/np.ndarray image type, but got RGBNr   )	r   r   rn   ndarraytyper3   convertr   ascontiguousarray)rg   s    r   r   zLoadPilAndNumpy._single_check  s     "u{{BJJ78s<himnpiqhr:ss8b%++&ww%ZZ&B1dd
+B%%b)B	r   c                 ,    t        | j                        S )z*Returns the length of the 'im0' attribute.)r;   r   r   s    r   r]   zLoadPilAndNumpy.__len__  s    488}r   c                     | j                   dk(  rt        | xj                   dz  c_         | j                  | j                  ddfS )z8Returns batch paths, images, processed images, None, ''.r"   Nr,   r   r   r   r   r   s    r   r   zLoadPilAndNumpy.__next__  7    ::?

a
zz488T2--r   c                     d| _         | S )z,Enables iteration for class LoadPilAndNumpy.r   r   r   s    r   r   zLoadPilAndNumpy.__iter__  r   r   Nr   )
r   r   r   r   rh   staticmethodr   r]   r   r   r   r   r   r   r   g  s/    &	   .r   r   c                   <    e Zd ZdZddZed	d       Zd Zd Zd Z	y)

LoadTensoraR  
    Load images from torch.Tensor data.

    This class manages the loading and pre-processing of image data from PyTorch tensors for further processing.

    Attributes:
        im0 (torch.Tensor): The input tensor containing the image(s).
        bs (int): Batch size, inferred from the shape of `im0`.
        mode (str): Current mode, set to 'image'.
        paths (list): List of image paths or filenames.
        count (int): Counter for iteration, initialized at 0 during `__iter__()`.

    Methods:
        _single_check(im, stride): Validate and possibly modify the input tensor.
    Nc                     | j                  |      | _        | j                  j                  d   | _        d| _        t        |      D cg c]  \  }}t        |dd| d       c}}| _        yc c}}w )zInitialize Tensor Dataloader.r   r   r   r   N)r   r   rB   r^   r3   rD   r   r   )r_   r   ra   rg   s       r   rh   zLoadTensor.__init__  sb    %%c*((..#	LUVYN[N51bgb*aSo>N[
[s   
A/c                    d| dt        | j                         d}t        | j                        dk7  rIt        | j                        dk7  rt        |      t	        j
                  |       | j                  d      } | j                  d   |z  s| j                  d   |z  rt        |      | j                         dkD  r:t	        j
                  d	| j                          d
       | j                         dz  } | S )z-Validate and format an image to torch.Tensor.ua   WARNING ⚠️ torch.Tensor inputs should be BCHW i.e. shape(1, 3, 640, 640) divisible by stride z. Input shapez is incompatible.r   r   r      g      ?uQ   WARNING ⚠️ torch.Tensor inputs should be normalized 0.0-1.0 but max value is z. Dividing input by 255.g     o@)	r   rB   r;   
ValueErrorr
   rq   	unsqueezerS   rU   )rg   striderb   s      r   r   zLoadTensor._single_check  s    ##)(-bhh7HHY[rxx=A288}! m#NN1aB88A;288A;#7Q-668c>NNnoqououownx y4 5 6e#B	r   c                     d| _         | S )zReturns an iterator object.r   r   r   s    r   r   zLoadTensor.__iter__  r   r   c                     | j                   dk(  rt        | xj                   dz  c_         | j                  | j                  ddfS )z!Return next item in the iterator.r"   Nr,   r   r   s    r   r   zLoadTensor.__next__  r   r   c                     | j                   S )zReturns the batch size.)r^   r   s    r   r]   zLoadTensor.__len__  r   r   )returnN)    )
r   r   r   r   rh   r   r   r   r   r]   r   r   r   r   r     s0     \  $
.r   r   c           	         g }| D ]  }t        |t        t        f      r`|j                  t	        j
                  t        |      j                  d      r!t        j                  |d      j                  n|             yt        |t        j                  t        j                  f      r|j                  |       t        dt        |      j                   d       |S )zUMerges a list of source of different types into a list of numpy arrays or PIL images.httpT)r!   ztype z is not a supported Ultralytics prediction source type. 
See https://docs.ultralytics.com/modes/predict for supported source types.)r   r   r   rY   r   rr   
startswithrequestsrO   rawrn   r   	TypeErrorr   r   )r   r   rg   s      r   autocast_listr    s    Eb3+&LLRI[I[\bIcHLLD$A$E$EiklmU[["**56LLeDH$5$5#6 7i j k k  Lr   c                    |r:t        d       ddl}|j                  |       j                  d      j                  S t        d       ddl}|j                  ddi      5 }|j                  | d	
      }ddd       t        j                  dg             D ]d  }|j                  d      xs ddk\  xs |j                  d      xs ddk\  }|s8|d   dk7  sA|d   dk(  sJ|d   dk(  sS|j                  d      c S  y# 1 sw Y   xY w)aE  
    Retrieves the URL of the best quality MP4 video stream from a given YouTube video.

    This function uses the pafy or yt_dlp library to extract the video info from YouTube. It then finds the highest
    quality MP4 format that has video codec but no audio codec, and returns the URL of this video stream.

    Args:
        url (str): The URL of the YouTube video.
        use_pafy (bool): Use the pafy package, default=True, otherwise use yt_dlp package.

    Returns:
        (str): The URL of the best quality MP4 video stream, or None if no suitable stream is found.
    )pafyzyoutube_dl==2020.12.2r   Nmp4)preftypezyt-dlpquietTF)downloadformatsr   i  r   i8  vcodecnoneacodecexturl)
r   r  newgetbestvideor  yt_dlp	YoutubeDLextract_inforeversedrO   )r  use_pafyr  r  ydl	info_dictrv   	good_sizes           r   rF   rF     s     <=xx}))5)9===8$wo.#((u(=I /)--	267Aw,15W!%%/:NQSW9WIQx[F2q{f7LQRSXQY]bQbuuU|#	 8 /.s   C>>D)F)&r   rV   r6   rs   dataclassesr   pathlibr   	threadingr   urllib.parser   rJ   numpyrn   r  r-   PILr   ultralytics.data.utilsr   r	   ultralytics.utilsr
   r   r   r   ultralytics.utils.checksr   r   r   r   r   r   r   r  LOADERSrF   r   r   r   <module>r'     s      	  !   ! 
     ; > > 7   P! P!f?2 ?2Do od8 8v9 9x 
O
C$r   