o V hso@s:ddlZddlZddlZddlZddlmZddlmZddlm Z ddl m Z ddl Z ddl ZddlZddlZddlmZddlmZmZmZddlmZmZmZmZdd lmZdd lmZeGd d d Z Gd ddZ!GdddZ"GdddZ#GdddZ$GdddZ%ddZ&dddZ'e!e$e#e"fZ(dS)N) dataclass)Path)Thread)urlparse)Image)FORMATS_HELP_MSG IMG_FORMATS VID_FORMATS)IS_COLAB IS_KAGGLELOGGERops)check_requirements)imreadc@sBeZdZUdZdZeed<dZeed<dZeed<dZ eed<dS) 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__rrrrrL/var/www/vscode/kcb/lib/python3.10/site-packages/ultralytics/data/loaders.pyrs    rc@sBeZdZdZdddZddZd d Zd d Zd dZddZ dS) 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. 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. file.streamsFc Csdtjj_||_d|_d|_||_tj |rt | n|g}t|}||_dg||_dg||_dg||_dg||_ddt|D|_ddt|D|_dd|D|_t|D]\}}|d d |d |d }t|jd vr}t|}|rt|n|}|dkrtstrt dt!"||j|<|j|#st$|d|t%|j|&t!j'}t%|j|&t!j(} |j|&t!j)} t*t%|j|&t!j+dpt,d|j|<t*t-.| r| ndddpd|j|<|j|/\} } | r| dur t$|d||j|0| | j|j|<t1|j2||j||gdd|j|<t34|d|j|d|d| d|j|dd |j|5qat34ddS)zUInitialize stream loader for multiple video sources, supporting various stream types.TrrNcSg|]}gqSrr.0_rrr lz(LoadStreams.__init__..cSr rrr!rrrr$mr%cSs g|] }t|tjdqS)r#)r clean_strreplaceossepr"xrrrr$ns r/: 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 infdzFailed to read images from )targetargsdaemonu Success ✅ (z frames of shape r+z at z.2fz FPS))6torchbackendscudnn benchmarkbufferrunningmode vid_strider(pathisfiler read_textrsplitlenbsfpsframesthreadscapsrangeimgsshapesources enumeraterhostnameget_best_youtube_url isnumericevalr r NotImplementedErrorcv2 VideoCaptureisOpenedConnectionErrorintgetCAP_PROP_FRAME_WIDTHCAP_PROP_FRAME_HEIGHT CAP_PROP_FPSmaxCAP_PROP_FRAME_COUNTfloatmathisfinitereadappendrupdater infostart) selfrMr?r<nisstwhrFsuccessimrrr__init__]sV "     & "6zLoadStreams.__init__cCsd|j|}}|jrq|rs||dkrut|j|dkr]|d7}|||jdkr\|\}}|sJtj |j |tj d}t d|||jrV|j||n |g|j|<ntd|jrw|ry||dksdSdSdSdSdSdS)z>> 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}") c Cs6tdddl}|^}}d\|_}}}}t|dkr$t|d|_n%t|dkr6dd|D\}}}}nt|d krId d|D\|_}}}}d |_d|_||_d|_ d |_ |jj |j}|duri|d n|d ||_ |durx|dn|d||_ |p|d|_|p|d|_|j |j |j|jd|_dS)zJInitialize screenshot capture with specified screen and region parameters.mssrN)rNNNNrcs|]}t|VqdSNrXr*rrr z+LoadScreenshots.__init__..r~csrrrr*rrrrrrr3topleftwidthheight)rrrr)rrsplitscreenrDrXr>framesctrErFmonitorsrrrrmonitor) rgsourcerparamsrrrrrrrrrps*     zLoadScreenshots.__init__cCs|S)zTYields the next screenshot image from the specified screen or region for processing.rrrrrrszLoadScreenshots.__iter__c Cs|t|j|jddddddf}d|jd|jd|jd|jd|j d }|j d7_ t |jg|g|gfS)zPCaptures and returns the next screenshot as a numpy array using the mss library.Nzscreen z (LTWH): ,r-r) ruasarrayrrsrrrrrrrstr)rgim0rjrrrrs*.zLoadScreenshots.__next__N)rrrrrprrrrrrrs  rc@s:eZdZdZdddZddZddZd d Zd d Zd S)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. 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. rc Csd}t|trt|jdkrt|j}t|}g}t|ttfr(t |n|gD]W}tt| }d|vrF| t t j |ddq+t j|r\| t t t j|dq+t j|rh||q+|r|||r||t|| q+t|dgg}} |D]} | dd } | tvr|| q| tvr| | qt|t| } } || |_| | |_| |_d g| dg| |_| d krd nd |_||_||_ t!| r|"| d nd|_#|jd krtd|dt$dS)zNInitialize dataloader for images and videos, supporting various input formats.Nz.txt*T) recursivez*.*z does not exist.rFrvideoimagezNo images or videos found in z. )% isinstancerrsuffixparentrB splitlineslisttuplesortedabsoluteextendglobr(r@isdirrrArcis_fileFileNotFoundErrorrlowerrr rDfilesnfni video_flagr>r?rEany _new_videor|r)rgr@batchr?rrparvideosr}rrnvrrrrpDsL            zLoadImagesAndVideos.__init__cCr)zPIterates through image/video files, yielding source paths, images, and metadata.rrrrrrrprzLoadImagesAndVideos.__iter__c Csxggg}}}t||jkr7|j|jkr|r|||fSt|j|j}|j|jrd|_|jr6|j s;| |d}t |j D] }|j }|sMnqB|r|j\}}|r|jd7_|||||d|jdd|jd|jd|jd|d |j|jkr|jd7_|jn|jd7_|jr|j|j|jkr| |j|jnyd |_|d d d krtd ddlm}|t|} tt| tj}Wdn1swYnt|}|durt !d|n|||||d|jdd|jd|d|jd7_|j|j"kr0nt||jks|||fS)zOReturns the next batch of images or video frames with their paths and metadata.rFrzvideo r,z (frame z) r-rrrheicz pillow-heifr)register_heif_openerNzImage Read Error zimage  )#rDrErrrrrr>r|rVrrJr?rsrtrrcrGrrrr pillow_heifrrryrTcvtColorrur COLOR_RGB2BGRrr rxr) rgpathsrKrer@rnr#rrimgrrrrusl        6         & >> 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 csNt|ts|g}ddt|D_fdd|D_d_tj_dS)zZInitializes a loader for PIL and Numpy images, converting inputs to a standardized format.cSs(g|]\}}t|ddpd|dqS)filenamer7r.jpggetattrr"rirorrrr$s(z,LoadPilAndNumpy.__init__..csg|]}|qSr) _single_check)r"rorrrr$srN)rrrNrrr>rDrErgrrrrrps zLoadPilAndNumpy.__init__cCstt|tjtjfsJdt|t|tjr8|jdkr"|d}t|dddddddf}t|}|S)zVValidate and format an image to numpy array, ensuring RGB order and contiguous memory.z,Expected PIL/np.ndarray image type, but got RGBNr) rrrundarraytyper>convertrascontiguousarray)rorrrrs$   " zLoadPilAndNumpy._single_checkcCs t|jS)zTReturns the length of the 'im0' attribute, representing the number of loaded images.)rDrrrrrrs zLoadPilAndNumpy.__len__cC2|jdkrt|jd7_|j|jdg|jfS)zEReturns the next batch of images, paths, and metadata for processing.rr7rrrrrErrrrr zLoadPilAndNumpy.__next__cCr)z[Iterates through PIL/numpy images, yielding paths, raw images, and metadata for processing.rrrrrrrrzLoadPilAndNumpy.__iter__N) rrrrrp staticmethodrrrrrrrrrs   rc@s@eZdZdZdddZedddZd d Zd d Zd dZ dS) LoadTensoraf A class for loading and processing tensor data for object detection tasks. This class handles the loading and pre-processing of image data from PyTorch tensors, preparing them for further processing in object detection pipelines. Attributes: im0 (torch.Tensor): The input tensor containing the image(s) with shape (B, C, H, W). bs (int): Batch size, inferred from the shape of `im0`. mode (str): Current processing mode, set to 'image'. paths (List[str]): List of image paths or auto-generated filenames. Methods: _single_check: Validates and formats an input tensor. Examples: >>> import torch >>> tensor = torch.rand(1, 3, 640, 640) >>> loader = LoadTensor(tensor) >>> paths, images, info = next(iter(loader)) >>> print(f"Processed {len(images)} images") returnNcCs8|||_|jjd|_d|_ddt|D|_dS)zDInitialize LoadTensor object for processing torch.Tensor image data.rrcSs$g|]\}}t|dd|dqS)rrrrrrrrr$"s$z'LoadTensor.__init__..N)rrrLrEr>rNrrrrrrps zLoadTensor.__init__ cCsd|dt|jd}t|jdkr(t|jdkrt|t||d}|jd|s6|jd|r:t||dt |j j krXtd |d | d }|S) zVValidates and formats 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.rrrg?zBtorch.Tensor inputs should be normalized 0.0-1.0 but max value is z. Dividing input by 255.go@) rrLrD ValueErrorr rx unsqueezer]r8finforrepsr_)rostriderjrrrr$s&   zLoadTensor._single_checkcCr)zBYields an iterator object for iterating through tensor image data.rrrrrrr:rzLoadTensor.__iter__cCr)zCYields the next batch of tensor images and metadata for processing.rr7rrrrrr?rzLoadTensor.__next__cCr)z+Returns the batch size of the tensor input.rrrrrrFrzLoadTensor.__len__)rN)r) rrrrrprrrrrrrrrrs   rc Csg}|D]:}t|ttfr%|tt|dr tj|ddj n|qt|tjt j fr4||qt dt |jd|S)z^Merges a list of sources into a list of numpy arrays or PIL images for Ultralytics prediction.httpT)rztype z is not a supported Ultralytics prediction source type. See https://docs.ultralytics.com/modes/predict for supported source types.)rrrrcrry startswithrequestsrYrawrur TypeErrorrr)rrrorrr autocast_listKs0 rpytubec Csn|dkr;tdddlm}||jjddd}t|dd dd }|D]}|jr8t|jd d d kr8|jSq#d S|dkrQtddd l }| |j ddjS|dkrtddd l }| ddi}|j|dd}Wd n1svwYt|dgD]1} | dpddkp| dpdd k} | r| ddkr| ddkr| ddkr| dSqd Sd S)a Retrieves 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". Defaults to "pytube". 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. rzpytubefix>=6.5.2r)YouTubemp4T)file_extension only_videocSrr) resolution)rjrrrysz&get_best_youtube_url..)keyreverseNri8pafy)rzyoutube_dl==2020.12.2)preftypezyt-dlpquietF)downloadformatsrirvcodecnoneacodecexturl)r pytubefixrstreamsfilterrrrXrrnew getbestvideoyt_dlp YoutubeDL extract_inforeversedrY) rmethodrrrrrydl info_dictr} good_sizerrrrP\s6  $(rP)r))rr`r(rz dataclassesrpathlibr threadingr urllib.parserrTnumpyrurr8PILrultralytics.data.utilsrrr ultralytics.utilsr r r r ultralytics.utils.checksrultralytics.utils.patchesrrrrrrrrrPLOADERSrrrrs:       #G(AF 6