#22 syntax

README.md

@@ -1,2 +1,47 @@
-# PiCamera
+# JamesCam
 Camera for Raspberry Pi
+
+## How to run
+Either:
+```
+chmod +x ./start.sh
+./start.sh
+```
+Or:
+```
+python3 src/main.py
+```
+
+## Configuration
+Check `config.json` for an example configuration.
+
+### `camera_type`
+Specifies the camera type (`picam` interface implementation) to use.
+```
+1: legacy picamera implementation
+```
+
+### `capture_resolution`
+Specifies the resolution of the photos to take.
+
+The X value will be rounded up to a multiple of 32, and the Y value to a multiple of 16, otherwise we'll get bugs due to the behaviour described in the [docs](https://picamera.readthedocs.io/en/release-1.13/recipes2.html#unencoded-image-capture-yuv-format)
+
+
+### `preview_resolution`
+Specifies the resolution of the viewfinder. I've set this to the resolution of the hyperpixel4 display
+
+### `output_format`
+Specifies the output format of the image. Check supported formats using `python3 -m PIL`
+
+### `output_extension`
+Specifies the file extension of the image. Should probably match the `output_format` option.
+
+### `output_directory`
+Specifies the directory to put taken images in to.
+
+### `output_filename_format`
+Specifies the format of the output filename.
+> See [Python docs](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes) for reference.
+
+### `output_jpeg_quality`
+Specify the quality of JPEG compression, best not to go over 95

config.json

@@ -0,0 +1,10 @@
+{
+    "camera_type": 1,
+    "capture_resolution": [3000, 2000],
+    "preview_resolution": [800, 480],
+    "output_format": "JPEG",
+    "output_extension": ".jpg",
+    "output_directory": "./images",
+    "output_filename_format": "%d-%m-%Y %H-%M-%S",
+    "output_jpeg_quality": 90
+}

picam.py

@@ -1,89 +0,0 @@
-import picamera
-import pygame
-import pygame_gui
-import time
-import io
-import os
-
-from datetime import datetime
-
-def setup_pygame():
-    pygame.init()
-    # Set the cursor to invisible. We use a transparent cursor for this as set_visible breaks the touch screen
-    pygame.mouse.set_cursor((8,8),(0,0),(0,0,0,0,0,0,0,0),(0,0,0,0,0,0,0,0))
-    screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) # (0, 0) means same as display resolution
-    return screen
-
-def setup_camera(screen):
-    camera = picamera.PiCamera()
-    camera.rotation = 90
-    return camera
-
-def take_picture(camera, capture_resolution, directory):
-    now = datetime.now()
-    now_string = now.strftime("%d-%m-%Y %H-%M-%S")
-    print("Saving image to: \"./images/{0}.jpg\"".format(now_string))
-    camera.resolution = capture_resolution
-    camera.capture("./{0}/{1}.jpg".format(directory, now_string))
-
-def set_cam_resolution(camera, resolution, framerate):
-    camera.resolution = resolution
-    camera.framerate = framerate
-
-screen = setup_pygame()
-camera = setup_camera(screen)
-
-cam_viewfinder_resolution = (int(screen.get_width()), int(screen.get_height()))
-cam_capture_resolution = (camera.MAX_RESOLUTION.width, camera.MAX_RESOLUTION.height)
-cam_video_resolution = (1920, 1080)
-
-cam_viewfinder_framerate = 15
-cam_video_framerate = 30
-
-set_cam_resolution(camera, cam_viewfinder_resolution, cam_viewfinder_framerate)
-
-rgb = bytearray(camera.resolution[0] * camera.resolution[1] * 3)
-
-#pygame-gui
-gui_manager = pygame_gui.UIManager((screen.get_width(), screen.get_height()))
-clock = pygame.time.Clock()
-
-take_button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect((720, 200), (80, 80)),
-                                             text='Take',
-                                             manager=gui_manager)
-
-loop = True
-while loop:
-    time_delta = clock.tick(60)/1000.0
-    for event in pygame.event.get():
-        if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_ESCAPE:
-                loop = False
-        elif event.type == pygame.QUIT:
-            loop = False
-        elif event.type == pygame.USEREVENT:
-            if event.user_type == pygame_gui.UI_BUTTON_PRESSED:
-                if event.ui_element == take_button:
-                    take_picture(camera, cam_capture_resolution, './images')
-                    # reset_resolution(camera, cam_viewfinder_resolution, cam_viewfinder_framerate)
-                    set_cam_resolution(camera, cam_viewfinder_resolution, cam_viewfinder_framerate)
-        gui_manager.process_events(event)
-
-    gui_manager.update(time_delta)
-
-    stream = io.BytesIO()
-    camera.capture(stream, use_video_port=True, format='rgb')
-    stream.seek(0)
-    stream.readinto(rgb)
-    stream.close()
-    img = pygame.image.frombuffer(rgb[0:(camera.resolution[0] * camera.resolution[1] * 3)], camera.resolution, 'RGB')
-    img = pygame.transform.scale(img, (screen.get_width(), screen.get_height()))
-
-    if img:
-        screen.blit(img, (0, 0))
-
-    gui_manager.draw_ui(screen)
-    pygame.display.update()
-
-camera.close()
-pygame.display.quit()

requirements.txt

@@ -1,2 +1,4 @@
-pygame==1.9.6
-pygame-gui==0.5.7
+pygame==2.1.2
+pygame-gui==0.6.4
+picamera==1.13
+pillow==9.2.0

src/main.py

@@ -0,0 +1,74 @@
+from picam_manager.picam_manager import PiCamManager
+from picamui.picamui import PiCamUi
+
+import json
+from PIL import Image
+from datetime import datetime
+
+CONFIG_PATH = "./config.json"
+
+def load_config() -> dict:
+    """Load JSON config from disk
+
+    :returns: Loaded JSON configuration as a dict
+    """
+    with open(CONFIG_PATH, 'rt') as config_file:
+        return json.load(config_file)
+
+def main() -> None:
+    """Main function for JamesCam"""
+    config = load_config()
+
+    # Setup UI
+    ui = PiCamUi()
+    ui.createUi()
+
+    # Setup camera
+    cam_manager = PiCamManager(config)
+    camera = cam_manager.camera
+
+    loop = True
+    while loop:
+        preview_bytes = camera.capture_preview()
+
+        ui.updatePreview(preview_bytes, camera.preview_resolution)
+        ui.update()
+
+        ui_events = ui.getEvents()
+        for event in ui_events:
+            if event == 'keyDownEscape' or event == 'pygameQuit' or event == 'btnExitPressed':
+                loop = False
+            elif event == 'btnTakePressed':
+                now = datetime.now()
+                capture_bytes = camera.capture()
+
+                pil_image = Image.frombuffer(mode='RGB', size=camera.capture_resolution, data=bytes(capture_bytes))
+
+                formatted_filename = now.strftime(config['output_filename_format'])
+                filename = f'{formatted_filename}{config["output_extension"]}'
+
+                with open(f'{config["output_directory"]}/{filename}', "wb") as output_file:
+                    if config['output_format'].lower() == 'jpeg':
+                        pil_image.save(output_file, format=config["output_format"], quality=config["output_jpeg_quality"])
+                    else:
+                        pil_image.save(output_file, format=config["output_format"])
+            else:
+                print('Unknown event {}'.format(event))
+
+    ui.cleanup()
+
+
+def print_ascii_art() -> None:
+    """Extremely important function"""
+    print("""
+     ██  █████  ███    ███ ███████ ███████  ██████  █████  ███    ███ 
+     ██ ██   ██ ████  ████ ██      ██      ██      ██   ██ ████  ████ 
+     ██ ███████ ██ ████ ██ █████   ███████ ██      ███████ ██ ████ ██ 
+██   ██ ██   ██ ██  ██  ██ ██           ██ ██      ██   ██ ██  ██  ██ 
+ █████  ██   ██ ██      ██ ███████ ███████  ██████ ██   ██ ██      ██ 
+                                                                      
+""")
+
+if __name__ == "__main__":
+    print_ascii_art()
+    main()

src/picam/picam.py

@@ -0,0 +1,38 @@
+from utils.utils import round_resolution
+
+ROUND_MULTIPLES = (32, 16)
+
+class PiCam:
+    def __init__(self, config: dict):
+        self.capture_resolution = round_resolution(config["capture_resolution"], ROUND_MULTIPLES)
+        self.preview_resolution = round_resolution(config["preview_resolution"], ROUND_MULTIPLES)
+
+    def set_capture_resolution(self, resolution: "tuple[int, int]") -> None:
+        """Set capture resolution for camera
+
+        :param resolution: New resolution for camera captures
+        """
+        rounded_resolution = round_resolution(resolution, ROUND_MULTIPLES)
+        self.capture_resolution = rounded_resolution
+
+    def set_preview_resolution(self, resolution: "tuple[int, int]") -> None:
+        """Set resolution for camera preview (viewfinder)
+
+        :param resolution: New resolution for camera preview
+        """
+        rounded_resolution = round_resolution(resolution, ROUND_MULTIPLES)
+        self.preview_resolution = rounded_resolution
+
+    def capture(self) -> bytearray:
+        """Capture an image
+
+        :returns: Image data as a byte buffer
+        """
+        raise NotImplementedError
+
+    def capture_preview(self) -> bytearray:
+        """Capture a preview image for the viewfinder
+
+        :returns: Image data as a byte buffer
+        """
+        raise NotImplementedError

src/picam/picam1.py

@@ -0,0 +1,61 @@
+from picam.picam import PiCam
+
+from io import BytesIO
+from picamera import PiCamera
+
+class PiCam1(PiCam):
+    """Implementation of PiCam class using legacy picamera module"""
+    def __init__(self, config: dict):
+        super().__init__(config)
+
+        self.init_camera()
+
+    def __del__(self):
+        """Destructor - cleans up picamera"""
+        self.close_camera()
+
+    def set_camera_resolution(self, resolution: "tuple[int, int]") -> None:
+        """Set resolution of active camera
+
+        :param resolution: Resolution to set camera to
+        """
+        self.camera.resolution = resolution
+
+    def set_preview_resolution(self, resolution: "tuple[int, int]") -> None:
+        super().set_preview_resolution(resolution)
+
+        self.set_camera_resolution(self.preview_resolution)
+
+    def init_camera(self) -> None:
+        """Initialize picamera camera object"""
+        self.camera = PiCamera(resolution=self.preview_resolution)
+
+    def close_camera(self) -> None:
+        """Close picamera camera object"""
+        self.camera.close()
+        self.camera = None
+
+    def capture(self, preview: bool = False) -> bytearray:
+        # Bytes to hold output buffer
+        if preview:
+            # Multiply by 3 for individual R, G, B values
+            out = bytearray((self.preview_resolution[0] * self.preview_resolution[1]) * 3)
+        else:
+            out = bytearray((self.capture_resolution[0] * self.capture_resolution[1]) * 3)
+            self.set_camera_resolution(self.capture_resolution) # If preview we'll already have the right resolution
+
+        bytes_stream = BytesIO()
+        self.camera.capture(bytes_stream, format='rgb', use_video_port=preview)
+
+        bytes_stream.seek(0)
+        bytes_stream.readinto(out)
+        bytes_stream.close()
+
+        if not preview:
+            # If preview we'll already have the right resolution
+            self.set_camera_resolution(self.preview_resolution)
+
+        return out
+
+    def capture_preview(self) -> bytearray:
+        return self.capture(preview=True)

src/picam_manager/picam_manager.py

@@ -0,0 +1,10 @@
+from picam.picam1 import PiCam1
+
+class PiCamManager:
+    def __init__(self, config: dict):
+        self.config = config
+
+        if config['camera_type'] == 1:
+            self.camera = PiCam1(config)
+        else:
+            raise Exception(f'Unsupported camera type {config["camera_type"]}')

src/picamui/picamui.py

@@ -0,0 +1,78 @@
+import pygame
+import pygame_gui
+
+class PiCamUi:
+    screen = None
+    guiManager = None
+    clock = None
+    uiElements = []
+
+    def __init__(self):
+        pygame.init()
+        # Set the cursor to invisible. We use a transparent cursor for this as set_visible breaks the touch screen
+        pygame.mouse.set_cursor((8,8),(0,0),(0,0,0,0,0,0,0,0),(0,0,0,0,0,0,0,0))
+        self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) # (0, 0) means same as display resolution
+
+    def createUi(self):
+        self.guiManager = pygame_gui.UIManager((self.screen.get_width(), self.screen.get_height()))
+        self.clock = pygame.time.Clock()
+
+        self.createUiElements()
+
+    def createUiElements(self):
+        btnTake = {
+            "name": "btnTake",
+            "element": pygame_gui.elements.UIButton(
+                relative_rect = pygame.Rect((720, 200), (80, 80)),
+                text = "Take",
+                manager = self.guiManager
+            )
+        }
+        self.uiElements.append(btnTake)
+
+        btnExit = {
+            "name": "btnExit",
+            "element": pygame_gui.elements.UIButton(
+                relative_rect=pygame.Rect((760, 440), (40, 40)),
+                text='X',
+                manager=self.guiManager
+            )
+        }
+        self.uiElements.append(btnExit)
+
+    def updatePreview(self, rgb, res):
+        img = pygame.image.frombuffer(rgb, res, 'RGB')
+        img = pygame.transform.scale(img, (self.screen.get_width(), self.screen.get_height()))
+
+        if img:
+            self.screen.blit(img, (0, 0))
+
+    def update(self):
+        self.guiManager.draw_ui(self.screen)
+        pygame.display.update()
+
+    def cleanup(self):
+        pygame.display.quit()
+
+    def getEvents(self):
+        events = []
+        time_delta = self.clock.tick(30)/1000.0
+        for event in pygame.event.get():
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_ESCAPE:
+                    events.append("keyDownEscape")
+            elif event.type == pygame.QUIT:
+                events.append("pygameQuit")
+            elif event.type == pygame.USEREVENT:
+                # Shoul be UI_BUTTON_PRESSED, but using on hover for now as having touch screen problems
+                if event.user_type == pygame_gui.UI_BUTTON_ON_HOVERED:
+                    for element in self.uiElements:
+                        if event.ui_element == element.get("element"):
+                            events.append("{}Pressed".format(element.get("name")))
+            self.guiManager.process_events(event)
+        self.guiManager.update(time_delta)
+
+        return events
+
+    def getScreenResolution(self):
+        return (self.screen.get_width(), self.screen.get_height())

src/utils/utils.py

@@ -0,0 +1,18 @@
+def round_value_up(value: int, multiple: int) -> int:
+    """Round value up to the nearest of the given multiple
+
+    :param value: Value to round
+    :param multiple: Multiple to round the value up to
+    :returns: Rounded value
+    """
+    value_mod = value % multiple
+    return value + (multiple - value_mod)
+
+def round_resolution(resolution: "tuple[int, int]", multiples: "tuple[int, int]") -> "tuple[int, int]":
+    """Round resolution up to the nearest of the given multiples
+
+    :param resolution: Resolution to round
+    :param multiples: Multiples to round the resolution values to
+    :returns: Tuple containing rounded resolution
+    """
+    return (round_value_up(resolution[0], multiples[0]), round_value_up(resolution[1], multiples[1]))

start.sh

@@ -0,0 +1 @@
+venv/bin/python3 src/main.py > out.txt 2>&1