Reference for ultralytics/data/loaders.py

def __iter__(self):
    """Iterates through YOLO image feed and re-opens unresponsive streams."""
    self.count = -1
    return self

def __len__(self):
    """Return the number of video streams in the LoadStreams object."""
    return self.bs  # 1E12 frames = 32 streams at 30 FPS for 30 years

def __next__(self):
    """Returns the next batch of frames from multiple video streams for processing."""
    self.count += 1

    images = []
    for i, x in enumerate(self.imgs):
        # Wait until a frame is available in each buffer
        while not x:
            if not self.threads[i].is_alive() or cv2.waitKey(1) == ord("q"):  # q to quit
                self.close()
                raise StopIteration
            time.sleep(1 / min(self.fps))
            x = self.imgs[i]
            if not x:
                LOGGER.warning(f"Waiting for stream {i}")

        # Get and remove the first frame from imgs buffer
        if self.buffer:
            images.append(x.pop(0))

        # Get the last frame, and clear the rest from the imgs buffer
        else:
            images.append(x.pop(-1) if x else np.zeros(self.shape[i], dtype=np.uint8))
            x.clear()

    return self.sources, images, [""] * self.bs

def close(self):
    """Terminates stream loader, stops threads, and releases video capture resources."""
    self.running = False  # stop flag for Thread
    for thread in self.threads:
        if thread.is_alive():
            thread.join(timeout=5)  # Add timeout
    for cap in self.caps:  # Iterate through the stored VideoCapture objects
        try:
            cap.release()  # release video capture
        except Exception as e:
            LOGGER.warning(f"Could not release VideoCapture object: {e}")
    cv2.destroyAllWindows()

def update(self, i, cap, stream):
    """Read stream frames in daemon thread and update image buffer."""
    n, f = 0, self.frames[i]  # frame number, frame array
    while self.running and cap.isOpened() and n < (f - 1):
        if len(self.imgs[i]) < 30:  # keep a <=30-image buffer
            n += 1
            cap.grab()  # .read() = .grab() followed by .retrieve()
            if n % self.vid_stride == 0:
                success, im = cap.retrieve()
                im = (
                    cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)[..., None] if self.cv2_flag == cv2.IMREAD_GRAYSCALE else im
                )
                if not success:
                    im = np.zeros(self.shape[i], dtype=np.uint8)
                    LOGGER.warning("Video stream unresponsive, please check your IP camera connection.")
                    cap.open(stream)  # re-open stream if signal was lost
                if self.buffer:
                    self.imgs[i].append(im)
                else:
                    self.imgs[i] = [im]
        else:
            time.sleep(0.01)  # wait until the buffer is empty

def __iter__(self):
    """Yields the next screenshot image from the specified screen or region for processing."""
    return self

def __next__(self):
    """Captures and returns the next screenshot as a numpy array using the mss library."""
    im0 = np.asarray(self.sct.grab(self.monitor))[:, :, :3]  # BGRA to BGR
    im0 = cv2.cvtColor(im0, cv2.COLOR_BGR2GRAY)[..., None] if self.cv2_flag == cv2.IMREAD_GRAYSCALE else im0
    s = f"screen {self.screen} (LTWH): {self.left},{self.top},{self.width},{self.height}: "

    self.frame += 1
    return [str(self.screen)], [im0], [s]  # screen, img, string

def __iter__(self):
    """Iterates through image/video files, yielding source paths, images, and metadata."""
    self.count = 0
    return self

def __len__(self):
    """Returns the number of files (images and videos) in the dataset."""
    return math.ceil(self.nf / self.bs)  # number of batches

def __next__(self):
    """Returns the next batch of images or video frames with their paths and metadata."""
    paths, imgs, info = [], [], []
    while len(imgs) < self.bs:
        if self.count >= self.nf:  # end of file list
            if imgs:
                return paths, imgs, info  # return last partial batch
            else:
                raise StopIteration

        path = self.files[self.count]
        if self.video_flag[self.count]:
            self.mode = "video"
            if not self.cap or not self.cap.isOpened():
                self._new_video(path)

            success = False
            for _ in range(self.vid_stride):
                success = self.cap.grab()
                if not success:
                    break  # end of video or failure

            if success:
                success, im0 = self.cap.retrieve()
                im0 = (
                    cv2.cvtColor(im0, cv2.COLOR_BGR2GRAY)[..., None]
                    if self.cv2_flag == cv2.IMREAD_GRAYSCALE
                    else im0
                )
                if success:
                    self.frame += 1
                    paths.append(path)
                    imgs.append(im0)
                    info.append(f"video {self.count + 1}/{self.nf} (frame {self.frame}/{self.frames}) {path}: ")
                    if self.frame == self.frames:  # end of video
                        self.count += 1
                        self.cap.release()
            else:
                # Move to the next file if the current video ended or failed to open
                self.count += 1
                if self.cap:
                    self.cap.release()
                if self.count < self.nf:
                    self._new_video(self.files[self.count])
        else:
            # Handle image files (including HEIC)
            self.mode = "image"
            if path.split(".")[-1].lower() == "heic":
                # Load HEIC image using Pillow with pillow-heif
                check_requirements("pillow-heif")

                from pillow_heif import register_heif_opener

                register_heif_opener()  # Register HEIF opener with Pillow
                with Image.open(path) as img:
                    im0 = cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)  # convert image to BGR nparray
            else:
                im0 = imread(path, flags=self.cv2_flag)  # BGR
            if im0 is None:
                LOGGER.warning(f"Image Read Error {path}")
            else:
                paths.append(path)
                imgs.append(im0)
                info.append(f"image {self.count + 1}/{self.nf} {path}: ")
            self.count += 1  # move to the next file
            if self.count >= self.ni:  # end of image list
                break

    return paths, imgs, info

def __iter__(self):
    """Iterates through PIL/numpy images, yielding paths, raw images, and metadata for processing."""
    self.count = 0
    return self

def __len__(self):
    """Returns the length of the 'im0' attribute, representing the number of loaded images."""
    return len(self.im0)

def __next__(self):
    """Returns the next batch of images, paths, and metadata for processing."""
    if self.count == 1:  # loop only once as it's batch inference
        raise StopIteration
    self.count += 1
    return self.paths, self.im0, [""] * self.bs

def __iter__(self):
    """Yields an iterator object for iterating through tensor image data."""
    self.count = 0
    return self

def __len__(self):
    """Returns the batch size of the tensor input."""
    return self.bs

def __next__(self):
    """Yields the next batch of tensor images and metadata for processing."""
    if self.count == 1:
        raise StopIteration
    self.count += 1
    return self.paths, self.im0, [""] * self.bs