Add examples for remote.py

Signed-off-by: Peter Bailey <[email protected]>

Author: PineappleBeech

examples/remote_motion_detection.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python3
+
+# This shows how to use the remote module to detect motion in an image.
+# It estimates the motion of the image and draws it on the image.
+
+import queue
+import threading
+
+import cv2
+import numpy as np
+
+import picamera2
+from picamera2 import MappedArray, Process, RemoteMappedArray
+
+BLOCK_SIZE = 32
+SEARCH_SIZE = 16
+STEP_SIZE = 8
+
+last_frame = None
+motion_map = None
+
+
+def run(request):
+    global last_frame
+
+    if last_frame is None:
+        last_frame = request.make_array("main")
+        return None
+
+    with RemoteMappedArray(request, "main") as m:
+        motion_map = calculate_motion(last_frame, m.array)
+
+    last_frame = request.make_array("main")
+
+    return motion_map
+
+
+def return_thread(futures):
+    global motion_map
+
+    while True:
+        future = futures.get()
+        motion_map = future.result()
+
+
+def calculate_motion(frame1, frame2):
+    motion_map = np.zeros((frame1.shape[0] // BLOCK_SIZE, frame1.shape[1] // BLOCK_SIZE, 2), dtype=np.int8)
+    for block_x in range(0, frame1.shape[1], BLOCK_SIZE):
+        for block_y in range(0, frame1.shape[0], BLOCK_SIZE):
+            block = frame1[block_y:block_y + BLOCK_SIZE, block_x:block_x + BLOCK_SIZE]
+            min_diff = np.inf
+            max_diff = 0
+            for offset_x in range(-SEARCH_SIZE, SEARCH_SIZE + 1, STEP_SIZE):
+                if block_x + offset_x < 0 or block_x + offset_x + BLOCK_SIZE >= frame2.shape[1]:
+                    continue
+                for offset_y in range(-SEARCH_SIZE, SEARCH_SIZE + 1, STEP_SIZE):
+                    if block_y + offset_y < 0 or block_y + offset_y + BLOCK_SIZE >= frame2.shape[0]:
+                        continue
+                    block2 = frame2[block_y + offset_y:block_y + offset_y + BLOCK_SIZE,
+                                    block_x + offset_x:block_x + offset_x + BLOCK_SIZE]
+                    diff = np.sum((block - block2)**2)
+                    if diff < min_diff:
+                        min_diff = diff
+                        min_offset = (offset_x, offset_y)
+                    if diff > max_diff:
+                        max_diff = diff
+
+            if max_diff < 4 * min_diff:
+                motion_map[block_y // BLOCK_SIZE, block_x // BLOCK_SIZE] = (0, 0)
+            else:
+                motion_map[block_y // BLOCK_SIZE, block_x // BLOCK_SIZE] = min_offset
+
+    return motion_map
+
+
+def draw_motion_map(request):
+    if motion_map is None:
+        return
+
+    with MappedArray(request, "main") as m:
+        for block_x in range(0, motion_map.shape[1]):
+            for block_y in range(0, motion_map.shape[0]):
+                mid_x = block_x * BLOCK_SIZE + BLOCK_SIZE // 2
+                mid_y = block_y * BLOCK_SIZE + BLOCK_SIZE // 2
+                offset_x, offset_y = motion_map[block_y, block_x]
+                cv2.arrowedLine(m.array, (mid_x, mid_y), (mid_x + offset_x, mid_y + offset_y), (0, 0, 255), 2)
+
+
+if __name__ == "__main__":
+    picam2 = picamera2.Picamera2()
+    config = picam2.create_preview_configuration()
+    config["buffer_count"] = 2
+    picam2.configure(config)
+    picam2.post_callback = draw_motion_map
+    picam2.start_preview(picamera2.Preview.QTGL)
+    picam2.start()
+
+    process = Process(run, picam2)
+
+    futures = queue.Queue()
+    return_thread = threading.Thread(target=return_thread, args=(futures,))
+    return_thread.start()
+
+    for _ in range(1000):
+        with picam2.captured_request() as request:
+            future = process.send(request)
+            futures.put(future)
+
+    return_thread.join()

examples/remote_processing_example.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python3
+
+# Shows how to use the remote module to process images in a separate process.
+# This is doing a simple sum of the pixels in the image in a separate process.
+# The results are then gathered by the main process and printed.
+
+import multiprocessing as mp
+import os
+import queue
+import threading
+import time
+
+import numpy as np
+
+import picamera2
+from picamera2 import Pool, RemoteMappedArray
+
+IMAGE_COUNT = 100
+
+
+def run(request):
+    print(f"Recieved request in process {os.getpid()}")
+    with RemoteMappedArray(request, "main") as m:
+        s = np.sum(m.array)
+        time.sleep(0.1)  # long calculation
+        print(f"Sum of array: {s}")
+    print(f"Processed request in process {os.getpid()}")
+    return s
+
+
+def gather_results(futures):
+    for i in range(IMAGE_COUNT):
+        future = futures.get()
+        print(f"Recieved result {i + 1}: {future.result()}")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    picam2 = picamera2.Picamera2()
+    config = picam2.create_preview_configuration()
+    config["buffer_count"] = 16
+    picam2.start(config)
+
+    with Pool(run, 16, picam2) as pool:
+        futures = queue.Queue()
+        results_thread = threading.Thread(target=gather_results, args=(futures,))
+        results_thread.start()
+
+        for _ in range(IMAGE_COUNT):
+            with picam2.captured_request() as request:
+                future = pool.send(request)
+                futures.put(future)
+
+        results_thread.join()

examples/remote_processing_pool.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+
+# Shows how the Pool class can be used to process images in separate processes.
+# This program creates a pool of 16 processes and sends 100 requests to the pool.
+# It keeps track of the number of requests processed by each process and prints the results.
+
+import os
+import time
+
+import picamera2
+from picamera2 import Pool
+
+
+def init():
+    global counter
+    counter = 0
+
+
+def run(request):
+    global counter
+    counter += 1
+    time.sleep(0.5)
+    return (os.getpid(), counter)
+
+
+if __name__ == "__main__":
+    picam2 = picamera2.Picamera2()
+    config = picam2.create_preview_configuration()
+    config["buffer_count"] = 16
+    picam2.start(config)
+
+    futures = []
+
+    with Pool(run, 16, picam2, init) as pool:
+        for _ in range(100):
+            with picam2.captured_request() as request:
+                future = pool.send(request)
+                futures.append(future)
+
+    print("Pool Closed")
+
+    counts = {}
+    counts.update(future.result() for future in futures)
+
+    print(counts)

examples/remote_save_image.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+
+# This shows how to use the remote module to save an image to a file.
+# This takes 100 images and saves them to a file in a separate process.
+# The images are saved in a folder called images.
+# The images are blurred as a simple example of processing the image in a separate process.
+# They have the process id that created them in the filename.
+
+import os
+
+import cv2
+
+import picamera2
+from picamera2 import Pool, RemoteMappedArray
+
+
+def init():
+    global counter
+    counter = 0
+
+
+def save_image(request):
+    global counter
+    counter += 1
+    with RemoteMappedArray(request, "main") as m:
+        temp_image = cv2.medianBlur(m.array, 9)
+        m.array[:] = temp_image
+
+    request.save(f"images_{os.getpid()}_{counter}.jpg")
+    request.save_dng(f"images_{os.getpid()}_{counter}.dng")
+
+
+if __name__ == "__main__":
+    picam2 = picamera2.Picamera2()
+    config = picam2.create_preview_configuration()
+    config["buffer_count"] = 8
+    picam2.start(config)
+
+    with Pool(save_image, 8, picam2, init) as pool:
+        for _ in range(25):
+            with picam2.captured_request() as request:
+                pool.send(request)

tests/test_list.txt

@@ -36,6 +36,9 @@ examples/preview_x_forwarding.py
 examples/pyav_capture.py
 examples/pyav_circular_capture.py
 examples/raw.py
+examples/remote_processing_pool.py
+examples/remote_processing_example.py
+examples/remote_save_image.py
 examples/request_context_manager.py
 examples/rotation.py
 examples/still_capture_with_config.py