Private
Public Access
134 lines
4.5 KiB
Python
134 lines
4.5 KiB
Python
"""Ein Kameraproduzent für mehrere Livebild-Betrachter."""
|
|
|
|
from collections import deque
|
|
from io import BytesIO
|
|
import threading
|
|
import time
|
|
from datetime import datetime
|
|
|
|
from PIL import Image, ImageDraw
|
|
|
|
|
|
class CameraStream:
|
|
TARGET_FPS = 15
|
|
def __init__(self, demo: bool = False):
|
|
self.demo = demo
|
|
self._condition = threading.Condition()
|
|
self._thread = None
|
|
self._stop = threading.Event()
|
|
self._frame = None
|
|
self._number = 0
|
|
self._frame_times = deque(maxlen=45)
|
|
self._time = None
|
|
self.error = None
|
|
|
|
def start(self):
|
|
if self._thread is not None:
|
|
return
|
|
self._thread = threading.Thread(target=self._run, daemon=True, name="camera")
|
|
self._thread.start()
|
|
|
|
def stop(self):
|
|
self._stop.set()
|
|
with self._condition:
|
|
self._condition.notify_all()
|
|
if self._thread is not None:
|
|
self._thread.join(timeout=3)
|
|
|
|
@staticmethod
|
|
def _jpeg(image: Image.Image) -> bytes:
|
|
buffer = BytesIO()
|
|
image.save(buffer, format="JPEG", quality=75)
|
|
return buffer.getvalue()
|
|
|
|
def _publish(self, frame: bytes):
|
|
with self._condition:
|
|
self._frame = frame
|
|
self._number += 1
|
|
self._time = time.monotonic()
|
|
self._frame_times.append(self._time)
|
|
self._condition.notify_all()
|
|
|
|
def _run(self):
|
|
try:
|
|
if self.demo:
|
|
self._run_demo()
|
|
else:
|
|
self._run_pi()
|
|
except Exception as exc:
|
|
with self._condition:
|
|
self.error = f"Kamera nicht verfügbar: {type(exc).__name__}: {exc}"
|
|
self._condition.notify_all()
|
|
|
|
def _run_demo(self):
|
|
while not self._stop.is_set():
|
|
image = Image.new("RGB", (640, 480), (21, 28, 32))
|
|
draw = ImageDraw.Draw(image)
|
|
draw.rectangle((40, 105, 600, 400), outline=(144, 111, 65), width=8)
|
|
draw.ellipse((165, 205, 475, 340), fill=(45, 52, 36), outline=(110, 91, 59), width=4)
|
|
draw.text((42, 30), "DEMO - KEINE ECHTE KAMERA", fill=(255, 172, 72))
|
|
draw.text((42, 440), datetime.now().strftime("%Y-%m-%d %H:%M:%S"), fill="white")
|
|
self._publish(self._jpeg(image))
|
|
self._stop.wait(0.2)
|
|
|
|
def _run_pi(self):
|
|
from picamera2 import Picamera2
|
|
|
|
camera = Picamera2()
|
|
started = False
|
|
try:
|
|
# BGR888 liefert laut Picamera2-Dokumentation RGB-Arrays für PIL.
|
|
config = camera.create_video_configuration(
|
|
main={"size": (640, 480), "format": "BGR888"},
|
|
controls={"FrameDurationLimits": (66667, 66667)}, queue=False
|
|
)
|
|
camera.configure(config)
|
|
camera.start()
|
|
started = True
|
|
while not self._stop.is_set():
|
|
began = time.monotonic()
|
|
pixels = camera.capture_array("main")
|
|
self._publish(self._jpeg(Image.fromarray(pixels, "RGB")))
|
|
self._stop.wait(max(0., 1/self.TARGET_FPS-(time.monotonic()-began)))
|
|
finally:
|
|
try:
|
|
if started:
|
|
camera.stop()
|
|
finally:
|
|
camera.close()
|
|
|
|
def latest(self):
|
|
with self._condition:
|
|
return self._frame
|
|
|
|
def latest_numbered(self):
|
|
with self._condition:
|
|
return self._number, self._frame
|
|
|
|
def latest_timed(self):
|
|
with self._condition:
|
|
return self._number, self._frame, self._time
|
|
|
|
def wait_next(self, number: int, timeout: float = 10):
|
|
with self._condition:
|
|
self._condition.wait_for(
|
|
lambda: self._number > number or self.error or self._stop.is_set(),
|
|
timeout=timeout,
|
|
)
|
|
return self._number, self._frame
|
|
|
|
def status(self):
|
|
with self._condition:
|
|
age = None if self._time is None else round(time.monotonic() - self._time, 1)
|
|
times = self._frame_times
|
|
fps = ((len(times)-1)/(times[-1]-times[0])
|
|
if len(times)>1 and times[-1]>times[0] and age is not None and age<1 else 0.)
|
|
return {
|
|
"fps": round(fps, 1),
|
|
"target_fps": 5 if self.demo else self.TARGET_FPS,
|
|
"source": "Demo" if self.demo else "Pi-Kamera",
|
|
"ready": self._frame is not None and age is not None and age < 3,
|
|
"frame_age_seconds": age,
|
|
"error": self.error,
|
|
}
|