Allow log of multiple captures by StreamingCamera
This commit is contained in:
Joel Collins
parent
8031327a5b
commit
d99602bd3d
3 changed files with 261 additions and 145 deletions
|
|
@ -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."""
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue