#22 syntax

README.md

@@ -1,4 +1,4 @@
-# PiCamera
+# JamesCam
 Camera for Raspberry Pi
 
 ## How to run
@@ -11,3 +11,37 @@ 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
+}

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

@@ -1,36 +1,74 @@
-import picamui
-import picam
+from picam_manager.picam_manager import PiCamManager
+from picamui.picamui import PiCamUi
 
-def main():
-    captureResolution = (1280, 1024)
-    captureDirectory = "./images"
-    captureExtension = "jpg"
+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.PiCamUi()
+    ui = PiCamUi()
     ui.createUi()
 
     # Setup camera
-    cam = picam.PiCam()
-    cam.setPreviewResolution(ui.getScreenResolution())
-    captureResolution = cam.getMaxResolution()
+    cam_manager = PiCamManager(config)
+    camera = cam_manager.camera
 
     loop = True
     while loop:
-        rgb = cam.getPreviewFrame()
-        ui.updatePreview(rgb, cam.getPreviewResolution())
+        preview_bytes = camera.capture_preview()
+
+        ui.updatePreview(preview_bytes, camera.preview_resolution)
         ui.update()
 
-        uiEvents = ui.getEvents()
-        for event in uiEvents:
-            if event == "keyDownEscape" or event == "pygameQuit" or event == "btnExitPressed":
+        ui_events = ui.getEvents()
+        for event in ui_events:
+            if event == 'keyDownEscape' or event == 'pygameQuit' or event == 'btnExitPressed':
                 loop = False
-            elif event == "btnTakePressed":
-                cam.capture(captureResolution, captureDirectory, captureExtension)
+            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))
+                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.py

@@ -1,44 +0,0 @@
-import picamera
-import io
-
-from datetime import datetime
-
-class PiCam:
-    camera = None
-    resPreview = (640, 480)
-
-    def __init__(self):
-        self.camera = picamera.PiCamera()
-
-    def setCamResolution(self, res):
-        self.camera.resolution = res
-
-    def setPreviewResolution(self, res):
-        self.resPreview = res
-        self.setCamResolution(self.resPreview)
-
-    def getPreviewResolution(self):
-        return self.resPreview
-
-    def getMaxResolution(self):
-        return (self.camera.MAX_RESOLUTION.width, self.camera.MAX_RESOLUTION.height)
-
-    def capture(self, res, directory, extension):
-        now = datetime.now()
-        strNow = now.strftime("%d-%m-%Y %H-%M-%S")
-        self.setCamResolution(res)
-        self.camera.capture("./{0}/{1}.{2}".format(directory, strNow, extension))
-        self.setCamResolution(self.resPreview)
-
-    def getPreviewFrame(self):
-        rgb = bytearray(self.getPreviewResolution()[0] * self.getPreviewResolution()[1] * 3)
-        stream = io.BytesIO()
-        self.camera.capture(stream, use_video_port=True, format="rgb")
-        stream.seek(0)
-        stream.readinto(rgb)
-        stream.close()
-
-        return rgb
-
-    def cleanup(self):
-        self.camera.close()

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

@@ -41,7 +41,7 @@ class PiCamUi:
         self.uiElements.append(btnExit)
 
     def updatePreview(self, rgb, res):
-        img = pygame.image.frombuffer(rgb[0:(res[0] * res[1] * 3)], res, 'RGB')
+        img = pygame.image.frombuffer(rgb, res, 'RGB')
         img = pygame.transform.scale(img, (self.screen.get_width(), self.screen.get_height()))
 
         if img:
@@ -64,7 +64,8 @@ class PiCamUi:
             elif event.type == pygame.QUIT:
                 events.append("pygameQuit")
             elif event.type == pygame.USEREVENT:
-                if event.user_type == pygame_gui.UI_BUTTON_PRESSED:
+                # 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")))

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

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