diff --git a/openflexure_microscope/camera/base.py b/openflexure_microscope/camera/base.py index 96e1b024..9b561117 100644 --- a/openflexure_microscope/camera/base.py +++ b/openflexure_microscope/camera/base.py @@ -4,6 +4,7 @@ import io import threading import copy import datetime +import uuid from PIL import Image try: @@ -26,43 +27,60 @@ def log(s): class StreamObject(object): def __init__(self, write_to_file: bool=None, filename: str=None, folder: str=None, fmt: str='file') -> None: # Store a nice ID - self.id = filename + self.id = uuid.uuid4().hex log("Created {}".format(self.id)) # Create file name - self.file = self.build_file_path(filename, folder, fmt) + iterator = 0 + f_name = self.build_file_path(filename, folder, fmt) + + while os.path.isfile(f_name): # While file already exists + iterator += 1 # Add a file name iterator + f_name = self.build_file_path(filename, folder, fmt, iterator=iterator) # Rebuild file name + + self.file = f_name # Byte stream properties self.stream = io.BytesIO() # Byte stream that data will be written to # Set default write target self.write_to_file = write_to_file - if self.write_to_file == False: + if self.write_to_file is False: log("Default target for {} set to 'stream'".format(self.id)) self.target = self.stream else: log("Default target for {} set to 'file'".format(self.id)) self.target = self.file + + # Keep on disk after close by default + self.keep_on_disk = True # Object lock self.locked = False # Is the StreamObject locked for writing? (Handled by StreamingCamera) def __enter__(self): - log("Entering context for {}. Stored files will be cleaned up automatically.".format(self.id)) + log("Entering context for {}.\ + Stored files will be cleaned up automatically.".format(self.id)) + self.keep_on_disk = False # Flag file to be removed on close. return self def __exit__(self, *args): log("Cleaning up {}".format(self.id)) - self.delete() + self.close() - def build_file_path(self, filename: str, folder: str, fmt: str) -> str: + def build_file_path(self, filename: str, folder: str, fmt: str, iterator: int=0) -> str: """ - Construct a full file path, based on filename, folder, and file format. Defaults to datestamp + Construct a full file path, based on filename, folder, and file format. + + Defaults to datestamp. Iterator adds a numeric increment to the file name. """ if filename: file_name = "{}.{}".format(filename, fmt) else: - file_name = "{}.{}".format(datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), fmt) + file_name_base = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + if iterator: + file_name_base = "{}_{}".format(file_name_base, iterator) + file_name = "{}.{}".format(file_name_base, fmt) # Create folder and file if folder: @@ -76,48 +94,115 @@ class StreamObject(object): return file_path def lock(self): - """Set locked flag to True""" + """Set locked flag to True.""" self.locked = True def unlock(self): - """Set locked flag to False""" + """Set locked flag to False.""" self.locked = False + @property + def stream_exists(self, auto_rewind=True) -> bool: + """Check if BytesIO stream is empty""" + if auto_rewind: + self.stream.seek(0) # Rewind the data bytes for reading + if self.stream.getvalue(): # If data stream contains data + self.stream.seek(0) # Rewind the data bytes for reading + return True + else: + self.stream.seek(0) # Rewind the data bytes for reading + return False + + @property + def file_exists(self) -> bool: + """Check if corresponding file exists""" + if os.path.isfile(self.file): + return True + else: + return False + + @property + def metadata(self) -> dict: + d = { + 'id': self.id, + 'locked': self.locked, + 'keep_on_disk': self.keep_on_disk, + 'path': self.file, + } + + # Get file path + if self.file_exists: + d['file'] = self.file + else: + d['file'] = None + + # Check stream + if self.stream_exists: + d['stream'] = True + else: + d['stream'] = False + + # Check if file was manually deleted + if self.keep_on_disk and not self.file_exists: + d['path'] = "{} (Deleted)".format(d['path']) + + return d + @property def data(self) -> io.BytesIO: - """Return a byte string of the capture data""" + """Return a byte string of the capture data.""" self.stream.seek(0) # Rewind the data bytes for reading - if not self.stream.getvalue() and os.path.isfile(self.file): # If stream is empty but file is not - log("No stream data. Opening from file {}".format(self.file)) - with open(self.file, 'rb') as f: - self.stream = io.BytesIO(f.read()) # Load bytes from file in disk - self.stream.seek(0) # Rewind data bytes again - - data = self.stream.getbuffer() # Create a copy of the stream bytes + if self.stream_exists: # If data stream contains data + data = io.BytesIO(self.stream.getbuffer()) # Create a copy of the stream bytes - return io.BytesIO(data) # Read and return bytes data + else: # If data stream is empty + if self.file_exists: # If data file exists + # TODO: Streamline this bit + log("No stream data. Opening from file {}".format(self.file)) + with open(self.file, 'rb') as f: + d = io.BytesIO(f.read()) # Load bytes from file in disk + d.seek(0) # Rewind loaded stream + data = io.BytesIO(d.getbuffer()) # Create a copy of the stream bytes + else: + data = None + + return data # Read and return bytes data @property def binary(self) -> bytes: - """Return a byte string of the capture data""" + """Return a byte string of the capture data.""" return self.data.getvalue() - def save(self): - """ - Creates/opens a file, and writes this StreamObjects bytestring to the file. - """ - with open(self.file, 'ab') as f: # Load file as bytes - log("Writing stream to file {}".format(self.file)) - f.seek(0, 0) # Seek to the start of the file - f.write(self.binary) # Write data bytes to file + def load_file(self) -> bool: + """Load data stored on disk to the in-memory stream.""" + if self.file_exists: # If data file exists + # TODO: Streamline this bit + with open(self.file, 'rb') as f: + self.stream = io.BytesIO(f.read()) # Load bytes from file in disk + self.stream.seek(0) # Rewind data bytes again + return True + else: + return False - def clear_stream(self): + def save_file(self) -> bool: + """ + Write the StreamObjects stream to a file. + """ + if self.stream_exists: # If there's a stream to save + with open(self.file, 'ab') as f: # Load file as bytes + log("Writing stream to file {}".format(self.file)) + f.seek(0, 0) # Seek to the start of the file + f.write(self.binary) # Write data bytes to file + return True + else: + return False + + def delete_stream(self): """Clears the BytesIO stream of the StreamObject.""" self.stream = io.BytesIO() - return True - def delete(self) -> bool: + def delete_file(self) -> bool: """ If the StreamObject has been saved to disk, deletes the file and returns True. """ @@ -129,6 +214,18 @@ class StreamObject(object): log("File not found {}".format(self.file)) return False + def shunt(self): + """Demote the StreamObject from being stored in memory.""" + if not self.file_exists: # If file doesn't already exist + self.save_file() # Save stream to disk, if it exists + self.delete_stream() # Delete the stream from memory + + def close(self): + """Both clear the stream, and delete any associated on-disk data""" + self.delete_stream() + if not self.keep_on_disk: + self.delete_file() + class CameraEvent(object): """An Event-like class that signals all active clients when a new frame is @@ -181,11 +278,8 @@ class BaseCamera(object): event = CameraEvent() def __init__(self): - self.start_worker() - - # Stores state of StreamingCamera - self.state = { - } + self.state = {} # Create dict for capture state + self.settings = {} # Create dict to store settings def start_worker(self, timeout: int=5) -> bool: """Start the background camera thread if it isn't running yet.""" diff --git a/openflexure_microscope/camera/pi.py b/openflexure_microscope/camera/pi.py index b70bbe44..eb868c04 100644 --- a/openflexure_microscope/camera/pi.py +++ b/openflexure_microscope/camera/pi.py @@ -53,52 +53,88 @@ HERE = os.path.abspath(os.path.dirname(__file__)) DEFAULT_CONFIG = os.path.join(HERE, 'config_picamera.yaml') +def last_entry(object_list: list): + if object_list: # If any images have been captured + return object_list[-1] # Return the latest captured image + else: + return None + +def entry_by_id(id: str, object_list: list): + found = None + for o in object_list: + if o.id == id: + found = o + return found + class StreamingCamera(BaseCamera): """Raspberry Pi camera implementation of StreamingCamera.""" def __init__(self): + # Run BaseCamera init to start thread + BaseCamera.__init__(self) + # Capture data - self.image = None - self.video = None + self.images = [] + self.videos = [] # Camera settings - self.settings = { + self.settings.update({ 'video_resolution': (832, 624), 'image_resolution': (2592, 1944), 'numpy_resolution': (1312, 976), 'jpeg_quality': 75, - } + }) # Store state of StreamingCamera - self.state = { - 'video_recent': None, - 'image_recent': None, + self.state.update({ 'stream_active': False, 'record_active': False, 'preview_active': False, - } + }) - # Finally, run BaseCamera init to start thread - BaseCamera.__init__(self) + self.start_worker() def initialisation(self): """Run any initialisation code when the frame iterator starts.""" pass - def start_preview(self) -> bool: - """Start the onboard GPU camera preview.""" - self.start_worker() + # RETURNING CAPTURES - self.camera.start_preview() - self.state['preview_active'] = True - return True + @property + def image(self): + """Return the latest captured image""" + return last_entry(self.images) - def stop_preview(self) -> bool: - """Stop the onboard GPU camera preview.""" - self.start_worker() + @property + def video(self): + """Return the latest recorded video""" + return last_entry(self.videos) - self.camera.stop_preview() - self.state['preview_active'] = False - return True + def image_from_id(self, id): + """Returns an image StreamObject with a matching ID""" + return entry_by_id(id, self.images) + + def video_from_id(self, id): + """Returns a video StreamObject with a matching ID""" + return entry_by_id(id, self.videos) + + # CREATING NEW CAPTURES + def new_stream_object(self, stream_object, target_list: list, shunt_others: bool=True): + """Add a new capture to a list of captures, and shunt all others""" + if shunt_others: # If shunting all older captures + for obj in target_list: # For each older capture + obj.shunt() # Shunt capture from memory to storage + target_list.append(stream_object) + return stream_object + + def new_image(self, stream_object, shunt_others=True): + """Add a new capture to the image list, and shunt all others""" + return self.new_stream_object(stream_object, self.images, shunt_others=shunt_others) + + def new_video(self, stream_object, shunt_others=True): + """Add a new capture to the video list, and shunt all others""" + return self.new_stream_object(stream_object, self.videos, shunt_others=shunt_others) + + # HANDLING SETTINGS # TODO: Handle exceptions # TODO: Have this take a dictionary (not a config file) @@ -154,10 +190,10 @@ class StreamingCamera(BaseCamera): if 'digital_gain' in config: set_digital_gain(self.camera, config['digital_gain']) - # TODO: Rewrite this bit? - # https://picamera.readthedocs.io/en/release-1.13/api_camera.html def change_zoom(self, zoom_value: int=1) -> None: """Change the camera zoom, handling recentering and scaling.""" + self.start_worker() + zoom_value = float(zoom_value) if zoom_value < 1: zoom_value = 1 @@ -175,26 +211,22 @@ class StreamingCamera(BaseCamera): new_fov = (centre[0] - size/2, centre[1] - size/2, size, size) self.camera.zoom = new_fov - def stop_recording(self, target=None) -> bool: - """Stop the last started video recording on splitter port 2. + # LAUNCH ACTIONS - target (str/BytesIO): Target object to write data bytes to. - """ - if not target: # If no target is defined - target_obj = self.video # Assume StreamingCamera as target - target_obj.unlock() # Unlock the StreamObject - else: - target_obj = target + def start_preview(self) -> bool: + """Start the onboard GPU camera preview.""" + self.start_worker() - # Stop the camera video recording on port 2 - log("Stopping recording") - self.camera.stop_recording(splitter_port=2) - log("Recording stopped") + self.camera.start_preview() + self.state['preview_active'] = True + return True - # Update state dictionary - self.state['record_active'] = False - self.state['video_recent'] = str(target_obj) + def stop_preview(self) -> bool: + """Stop the onboard GPU camera preview.""" + self.start_worker() + self.camera.stop_preview() + self.state['preview_active'] = False return True def start_recording( @@ -217,47 +249,56 @@ class StreamingCamera(BaseCamera): fmt (str): Format of the capture. (default 'h264') """ - self.start_worker() - # If no target is specified, store to StreamingCamera - if not target: - # If target is not locked - if (self.video is None) or (not self.video.locked): + # Start recording method only if a current recording is not running + if not self.state['record_active']: + self.start_worker() - self.video = StreamObject( + # If no target is specified, store to StreamingCamera + if not target: + # Create a new video and add to the video list + target_obj = self.new_video(StreamObject( write_to_file=write_to_file, filename=filename, folder=folder, - fmt=fmt) # Reset/create StreamObject + fmt=fmt)) - # Store to the StreamObject BytesIO - target = self.video.target - # Note the target StreamObject, used for function return - target_obj = self.video - - target_obj.lock() # Lock the StreamObject while recording + # Lock the StreamObject while recording + target_obj.lock() + # Store to the StreamObject target + target = target_obj.target else: - print("Cannot start recording a new video \ - until the current recording has been stopped. \ - Returning None.") - return None + target_obj = target + + # Start the camera video recording on port 2 + log("Starting record at {}".format(self.settings['video_resolution'])) + self.camera.start_recording( + target, + format=fmt, + splitter_port=2, + resize=self.settings['video_resolution'], + quality=quality) + + # Update state dictionary + self.state['record_active'] = True + + return target_obj + else: - target_obj = target + print("Cannot start a new recording until the current recording has stopped.") + return None + + def stop_recording(self) -> bool: + """Stop the last started video recording on splitter port 2.""" + + # Stop the camera video recording on port 2 + log("Stopping recording") + self.camera.stop_recording(splitter_port=2) + log("Recording stopped") - # Start the camera video recording on port 2 - log("Starting record at {}".format(self.settings['video_resolution'])) - self.camera.start_recording( - target, - format=fmt, - splitter_port=2, - resize=self.settings['video_resolution'], - quality=quality) - # Update state dictionary - self.state['record_active'] = True - - return target_obj + self.state['record_active'] = False def pause_stream_for_capture(self, splitter_port: int=1, resolution: Tuple[int, int]=None) -> None: """ @@ -331,10 +372,9 @@ class StreamingCamera(BaseCamera): # If no target is specified, store to StreamingCamera if not target: - self.image = StreamObject(write_to_file=write_to_file, filename=filename, folder=folder, fmt=fmt) # Reset StreamObject - - target = self.image.target # Store to the StreamObject BytesIO - target_obj = self.image # Note the target StreamObject, used for function return + # Create a new image and add to the image list + target_obj = self.new_image(StreamObject(write_to_file=write_to_file, filename=filename, folder=folder, fmt=fmt)) + target = target_obj.target # Store to the StreamObject BytesIO else: target_obj = target @@ -412,6 +452,8 @@ class StreamingCamera(BaseCamera): else: return output.array + # HANDLE STREAM FRAMES + def frames(self): """ Create iterator used by worker thread to generate stream frames. diff --git a/tests/test_camera.py b/tests/test_camera.py index 84363d32..6a6c3d19 100644 --- a/tests/test_camera.py +++ b/tests/test_camera.py @@ -10,6 +10,7 @@ import uuid from PIL import Image import unittest +from pprint import pprint success_string = """ /O @@ -40,13 +41,6 @@ class TestCaptureMethods(unittest.TestCase): for use_video_port in [True, False]: for resize in [None, (640, 480)]: - # Create unique ID - id = uuid.uuid4().hex - - log("Resize: {}, V_Port: {}, ID: {}".format( - resize, - use_video_port, - id)) # Wait for camera wait_for_cam(camera) @@ -55,11 +49,10 @@ class TestCaptureMethods(unittest.TestCase): with camera.capture( write_to_file=False, use_video_port=use_video_port, - filename=id, resize=resize) as stream: # Ensure file deletion fails and returns False - self.assertFalse(stream.delete()) + self.assertFalse(stream.delete_file()) # Ensure capture not stored to file self.assertFalse(os.path.isfile(stream.file)) @@ -75,12 +68,12 @@ class TestCaptureMethods(unittest.TestCase): )) # Save capture to file - stream.save() + stream.save_file() # Check file got saved self.assertTrue(os.path.isfile(stream.file)) # Delete file - stream.delete() + stream.delete_file() # Check file got deleted self.assertFalse(os.path.isfile(stream.file)) @@ -117,9 +110,6 @@ class TestCaptureMethods(unittest.TestCase): for use_video_port in [True, False]: for resize in [None, (640, 480)]: - # Create unique ID - id = uuid.uuid4().hex - # Wait for camera wait_for_cam(camera) @@ -127,7 +117,6 @@ class TestCaptureMethods(unittest.TestCase): stream = camera.capture( write_to_file=True, use_video_port=use_video_port, - filename=id, resize=resize) # Check file got saved @@ -141,7 +130,7 @@ class TestCaptureMethods(unittest.TestCase): self.assertTrue(isinstance(stream.binary, (bytes, bytearray))) # Ensure file deletion completes and returns True - self.assertTrue(stream.delete()) + self.assertTrue(stream.delete_file()) # Check file got deleted self.assertFalse(os.path.isfile(stream.file)) @@ -155,8 +144,6 @@ class TestUnencodedMethods(unittest.TestCase): for use_video_port in [True, False]: for resize in [None, (640, 480)]: - # Create unique ID - id = uuid.uuid4().hex print("{}, {}, {}".format(id, resize, use_video_port)) @@ -189,8 +176,6 @@ class TestUnencodedMethods(unittest.TestCase): for use_video_port in [True, False]: for resize in [None, (640, 480)]: - # Create unique ID - id = uuid.uuid4().hex print("{}, {}, {}".format(id, resize, use_video_port)) @@ -227,16 +212,12 @@ class TestRecordMethods(unittest.TestCase): for write_to_file in [True, False, None]: - # Create unique ID - id = uuid.uuid4().hex - # Wait for camera wait_for_cam(camera) # Start recording with camera.start_recording( - write_to_file=write_to_file, - filename=id) as stream: + write_to_file=write_to_file) as stream: # Record for 2 seconds time.sleep(2) @@ -264,14 +245,11 @@ class TestRecordMethods(unittest.TestCase): """Tests recording videos to file on disk, without context manager.""" global camera - # Create unique ID - id = uuid.uuid4().hex - # Wait for camera wait_for_cam(camera) # Start recording - stream = camera.start_recording(filename=id) + stream = camera.start_recording() # Record for 2 seconds time.sleep(2) # Stop recording @@ -282,7 +260,7 @@ class TestRecordMethods(unittest.TestCase): self.assertTrue(statinfo.st_size > 0) # Ensure file deletion completes and returns True - self.assertTrue(stream.delete()) + self.assertTrue(stream.delete_file()) # Check file got deleted self.assertFalse(os.path.isfile(stream.file)) @@ -293,9 +271,6 @@ class TestThreadStarting(unittest.TestCase): """Tests that a capture call restarts the camera worker thread.""" global camera - # Create unique ID - id = uuid.uuid4().hex - # Wait for camera wait_for_cam(camera) @@ -307,8 +282,7 @@ class TestThreadStarting(unittest.TestCase): # Restart worker thread by initialising a capture with camera.capture( - use_video_port=True, - filename=id) as stream: + use_video_port=True) as stream: # Ensure StreamObject 'stream' has # a valid BytesIO object and byte string @@ -333,5 +307,11 @@ if __name__ == '__main__': if result.wasSuccessful(): print(success_string) + + # Show us what was captured + for im in camera.images: + pprint(im.metadata) + for im in camera.videos: + pprint(im.metadata) camera.close()