Skip to content

landingai.image_source_ops

Operations (create, probe, save, etc) around images, videos from various sources (webcam, video, RTSP stream etc).

probe_video(video_file, samples_per_second)

Probe a video file to get some metadata before sampling images. Parameters

video_file: The local path to the video file samples_per_second: Number of images to sample per second Returns

A tuple of three values - The total number of frames, - The number of frames to sample, - The video length in seconds.

Source code in landingai/image_source_ops.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def probe_video(video_file: str, samples_per_second: float) -> Tuple[int, int, float]:
    """Probe a video file to get some metadata before sampling images.
    Parameters
    ----------
    video_file: The local path to the video file
    samples_per_second: Number of images to sample per second
    Returns
    -------
    A tuple of three values
        - The total number of frames,
        - The number of frames to sample,
        - The video length in seconds.
    """
    if not Path(video_file).exists():
        raise FileNotFoundError(f"Video file {video_file} does not exist.")
    cap = cv2.VideoCapture(video_file)
    fps = cap.get(cv2.CAP_PROP_FPS)
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    video_length_seconds = total_frames / fps
    sample_size = int(video_length_seconds * samples_per_second)
    cap.release()
    return (total_frames, sample_size, video_length_seconds)

sample_images_from_video(video_file, output_dir, samples_per_second=1)

Sample images from a video file. Parameters

video_file: The local path to the video file output_dir: The local directory path that stores the sampled images samples_per_second: The number of images to sample per second. If set to zero, it disables sampling Returns

a list of local file paths to the sampled images

Source code in landingai/image_source_ops.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
def sample_images_from_video(
    video_file: str, output_dir: Path, samples_per_second: float = 1
) -> List[str]:
    """Sample images from a video file.
    Parameters
    ----------
    video_file: The local path to the video file
    output_dir: The local directory path that stores the sampled images
    samples_per_second: The number of images to sample per second. If set to zero, it disables sampling
    Returns
    -------
    a list of local file paths to the sampled images
    """
    output_dir.mkdir(parents=True, exist_ok=True)
    if samples_per_second != 0:
        total_frames, sample_size, _ = probe_video(video_file, samples_per_second)
        # Calculate the frame interval based on the desired frame rate
        sample_interval = int(total_frames / sample_size)
    else:
        sample_interval = 1
    frame_count = 0
    output = []
    cap = cv2.VideoCapture(video_file)
    while cap.isOpened():
        ret, frame = cap.read()
        # Check if end of video file
        if not ret:
            break
        # Check if the current frame should be saved
        if frame_count % sample_interval == 0:
            output_file_path = str(output_dir / f"{frame_count}.jpg")
            cv2.imwrite(output_file_path, frame)
            output.append(output_file_path)
        frame_count += 1
    cap.release()
    return output

take_photo_from_webcam(webcam_source=0)

Open a Window and allow users to take a photo from the webcam. It supports running on both local environment and Google's colab notebooks. For Google colab, it will open a window to allow users to take a photo from the webcam by pressing the "Capture" button. For local environment, it will open a window to allow users to take a photo from the webcam by pressing the "space" button.

Source code in landingai/image_source_ops.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
def take_photo_from_webcam(webcam_source: Union[str, int] = 0) -> PIL.Image.Image:
    """Open a Window and allow users to take a photo from the webcam.
    It supports running on both local environment and Google's colab notebooks.
    For Google colab, it will open a window to allow users to take a photo from the webcam by pressing the "Capture" button.
    For local environment, it will open a window to allow users to take a photo from the webcam by pressing the "space" button.
    """
    try:
        # Running on Google's colab or local Jupyter notebook
        from base64 import b64decode

        from google.colab.output import eval_js  # type: ignore
        from IPython.display import Javascript, display

        # Define function to acquire images either directly from the local webcam (i.e. jupyter notebook)or from the web browser (i.e. collab)
        def take_photo() -> PIL.Image.Image:
            quality = 0.8
            js = Javascript(
                """
            async function takePhoto(quality) {
                const div = document.createElement('div');
                const capture = document.createElement('button');
                capture.textContent = 'Capture';
                div.appendChild(capture);

                const video = document.createElement('video');
                video.style.display = 'block';
                const stream = await navigator.mediaDevices.getUserMedia({video: true});

                document.body.appendChild(div);
                div.appendChild(video);
                video.srcObject = stream;
                await video.play();

                // Resize the output to fit the video element.
                google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);

                // Wait for Capture to be clicked.
                await new Promise((resolve) => capture.onclick = resolve);

                const canvas = document.createElement('canvas');
                canvas.width = video.videoWidth;
                canvas.height = video.videoHeight;
                canvas.getContext('2d').drawImage(video, 0, 0);
                stream.getVideoTracks()[0].stop();
                div.remove();
                return canvas.toDataURL('image/jpeg', quality);
            }
            """
            )
            display(js)
            data = eval_js("takePhoto({})".format(quality))
            binary = b64decode(data.split(",")[1])
            return PIL.Image.open(io.BytesIO(binary))

    except ModuleNotFoundError:
        # Capture image from local webcam using OpenCV
        import cv2

        def take_photo() -> PIL.Image.Image:
            cam = cv2.VideoCapture(webcam_source)
            cv2.namedWindow("Press space to take photo")
            cv2.startWindowThread()
            captured_frame: Optional[np.ndarray] = None
            while True:
                ret, frame = cam.read()
                if not ret:
                    print("failed to grab frame")
                    exit()
                cv2.imshow("Press space to take photo", frame)
                k = cv2.waitKey(1)
                if k % 256 == 32:
                    # SPACE pressed
                    captured_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    break
            cam.release()
            cv2.waitKey(1)
            cv2.destroyAllWindows()
            cv2.waitKey(1)
            return PIL.Image.fromarray(captured_frame)

    return take_photo()