|h{ddlZddlZddlZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZmZmZddlZddlZddlZddlmZddlmZmZmZddlmZmZmZmZdd l m!Z!dd l"m#Z#eGd d Z$Gd dZ%GddZ&GddZ'GddZ(GddZ)de e de eej,ejTffdZ+dde,de,dee,fdZ-e%e(e'e&fZ.y)N) dataclass)Path)Thread)AnyListOptionalTupleUnion)Image)FORMATS_HELP_MSG IMG_FORMATS VID_FORMATS)IS_COLAB IS_KAGGLELOGGERops)check_requirements)imreadcJeZdZUdZdZeed<dZeed<dZeed<dZ eed<y) SourceTypesa Class to represent various types of input sources for predictions. This class uses dataclass to define boolean flags for different types of input sources that can be used for making predictions with YOLO models. Attributes: stream (bool): Flag indicating if the input source is a video stream. screenshot (bool): Flag indicating if the input source is a screenshot. from_img (bool): Flag indicating if the input source is an image file. tensor (bool): Flag indicating if the input source is a tensor. Examples: >>> source_types = SourceTypes(stream=True, screenshot=False, from_img=False) >>> print(source_types.stream) True >>> print(source_types.from_img) False Fstream screenshotfrom_imgtensorN) __name__ __module__ __qualname____doc__rbool__annotations__rrrW/var/www/html/test/engine/venv/lib/python3.12/site-packages/ultralytics/data/loaders.pyrrs1(FDJHdFDr"rc eZdZdZddedededefdZdedejd efd Z d Z d Z d e eeeej eeffdZd efdZy) LoadStreamsa Stream Loader for various types of video streams. Supports RTSP, RTMP, HTTP, and TCP streams. This class handles the loading and processing of multiple video streams simultaneously, making it suitable for real-time video analysis tasks. Attributes: sources (List[str]): The source input paths or URLs for the video streams. vid_stride (int): Video frame-rate stride. buffer (bool): Whether to buffer input streams. running (bool): Flag to indicate if the streaming thread is running. mode (str): Set to 'stream' indicating real-time capture. imgs (List[List[np.ndarray]]): List of image frames for each stream. fps (List[float]): List of FPS for each stream. frames (List[int]): List of total frames for each stream. threads (List[Thread]): List of threads for each stream. shape (List[Tuple[int, int, int]]): List of shapes for each stream. caps (List[cv2.VideoCapture]): List of cv2.VideoCapture objects for each stream. bs (int): Batch size for processing. cv2_flag (int): OpenCV flag for image reading (grayscale or RGB). Methods: 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. Examples: >>> stream_loader = LoadStreams("rtsp://example.com/stream1.mp4") >>> for sources, imgs, _ in stream_loader: ... # Process the images ... pass >>> stream_loader.close() Notes: - The class uses threading to efficiently load frames from multiple streams simultaneously. - It automatically handles YouTube links, converting them to the best available stream URL. - The class implements a buffer system to manage frame storage and retrieval. sources vid_stridebufferchannelsc  dtjj_||_d|_d|_||_|dk(rtjntj|_ tjj|r't|j!j#n|g}t%|}||_dg|z|_dg|z|_dg|z|_dg|z|_t1|Dcgc]}gc}|_t1|Dcgc]}gc}|_|Dcgc]5}t7j8|j;tj<d7c}|_tA|D]:\}} |dzd|d| d } tBjDjG| jHd vr tK| } | jMr tO| n| } | dk(rtPstRr tUd tjV| |j.|<|j.|jYst[| d | t]|j.|j_tj`} t]|j.|j_tjb} |j.|j_tjd} tgt]|j.|j_tjhdxs tkd |j*|<tgtmjn| r| nddzdxsd|j(|<|j.|jq\}}|jtjk(r'tjr|tjtdn|}|r|t[| d| |j2|jw||j4|j4|<ty|jz||j.|| gd|j,|<t}j~| d|j*|d| d| d|j(|dd |j,|j=t}j~dycc}wcc}wcc}w)a Initialize stream loader for multiple video sources, supporting various stream types. Args: sources (str): Path to streams file or single stream URL. vid_stride (int): Video frame-rate stride. buffer (bool): Whether to buffer input streams. channels (int): Number of image channels (1 for grayscale, 3 for RGB). TrrN_/: z... >youtu.be youtube.comwww.youtube.comzm'source=0' webcam not supported in Colab and Kaggle notebooks. Try running 'source=0' in a local environment.zFailed to open infd.NzFailed to read images from )targetargsdaemonu Success ✅ (z frames of shape xz at z.2fz FPS))Atorchbackendscudnn benchmarkr(runningmoder'cv2IMREAD_GRAYSCALE IMREAD_COLORcv2_flagospathisfiler read_textrsplitlenbsfpsframesthreadscapsrangeimgsshaper clean_strreplacesepr& enumerateurllibparseurlparsehostnameget_best_youtube_url isnumericevalrrNotImplementedError VideoCaptureisOpenedConnectionErrorintgetCAP_PROP_FRAME_WIDTHCAP_PROP_FRAME_HEIGHT CAP_PROP_FPSmaxCAP_PROP_FRAME_COUNTfloatmathisfinitereadcvtColorCOLOR_BGR2GRAYappendrupdaterinfostart)selfr&r'r(r)nr,r9isstwhrLsuccessims r#__init__zLoadStreams.__init__^s*.&   $08A ,,3CSCS 8:w8O$w-))+224V]U^ L37cAg vz FQJ !&q*AR* "'(+Qb+ GNO! a(00=O g& $DAqE7!A3b4(B||$$Q'004bb(+;;=QaAAv8y)E++A.DIIaL99Q<((*%OA3&?@@DIIaL$$S%=%=>?ADIIaL$$S%>%>?@A))A,""3#3#34C TYYq\%5%5c6N6N%O!PRSTX]YDKKNdmmC&8sa3FJPbDHHQK))A,++-KGRDHMMUXUiUiDib#"4"45i@oqBbj%,Gs&KLL IIaL   #HHDJJqM$DKK499Q>> loader = LoadScreenshots("0 100 100 640 480") # screen 0, top-left (100,100), 640x480 >>> for source, im, im0s, vid_cap, s in loader: ... print(f"Captured frame: {im.shape}") sourcer)ctdddl}|j^}}d\|_}}}}t |dk(rt |d|_n?t |dk(rd|D\}}}}n"t |dk(rd |D\|_}}}}d |_d|_|j|_d|_ d |_ |dk(rtjntj|_|jj|j} || d n| d |z|_|| d n| d |z|_|xs| d|_|xs| d|_|j"|j |j$|j&d|_y)a# Initialize screenshot capture with specified screen and region parameters. Args: source (str): Screen capture source string in format "screen_num left top width height". channels (int): Number of image channels (1 for grayscale, 3 for RGB). mssrN)rNNNNr+c32K|]}t|ywNrb.0r9s r# z+LoadScreenshots.__init__..s'?1A'?rc32K|]}t|ywrrrs r#rz+LoadScreenshots.__init__..s4LSV4Lrrr4topleftwidthheight)rrrr)rrsplitscreenrJrbr@framesctrKrLrArBrCrDmonitorsrrrrmonitor) rsrr)rparamsrrrrrs r#r|zLoadScreenshots.__init__sd 5! ,,.0I- T3v v;! fQi.DK [A '?'? $D#uf [A 4LV4L 1DKsE6  77908A ,,3CSCS ((##DKK0%([75>wu~7K'+|GFO'&/D:P .gg. 1 1 $ $((TZZ[_[f[fg r"c|S)zSYield the next screenshot image from the specified screen or region for processing.r!rs r#rzLoadScreenshots.__iter__%s r"rc tj|jj|jddddddf}|j t jk(r't j|t jdn|}d|jd|jd|jd|jd|jd }|xjdz c_t!|jg|g|gfS) zNCapture and return the next screenshot as a numpy array using the mss library.Nrr5zscreen z (LTWH): ,r.r+)rasarrayrrrrDrArBrmrnrrrrrrr)rsim0rvs r#rzLoadScreenshots.__next__)sjjt||45aBQBh?BF--SVSgSgBgcll3 2 23I>mpdkk])DII;az4::,aPTP[P[}\^ _ a DKK !C51#--r"Nr) rrrrrrbr|rr rrrrr!r"r#rrsL> hs hc hD.%S 4 +;T#Y FG.r"rc eZdZdZd deeeefdededefdZ dZ de eeee jeeffd Zdefd Zdefd Zy )LoadImagesAndVideosa" A class for loading and processing images and videos for YOLO object detection. This class manages the loading and pre-processing of image and video data from various sources, including single image files, video files, and lists of image and video paths. Attributes: files (List[str]): List of image and video file paths. nf (int): Total number of files (images and videos). video_flag (List[bool]): 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. bs (int): Batch size. 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__(). ni (int): Number of images. cv2_flag (int): OpenCV flag for image reading (grayscale or RGB). Methods: __init__: Initialize the LoadImagesAndVideos object. __iter__: Returns an iterator object for VideoStream or ImageFolder. __next__: Returns the next batch of images or video frames along with their paths and metadata. _new_video: Creates a new video capture object for the given path. __len__: Returns the number of batches in the object. Examples: >>> loader = LoadImagesAndVideos("path/to/data", batch=32, vid_stride=1) >>> for paths, imgs, info in loader: ... # Process batch of images or video frames ... pass Notes: - Supports various image formats including HEIC. - Handles both local files and directories. - Can read from a text file containing paths to images and videos. rFbatchr'r)c d}t|trTt|jdk(r> ?R !A\\#&r*002F$ a ;& a  ! Vc&kBf_ r' 'B,$"4!QwGG $08A ,,3CSCS v; OOF1I &DH 77a<#&CA3bIYHZ$[\ \ r"cd|_|S)zOIterate through image/video files, yielding source paths, images, and metadata.rrrs r#rzLoadImagesAndVideos.__iter__  r"rc Bggg}}}t||jkr|j|jk\r |r|||fSt|j |j}|j |jr.d|_|jr|jjs|j|d}t|jD] }|jj}|r n|r4|jj\}}|jt j"k(r't!j$|t j&dn|}|r|xj(dz c_|j+||j+||j+d|jdzd|jd|j(d|j,d|d |j(|j,k(r|xjdz c_|jj/n|xjdz c_|jr|jj/|j|jkry|j|j |jnOd |_|j1d d j3d k(rnt5dddlm}|t;j<|5} t!j$t?j@| t jB}dddntE||j}tGjHd|nT|j+||j+||j+d|jdzd|jd|d |xjdz c_|j|jJk\rnt||jkr|||fS#1swYxYw)zNReturn the next batch of images or video frames with their paths and metadata.rFr5r+zvideo r-z (frame z) r.rrrheicz pillow-heifr)register_heif_openerN)flagszImage Read Error zimage  )&rJrKrrrrrr@r}r`rrPr'rrrDrArBrmrnrrorMrrrr pillow_heifrr rrr COLOR_RGB2BGRrrrr) rspathsrQrqrFrzr,rrimgs r#rzLoadImagesAndVideos.__next__s=BTt$i$''!zzTWW$ $,,''::djj)Dtzz*# xxtxx'8'8':OOD)t/A"hhmmoG" #'88#4#4#6LGS ==C,@,@@ S#*<*<=iH   a  T* C( fTZZ!^,?$ ??3'+113v=&}5@(*D)OS!ll2::c?CLL&KK$KK&a(8$''!D6 LM a ::($i$''!BdD  OOs 8PPcd|_tj||_t |jj tj |_|jjstd|t |jj tj|jz |_ y)z]Create a new video capture object for the given path and initialize video-related attributes.rzFailed to open video N) rrAr_r}rbrcrfrLr`rrhr'rM)rsrFs r#rzLoadImagesAndVideos._new_videos ##D)txx||C$4$456xx  "#&;D6$BC C$((,,s'?'?@4??RS r"cZtj|j|jz S)z>Return the number of files (images and videos) in the dataset.)rjceilrrKrs r#rzLoadImagesAndVideos.__len__syy477*++r"N)r+r+r)rrrrr rrrrbr|rr rrrrrr!r"r#rr3s%N3]U3d?33]C3]QT3]dg3]j D!%S 4 +;T#Y FGD!LTsT,,r"rc eZdZdZd deej ejefde fdZ e ddeej ejfde dejfdZ de fd Zdeee eejee ffd Zd Zy )LoadPilAndNumpya3 Load images from PIL and Numpy arrays for batch processing. This class manages 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[str]): List of image paths or autogenerated filenames. im0 (List[np.ndarray]): List of images stored as Numpy arrays. mode (str): Type of data being processed, set to 'image'. bs (int): Batch size, equivalent to the length of `im0`. Methods: _single_check: Validate and format a single image to a Numpy array. Examples: >>> from PIL import Image >>> import numpy as np >>> pil_img = Image.new("RGB", (100, 100)) >>> np_img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8) >>> loader = LoadPilAndNumpy([pil_img, np_img]) >>> paths, images, _ = next(iter(loader)) >>> print(f"Loaded {len(images)} images") Loaded 2 images rr)c Jt|ts|g}t|Dcgc]\}}t|ddxsd|dc}}|_|dk(rdnd}|Dcgc]}|j ||c}|_d|_t|j |_ ycc}}wcc}w) a; Initialize a loader for PIL and Numpy images, converting inputs to a standardized format. Args: im0 (PIL.Image.Image | np.ndarray | List): Single image or list of images in PIL or numpy format. channels (int): Number of image channels (1 for grayscale, 3 for RGB). filenamer:r.jpgr+LRGBN) rrrVgetattrr _single_checkrr@rJrK)rsrr)rur{pil_flags r#r|zLoadPilAndNumpy.__init__s#t$%CR[\_R`aBgb*b1DuQCt_Da "a-3U?BCD&&r84C dhh- bCs BB r{flagrczt|tjtjfsJdt |t|tjrOtj |j |}|dk(r|dn |ddddf}tj|}|S|jdk(r|d}|S)zVValidate and format an image to numpy array, ensuring RGB order and contiguous memory.z,Expected PIL/np.ndarray image type, but got rr5.Nr) rr rrtyperconvertascontiguousarrayndim)r{rs r#rzLoadPilAndNumpy._single_checks"u{{BJJ78s>> import torch >>> tensor = torch.rand(1, 3, 640, 640) >>> loader = LoadTensor(tensor) >>> paths, images, info = next(iter(loader)) >>> print(f"Processed {len(images)} images") rrNc |j||_|jjd|_d|_t |Dcgc]\}}t |dd|dc}}|_ycc}}w)z Initialize LoadTensor object for processing torch.Tensor image data. Args: im0 (torch.Tensor): Input tensor with shape (B, C, H, W). rrrrN)rrrRrKr@rVrr)rsrrur{s r#r|zLoadTensor.__init__Ks`%%c*((..# LUVYN[51bgb*aSo>[ [s A/r{stridecLd|dt|jd}t|jdk7rIt|jdk7r t|t j ||j d}|jd|zs|jd|zr t||jdtj|jjzkDr:t j d |jd |jd z }|S) zTValidate and format a single image tensor, ensuring correct shape and normalization.zRtorch.Tensor inputs should be BCHW i.e. shape(1, 3, 640, 640) divisible by stride z . Input shapez is incompatible.rrrrg?zBtorch.Tensor inputs should be normalized 0.0-1.0 but max value is z. Dividing input by 255.go@) rrRrJ ValueErrorrr unsqueezergr;finforepsri)r{rrvs r#rzLoadTensor._single_checkWs##)(-bhh7HHY [  rxx=A 288}! m# NN1 aB 88A; 288A;#7Q-  668cEKK1555 5 NNTUWU[U[U]T^^vw e#B r"cd|_|S)zAYield an iterator object for iterating through tensor image data.rrrs r#rzLoadTensor.__iter__mrr"c|jdk(rt|xjdz c_|j|jdg|jzfS)zBYield the next batch of tensor images and metadata for processing.r+r:r rs r#rzLoadTensor.__next__rr r"c|jS)z*Return the batch size of the tensor input.rrs r#rzLoadTensor.__len__yrr") )rrrrr;Tensorr|rrbrrr rrrrr!r"r#rr3s. \ELL \T \%,,U\\* 4%S 5<<c BC4r"rrrcg}|D]}t|ttfr^|jt j t|j drtjj|n|wt|tjtjfr|j|tdt|jd|S)z]Merge a list of sources into a list of numpy arrays or PIL images for Ultralytics prediction.httpztype z is not a supported Ultralytics prediction source type. See https://docs.ultralytics.com/modes/predict for supported source types.)rrrror r startswithrWrequesturlopenrr TypeErrorrr)rrr{s r# autocast_listr$~s E  b3+ & LL#b'BTBTU[B\FNN$:$:2$>bde f U[["**5 6 LL R))*+]^   Lr"urlmethodc2|dk(rtdddlm}||jj dd}t |dd }|D]8}|j st|j d d d k\s,|jcSy |d k(r:tddd l }|j|jdjS|dk(rtddd l }|jddi5}|j|d}d d d tj!dgD]d} | j!dxsddk\xs| j!dxsdd k\} | s8| ddk7sA| ddk(sJ| ddk(sS| j!dcSy y #1swYxYw)a Retrieve the URL of the best quality MP4 video stream from a given YouTube video. Args: url (str): The URL of the YouTube video. method (str): The method to use for extracting video info. Options are "pytube", "pafy", and "yt-dlp". Returns: (str | None): The URL of the best quality MP4 video stream, or None if no suitable stream is found. Examples: >>> url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ" >>> best_url = get_best_youtube_url(url) >>> print(best_url) https://rr4---sn-q4flrnek.googlevideo.com/videoplayback?expire=... Notes: - Requires additional libraries based on the chosen method: pytubefix, pafy, or yt-dlp. - The function prioritizes streams with at least 1080p resolution when available. - For the "yt-dlp" method, it looks for formats with video codec, no audio, and *.mp4 extension. pytubezpytubefix>=6.5.2r)YouTubemp4T)file_extension only_videoc|jSr) resolution)rvs r#z&get_best_youtube_url..s  r")keyreverseNri8pafy)r2zyoutube_dl==2020.12.2)preftypezyt-dlpquietF)downloadformatsrirvcodecnoneacodecextr%)r pytubefixr)streamsfilterrr.rbr%r2new getbestvideoyt_dlp YoutubeDL extract_inforeversedrc) r%r&r)r<rr2r@ydl info_dictr good_sizes r#r[r[s,-.%#,&&--Ut-T&#((u(=I >)-- 267 $Aw,15W!%%/:NQSW9WIQx[F2q{f7LQRSXQY]bQbuuU|#  $  > >s -F  F)r()/rrjrErrW dataclassesrpathlibr threadingrtypingrrrr r rAnumpyrr;PILr ultralytics.data.utilsr r rultralytics.utilsrrrrultralytics.utils.checksrultralytics.utils.patchesrrr%rrrrrr$rr[LOADERSr!r"r#rRs !44  MM>>7,  6ll^M.M.`s,s,lGGTHHV$s)U5;; 3J-K(L"1$c1$31$hsm1$j )