Files
inkscape.calibrationDecoupe…/raspberry/capture_server.py
T
2026-09-27 16:29:43 +02:00

128 lines
4.0 KiB
Python

"""
Serveur Flask pour prendre une photo à distance avec une webcam USB (ex. Creative)
sur Raspberry Pi, dans la meilleure résolution supportée par la caméra.
Prérequis :
sudo apt install v4l-utils python3-opencv python3-flask
"""
import re
import subprocess
import threading
import cv2
from flask import Flask, jsonify, send_file
app = Flask(__name__)
PHOTO_PATH = "/tmp/photo.jpg"
DEVICE = 0 # /dev/video0
WARMUP_FRAMES = 15 # images jetées le temps que l'auto-exposition / balance des blancs se stabilise
JPEG_QUALITY = 95 # 0-100 (OpenCV met 95 par défaut, 100 = fichier plus gros)
camera_lock = threading.Lock() # évite deux accès simultanés à la caméra
_best_mode = None # cache : (largeur, hauteur, fourcc)
def get_best_mode():
"""Interroge la caméra via v4l2-ctl et retourne la plus grande résolution
supportée, avec le format (MJPG ou YUYV) qui la permet."""
global _best_mode
if _best_mode:
return _best_mode
best = None # (pixels, largeur, hauteur, fourcc)
try:
out = subprocess.run(
["v4l2-ctl", "-d", f"/dev/video{DEVICE}", "--list-formats-ext"],
capture_output=True, text=True, timeout=5,
).stdout
fmt = None
for line in out.splitlines():
m = re.search(r"\[\d+\]:\s*'(\w{4})'", line)
if m:
fmt = m.group(1)
continue
m = re.search(r"Size: Discrete (\d+)x(\d+)", line)
if m and fmt:
w, h = int(m.group(1)), int(m.group(2))
candidate = (w * h, w, h, fmt)
# À résolution égale, on préfère MJPG (moins de bande passante USB)
if (best is None or candidate[0] > best[0]
or (candidate[0] == best[0] and fmt == "MJPG")):
best = candidate
except (FileNotFoundError, subprocess.TimeoutExpired):
pass
if best:
_best_mode = (best[1], best[2], best[3])
else:
# Repli : on demande une résolution énorme, le pilote choisira le max possible
_best_mode = (9999, 9999, "MJPG")
return _best_mode
def capture():
"""Prend une photo à la résolution max et l'enregistre dans PHOTO_PATH.
Retourne la résolution réellement obtenue."""
width, height, fourcc = get_best_mode()
with camera_lock:
cam = cv2.VideoCapture(DEVICE, cv2.CAP_V4L2)
if not cam.isOpened():
raise RuntimeError("Impossible d'accéder à la caméra")
try:
# Le format doit être défini AVANT la résolution
cam.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*fourcc))
cam.set(cv2.CAP_PROP_FRAME_WIDTH, width)
cam.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
cam.set(cv2.CAP_PROP_BUFFERSIZE, 1)
# Laisser l'auto-exposition / le focus se régler
for _ in range(WARMUP_FRAMES):
cam.grab()
ret, frame = cam.read()
if not ret or frame is None:
raise RuntimeError("Échec de la capture")
real_w = int(cam.get(cv2.CAP_PROP_FRAME_WIDTH))
real_h = int(cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
finally:
cam.release()
cv2.imwrite(PHOTO_PATH, frame, [cv2.IMWRITE_JPEG_QUALITY, JPEG_QUALITY])
return real_w, real_h
@app.route("/photo")
def take_photo():
try:
w, h = capture()
except RuntimeError as e:
return str(e), 500
return jsonify(status="ok", width=w, height=h, path=PHOTO_PATH)
@app.route("/capture")
def capture_photo():
try:
capture()
except RuntimeError as e:
return str(e), 500
return send_file(PHOTO_PATH, mimetype="image/jpeg")
@app.route("/old")
def use_old_photo():
return send_file(PHOTO_PATH, mimetype="image/jpeg")
@app.route("/info")
def info():
w, h, fourcc = get_best_mode()
return jsonify(width=w, height=h, format=fourcc)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, threaded=True)