Explicit output stream must be specified when capturing
This commit is contained in:
Joel Collins
parent
3f69332240
commit
78ce3a9a11
4 changed files with 187 additions and 153 deletions
|
|
@ -15,7 +15,7 @@ except ImportError:
|
|||
except ImportError:
|
||||
from _thread import get_ident
|
||||
|
||||
from .capture import StreamObject, BASE_CAPTURE_PATH
|
||||
from .capture import CaptureObject, BASE_CAPTURE_PATH
|
||||
|
||||
|
||||
def last_entry(object_list: list):
|
||||
|
|
@ -222,19 +222,62 @@ class BaseCamera(object):
|
|||
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 shunt_captures(self, target_list: list):
|
||||
for obj in target_list: # For each older capture
|
||||
obj.shunt() # Shunt capture from memory to storage
|
||||
|
||||
def new_image(
|
||||
self,
|
||||
write_to_file: bool=False,
|
||||
keep_on_disk: bool=True,
|
||||
filename: str=None,
|
||||
fmt: str='jpeg',
|
||||
shunt_others: bool=True):
|
||||
|
||||
"""Add a new capture to the image list, and shunt all others."""
|
||||
|
||||
if not filename:
|
||||
filename = self.generate_basename(self.images)
|
||||
logging.debug(filename)
|
||||
|
||||
output = CaptureObject(
|
||||
write_to_file=write_to_file,
|
||||
keep_on_disk=keep_on_disk,
|
||||
filename=filename,
|
||||
folder=self.paths['image'],
|
||||
fmt=fmt)
|
||||
|
||||
self.shunt_captures(self.images)
|
||||
self.images.append(output)
|
||||
|
||||
return output
|
||||
|
||||
def new_video(
|
||||
self,
|
||||
write_to_file: bool=True,
|
||||
keep_on_disk: bool=True,
|
||||
filename: str=None,
|
||||
fmt: str='h264',
|
||||
quality: int=15,
|
||||
shunt_others: bool=True):
|
||||
|
||||
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)
|
||||
|
||||
if not filename:
|
||||
filename = self.generate_basename(self.videos)
|
||||
logging.debug(filename)
|
||||
|
||||
output = CaptureObject(
|
||||
write_to_file=write_to_file,
|
||||
keep_on_disk=keep_on_disk,
|
||||
filename=filename,
|
||||
folder=self.paths['video'],
|
||||
fmt=fmt)
|
||||
|
||||
self.shunt_captures(self.videos)
|
||||
self.videos.append(output)
|
||||
|
||||
return output
|
||||
|
||||
# INTELLIGENTLY GENERATE FILENAMES
|
||||
def generate_basename(self, obj_list: list) -> str:
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ thumbnail_size = (60, 60)
|
|||
BASE_CAPTURE_PATH = os.path.join(os.path.expanduser('~'), 'micrographs')
|
||||
TEMP_CAPTURE_PATH = os.path.join(BASE_CAPTURE_PATH, 'tmp')
|
||||
|
||||
class StreamObject(object):
|
||||
class CaptureObject(object):
|
||||
"""
|
||||
StreamObject used to store and process capture data, and metadata.
|
||||
|
||||
|
|
@ -26,6 +26,7 @@ class StreamObject(object):
|
|||
folder: str='',
|
||||
fmt: str='') -> None:
|
||||
"""Create a new StreamObject, to manage capture data."""
|
||||
|
||||
# Store a nice ID
|
||||
self.id = uuid.uuid4().hex
|
||||
logging.info("Created StreamObject {}".format(self.id))
|
||||
|
|
@ -37,24 +38,18 @@ class StreamObject(object):
|
|||
# Keep on disk after close by default
|
||||
self.keep_on_disk = keep_on_disk
|
||||
|
||||
# Explicitally state if capture should be written to a file, not a bytestream
|
||||
self.write_to_file = write_to_file
|
||||
|
||||
# Create file name. Default to UUID
|
||||
if not filename:
|
||||
filename = self.id
|
||||
self.filename = filename
|
||||
|
||||
self.filename = "{}.{}".format(filename, fmt)
|
||||
self.folder = folder
|
||||
self.build_file_path(self.filename, self.folder, self.format)
|
||||
|
||||
# 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 not self.write_to_file:
|
||||
logging.debug("Target for {} set to 'stream'".format(self.id))
|
||||
self.target = self.stream
|
||||
else:
|
||||
logging.debug("Target for {} set to 'file'".format(self.id))
|
||||
self.target = self.file
|
||||
# Initialise the capture stream
|
||||
self.initialise_capture()
|
||||
|
||||
# Log if created by context manager
|
||||
self.context_manager = False
|
||||
|
|
@ -67,14 +62,12 @@ class StreamObject(object):
|
|||
|
||||
def __enter__(self):
|
||||
"""Create StreamObject in context, to auto-clean disk data."""
|
||||
logging.debug("Entering context for {}.\
|
||||
Stored files will be cleaned up automatically.".format(self.id))
|
||||
logging.debug("Entering context for {}. Stored files will be cleaned up automatically regardless of location.".format(self.id))
|
||||
self.keep_on_disk = False # Flag file to be removed on close.
|
||||
self.context_manager = True # Used in metadata
|
||||
|
||||
# Re-generate file name for temp file
|
||||
logging.info("Re-generating file name for temp file")
|
||||
self.build_file_path(self.filename, self.folder, self.format)
|
||||
logging.info("Rebuilding as a temporary capture...")
|
||||
self.initialise_capture()
|
||||
|
||||
return self
|
||||
|
||||
|
|
@ -83,11 +76,24 @@ class StreamObject(object):
|
|||
logging.info("Cleaning up {}".format(self.id))
|
||||
self.close()
|
||||
|
||||
def initialise_capture(self):
|
||||
self.build_file_path(self.filename, self.folder)
|
||||
|
||||
# Byte bytestream properties
|
||||
self.bytestream = io.BytesIO() # Byte bytestream that data will be written to
|
||||
|
||||
# Set default write target
|
||||
if not self.write_to_file:
|
||||
logging.debug("Target for {} set to 'bytestream'".format(self.id))
|
||||
self.stream = self.bytestream
|
||||
else:
|
||||
logging.debug("Target for {} set to 'file'".format(self.id))
|
||||
self.stream = self.file
|
||||
|
||||
def build_file_path(
|
||||
self,
|
||||
filename: str,
|
||||
folder: str,
|
||||
fmt: str):
|
||||
folder: str):
|
||||
"""
|
||||
Construct a full file path, based on filename, folder, and file format.
|
||||
|
||||
|
|
@ -95,9 +101,7 @@ class StreamObject(object):
|
|||
"""
|
||||
global TEMP_CAPTURE_PATH
|
||||
|
||||
file_given_name = "{}.{}".format(filename, fmt) # Given file name. May include a relative path
|
||||
|
||||
self.file = os.path.join(folder, file_given_name) # Full file name by joining given folder to given name
|
||||
self.file = os.path.join(folder, filename) # Full file name by joining given folder to given name
|
||||
|
||||
self.split_file_path(self.file) # Split file path into folder, filename, and basename
|
||||
|
||||
|
|
@ -116,6 +120,11 @@ class StreamObject(object):
|
|||
if not os.path.exists(self.filefolder):
|
||||
os.makedirs(self.filefolder)
|
||||
|
||||
logging.debug(self.file)
|
||||
logging.debug(self.filename)
|
||||
logging.debug(self.basename)
|
||||
logging.debug(self.filefolder)
|
||||
|
||||
def split_file_path(self, filepath):
|
||||
"""Takes a full file path, and splits it into separated class properties."""
|
||||
self.filefolder, self.filename = os.path.split(filepath) # Split the full file path into a folder and a filename
|
||||
|
|
@ -131,14 +140,14 @@ class StreamObject(object):
|
|||
|
||||
@property
|
||||
def stream_exists(self, auto_rewind=True) -> bool:
|
||||
"""Check if BytesIO stream is empty."""
|
||||
"""Check if BytesIO bytestream 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
|
||||
self.bytestream.seek(0) # Rewind the data bytes for reading
|
||||
if self.bytestream.getvalue(): # If data bytestream contains data
|
||||
self.bytestream.seek(0) # Rewind the data bytes for reading
|
||||
return True
|
||||
else:
|
||||
self.stream.seek(0) # Rewind the data bytes for reading
|
||||
self.bytestream.seek(0) # Rewind the data bytes for reading
|
||||
return False
|
||||
|
||||
@property
|
||||
|
|
@ -161,11 +170,11 @@ class StreamObject(object):
|
|||
'time': self.timestring
|
||||
}
|
||||
|
||||
# Check stream
|
||||
# Check bytestream
|
||||
if self.stream_exists:
|
||||
d['stream'] = True
|
||||
d['bytestream'] = True
|
||||
else:
|
||||
d['stream'] = False
|
||||
d['bytestream'] = False
|
||||
|
||||
# Combined availability of data
|
||||
if self.stream_exists or self.file_exists:
|
||||
|
|
@ -182,19 +191,19 @@ class StreamObject(object):
|
|||
@property
|
||||
def data(self) -> io.BytesIO:
|
||||
"""Return a byte string of the capture data."""
|
||||
self.stream.seek(0) # Rewind the data bytes for reading
|
||||
self.bytestream.seek(0) # Rewind the data bytes for reading
|
||||
|
||||
if self.stream_exists: # If data stream contains data
|
||||
# Create a copy of the stream bytes
|
||||
data = io.BytesIO(self.stream.getbuffer())
|
||||
if self.stream_exists: # If data bytestream contains data
|
||||
# Create a copy of the bytestream bytes
|
||||
data = io.BytesIO(self.bytestream.getbuffer())
|
||||
|
||||
else: # If data stream is empty
|
||||
else: # If data bytestream is empty
|
||||
if self.file_exists: # If data file exists
|
||||
logging.info("Opening from file {}".format(self.file))
|
||||
with open(self.file, 'rb') as f:
|
||||
d = io.BytesIO(f.read()) # Load bytes from file
|
||||
d.seek(0) # Rewind loaded stream
|
||||
# Create a copy of the stream bytes
|
||||
d.seek(0) # Rewind loaded bytestream
|
||||
# Create a copy of the bytestream bytes
|
||||
data = io.BytesIO(d.getbuffer())
|
||||
else:
|
||||
data = None
|
||||
|
|
@ -226,27 +235,27 @@ class StreamObject(object):
|
|||
return data
|
||||
|
||||
def load_file(self) -> bool:
|
||||
"""Load data stored on disk to the in-memory stream."""
|
||||
"""Load data stored on disk to the in-memory bytestream."""
|
||||
if self.file_exists: # If data file exists
|
||||
with open(self.file, 'rb') as f:
|
||||
self.stream = io.BytesIO(f.read()) # Load bytes from file
|
||||
self.stream.seek(0) # Rewind data bytes again
|
||||
self.bytestream = io.BytesIO(f.read()) # Load bytes from file
|
||||
self.bytestream.seek(0) # Rewind data bytes again
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def save_file(self) -> bool:
|
||||
"""Write the StreamObjects stream to a file."""
|
||||
"""Write the StreamObjects bytestream to a file."""
|
||||
if not self.keep_on_disk: # If capture is currently temporary
|
||||
self.load_file() # Load data from tmp file into stream, if tmp file exists
|
||||
self.load_file() # Load data from tmp file into bytestream, if tmp file exists
|
||||
self.keep_on_disk = True # Flag as kept on disk
|
||||
self.file = self.file_notmp # Reset file path to non-temporary path
|
||||
self.split_file_path(self.file) # Set split properties based on new path
|
||||
logging.info("Moved temporary file out to {}".format(self.file))
|
||||
|
||||
if self.stream_exists: # If there's a stream to save
|
||||
if self.stream_exists: # If there's a bytestream to save
|
||||
with open(self.file, 'ab') as f: # Load file as bytes
|
||||
logging.debug("Writing stream to file {}".format(self.file))
|
||||
logging.debug("Writing bytestream 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
|
||||
|
|
@ -254,8 +263,8 @@ class StreamObject(object):
|
|||
return False
|
||||
|
||||
def delete_stream(self):
|
||||
"""Clear the BytesIO stream of the StreamObject."""
|
||||
self.stream = io.BytesIO()
|
||||
"""Clear the BytesIO bytestream of the StreamObject."""
|
||||
self.bytestream = io.BytesIO()
|
||||
|
||||
def delete_file(self) -> bool:
|
||||
"""If the StreamObject has been saved, delete the file."""
|
||||
|
|
@ -275,11 +284,11 @@ class StreamObject(object):
|
|||
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
|
||||
self.save_file() # Save bytestream to disk, if it exists
|
||||
self.delete_stream() # Delete the bytestream from memory
|
||||
|
||||
def close(self):
|
||||
"""Both clear the stream, and delete any associated on-disk data."""
|
||||
"""Both clear the bytestream, and delete any associated on-disk data."""
|
||||
logging.info("Closing {}".format(self.id))
|
||||
self.delete_stream()
|
||||
if not self.keep_on_disk:
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ from typing import Tuple
|
|||
# Threading
|
||||
import threading
|
||||
|
||||
from .base import BaseCamera, StreamObject
|
||||
from .base import BaseCamera, CaptureObject
|
||||
# Richard's fix gain
|
||||
from .set_picamera_gain import set_analog_gain, set_digital_gain
|
||||
|
||||
|
|
@ -283,52 +283,40 @@ class StreamingCamera(BaseCamera):
|
|||
|
||||
def start_recording(
|
||||
self,
|
||||
target=None,
|
||||
write_to_file: bool=True,
|
||||
filename: str=None,
|
||||
output,
|
||||
fmt: str='h264',
|
||||
quality: int=15):
|
||||
"""Start recording.
|
||||
|
||||
Start a new video recording, writing to a target object.
|
||||
Start a new video recording, writing to a output object.
|
||||
|
||||
Args:
|
||||
target (str/BytesIO): Target object to write bytes to.
|
||||
output (CaptureObject): Output object to write data bytes to.
|
||||
write_to_file (bool/NoneType): Should the StreamObject write to a file?
|
||||
filename (str): Name of the stored file. Defaults to timestamp.
|
||||
fmt (str): Format of the capture.
|
||||
|
||||
Returns:
|
||||
target_object (str/BytesIO): Target object.
|
||||
output_object (str/BytesIO): Target object.
|
||||
|
||||
"""
|
||||
# Start recording method only if a current recording is not running
|
||||
if not self.state['record_active']:
|
||||
|
||||
# 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=self.paths['video'],
|
||||
fmt=fmt)
|
||||
)
|
||||
|
||||
# If output is a StreamObject
|
||||
if isinstance(output, CaptureObject):
|
||||
# Lock the StreamObject while recording
|
||||
target_obj.lock()
|
||||
# Store to the StreamObject target
|
||||
target = target_obj.target
|
||||
|
||||
output.lock()
|
||||
# Set target to capture stream
|
||||
output_stream = output.stream
|
||||
else:
|
||||
target_obj = target
|
||||
output_stream = output
|
||||
|
||||
# Start the camera video recording on port 2
|
||||
logging.info("Recording to {}".format(target))
|
||||
logging.info("Recording to {}".format(output))
|
||||
|
||||
self.camera.start_recording(
|
||||
target,
|
||||
output_stream,
|
||||
format=fmt,
|
||||
splitter_port=2,
|
||||
resize=self.config['video_resolution'],
|
||||
|
|
@ -337,7 +325,7 @@ class StreamingCamera(BaseCamera):
|
|||
# Update state dictionary
|
||||
self.state['record_active'] = True
|
||||
|
||||
return target_obj
|
||||
return output
|
||||
|
||||
else:
|
||||
print(
|
||||
|
|
@ -404,7 +392,7 @@ class StreamingCamera(BaseCamera):
|
|||
|
||||
def capture(
|
||||
self,
|
||||
target=None,
|
||||
output,
|
||||
write_to_file: bool=False,
|
||||
keep_on_disk: bool=True,
|
||||
use_video_port: bool=False,
|
||||
|
|
@ -418,7 +406,7 @@ class StreamingCamera(BaseCamera):
|
|||
Target object can be overridden for development purposes.
|
||||
|
||||
Args:
|
||||
target (str/BytesIO): Target object to write data bytes to.
|
||||
output (CaptureObject/str): Output object to write data bytes to.
|
||||
write_to_file (bool): Should the StreamObject write to a file, instead of BytesIO stream?
|
||||
use_video_port (bool): Capture from the video port used for streaming. Lower resolution, faster.
|
||||
filename (str): Name of the stored file. Defaults to timestamp.
|
||||
|
|
@ -426,29 +414,14 @@ class StreamingCamera(BaseCamera):
|
|||
resize ((int, int)): Resize the captured image.
|
||||
"""
|
||||
|
||||
# If no filename is specified, build a non-clashing one
|
||||
if not filename:
|
||||
filename = self.generate_basename(self.images)
|
||||
logging.debug(filename)
|
||||
|
||||
# If no target is specified, store to StreamingCamera
|
||||
if not target:
|
||||
# TODO: Handle clashing file names here instead of in capture method.
|
||||
# Create a new image and add to the image list
|
||||
target_obj = self.new_image(
|
||||
StreamObject(
|
||||
write_to_file=write_to_file,
|
||||
keep_on_disk=keep_on_disk,
|
||||
filename=filename,
|
||||
folder=self.paths['image'],
|
||||
fmt=fmt)
|
||||
)
|
||||
target = target_obj.target # Store to the StreamObject BytesIO
|
||||
|
||||
# If output is a StreamObject
|
||||
if isinstance(output, CaptureObject):
|
||||
# Set target to capture stream
|
||||
output_stream = output.stream
|
||||
else:
|
||||
target_obj = target
|
||||
output_stream = output
|
||||
|
||||
logging.info("Capturing to {}".format(target))
|
||||
logging.info("Capturing to {}".format(output))
|
||||
|
||||
if not use_video_port:
|
||||
|
||||
|
|
@ -456,7 +429,7 @@ class StreamingCamera(BaseCamera):
|
|||
self.pause_stream()
|
||||
|
||||
self.camera.capture(
|
||||
target,
|
||||
output_stream,
|
||||
format=fmt,
|
||||
quality=100,
|
||||
resize=resize,
|
||||
|
|
@ -467,14 +440,14 @@ class StreamingCamera(BaseCamera):
|
|||
|
||||
else:
|
||||
self.camera.capture(
|
||||
target,
|
||||
output_stream,
|
||||
format=fmt,
|
||||
quality=100,
|
||||
resize=resize,
|
||||
bayer=False,
|
||||
use_video_port=True)
|
||||
|
||||
return target_obj
|
||||
return output
|
||||
|
||||
def yuv(
|
||||
self,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue