infinicode 2.8.13 → 2.8.16

package/packages/robopark/vision/app_pi_clean.py

@@ -0,0 +1,326 @@
+from flask import Flask, Response, jsonify, request
+from flask_cors import CORS
+import argparse
+import cv2
+import os
+import time
+import numpy as np
+import threading
+import requests
+import base64
+
+app = Flask(__name__)
+CORS(app)
+
+# Camera management
+current_camera_index = 0
+camera = None
+
+def get_camera():
+    global camera, current_camera_index
+    if camera is None or not camera.isOpened():
+        camera = cv2.VideoCapture(current_camera_index)
+        camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+        camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+        print(f"Camera {current_camera_index} initialized")
+    return camera
+
+# Global variables
+latest_detections = []
+lock = threading.Lock()
+caption_mode_enabled = False
+motion_detection_active = False
+motion_detected_state = False
+last_motion_time = 0
+motion_frame_buffer = None
+webhook_url = None
+last_webhook_send_time = 0
+webhook_send_interval = 0.5
+
+# Simple object detection using OpenCV DNN (MobileNet SSD)
+try:
+    # Load pre-trained MobileNet SSD model
+    net = cv2.dnn.readNetFromCaffe(
+        'deploy.prototxt',
+        'mobilenet_iter_73000.caffemodel'
+    )
+    DETECTION_AVAILABLE = True
+    print("Object detection model loaded")
+except:
+    DETECTION_AVAILABLE = False
+    print("Object detection model not found - running without detection")
+
+# COCO class labels
+CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
+    "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
+    "dog", "horse", "motorbike", "person", "pottedplant", "sheep",
+    "sofa", "train", "tvmonitor"]
+
+def detect_objects(frame, conf_threshold=0.5):
+    """Detect objects using OpenCV DNN"""
+    if not DETECTION_AVAILABLE:
+        return frame, []
+
+    (h, w) = frame.shape[:2]
+    blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5)
+    net.setInput(blob)
+    detections_dnn = net.forward()
+
+    detected_objects = []
+
+    for i in range(detections_dnn.shape[2]):
+        confidence = detections_dnn[0, 0, i, 2]
+
+        if confidence > conf_threshold:
+            idx = int(detections_dnn[0, 0, i, 1])
+            if idx >= len(CLASSES):
+                continue
+
+            box = detections_dnn[0, 0, i, 3:7] * np.array([w, h, w, h])
+            (startX, startY, endX, endY) = box.astype("int")
+
+            label = CLASSES[idx]
+
+            # Draw bounding box
+            cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2)
+
+            # Draw label with confidence
+            text = f"{label}: {confidence*100:.1f}%"
+            y = startY - 15 if startY - 15 > 15 else startY + 15
+            cv2.putText(frame, text, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+
+            detected_objects.append({
+                "label": label,
+                "confidence": float(confidence),
+                "bbox": [int(startX), int(startY), int(endX), int(endY)],
+                "is_focus": False
+            })
+
+    return frame, detected_objects
+
+def send_webhook(frame_data):
+    """Send frame to webhook URL"""
+    global webhook_url, last_webhook_send_time
+
+    if not webhook_url:
+        return
+
+    current_time = time.time()
+    if current_time - last_webhook_send_time < webhook_send_interval:
+        return
+
+    try:
+        _, buffer = cv2.imencode('.jpg', frame_data)
+        img_base64 = base64.b64encode(buffer).decode('utf-8')
+
+        payload = {
+            'timestamp': time.strftime('%Y-%m-%dT%H:%M:%S'),
+            'image': img_base64,
+            'format': 'jpeg',
+            'encoding': 'base64'
+        }
+
+        def send_async():
+            try:
+                response = requests.post(webhook_url, json=payload, headers={'Content-Type': 'application/json'}, timeout=5)
+                if response.status_code == 200:
+                    print(f"Webhook sent successfully")
+            except Exception as e:
+                print(f"Webhook error: {e}")
+
+        thread = threading.Thread(target=send_async, daemon=True)
+        thread.start()
+        last_webhook_send_time = current_time
+    except Exception as e:
+        print(f"Error preparing webhook: {e}")
+
+def generate_frames():
+    global latest_detections, motion_detection_active, motion_detected_state
+    global last_motion_time, motion_frame_buffer
+
+    prev_gray = None
+
+    while True:
+        cam = get_camera()
+        if cam is None or not cam.isOpened():
+            time.sleep(1)
+            continue
+
+        success, frame = cam.read()
+        if not success:
+            time.sleep(0.1)
+            continue
+
+        # Run object detection
+        processed_frame, detections = detect_objects(frame, conf_threshold=0.5)
+
+        with lock:
+            latest_detections = detections
+
+        # Motion detection logic
+        if motion_detection_active:
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            gray = cv2.GaussianBlur(gray, (21, 21), 0)
+
+            if prev_gray is not None:
+                frame_delta = cv2.absdiff(prev_gray, gray)
+                thresh = cv2.threshold(frame_delta, 25, 255, cv2.THRESH_BINARY)[1]
+                thresh = cv2.dilate(thresh, None, iterations=2)
+                contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+                motion_detected = False
+                for contour in contours:
+                    if cv2.contourArea(contour) >= 500:
+                        motion_detected = True
+                        (x, y, w, h) = cv2.boundingRect(contour)
+                        cv2.rectangle(processed_frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
+                        break
+
+                if motion_detected:
+                    motion_detected_state = True
+                    last_motion_time = time.time()
+                    motion_frame_buffer = processed_frame.copy()
+                    print(f"Motion detected!")
+                    send_webhook(processed_frame)
+                else:
+                    motion_detected_state = False
+
+            prev_gray = gray
+
+        ret, buffer = cv2.imencode('.jpg', processed_frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
+        frame_bytes = buffer.tobytes()
+
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')
+
+@app.route('/')
+def index():
+    return jsonify({"status": "ok", "message": "RoboVision Pi Server", "version": "1.0"})
+
+@app.route('/video_feed')
+def video_feed():
+    return Response(generate_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+@app.route('/api/detections')
+def get_detections():
+    with lock:
+        return jsonify(latest_detections)
+
+@app.route('/api/caption')
+def get_caption():
+    return jsonify({"caption": "Awaiting caption..."})
+
+@app.route('/api/caption_mode', methods=['GET', 'POST'])
+def caption_mode():
+    global caption_mode_enabled
+    if request.method == 'GET':
+        return jsonify({"enabled": caption_mode_enabled})
+    data = request.json or {}
+    caption_mode_enabled = bool(data.get('enabled', False))
+    return jsonify({"enabled": caption_mode_enabled})
+
+@app.route('/api/cameras', methods=['GET'])
+def list_cameras():
+    available = []
+    for i in range(4):
+        cap = cv2.VideoCapture(i)
+        if cap.isOpened():
+            available.append({"index": i, "name": f"Camera {i}"})
+            cap.release()
+    return jsonify({"cameras": available, "current": current_camera_index})
+
+@app.route('/api/camera/switch', methods=['POST'])
+def switch_camera():
+    global camera, current_camera_index
+    data = request.json or {}
+    new_index = int(data.get('index', 0))
+
+    if camera:
+        camera.release()
+
+    current_camera_index = new_index
+    camera = None
+
+    return jsonify({"status": "ok", "camera_index": current_camera_index})
+
+@app.route('/api/motion/status', methods=['GET'])
+def motion_status():
+    global motion_detection_active, motion_detected_state, last_motion_time
+    return jsonify({
+        "active": motion_detection_active,
+        "motion_detected": motion_detected_state,
+        "last_motion": last_motion_time,
+        "time_since_motion": time.time() - last_motion_time if last_motion_time > 0 else None
+    })
+
+@app.route('/api/motion/toggle', methods=['POST'])
+def motion_toggle():
+    global motion_detection_active
+    data = request.json or {}
+    motion_detection_active = bool(data.get('active', False))
+    return jsonify({"status": "success", "active": motion_detection_active})
+
+@app.route('/api/motion/snapshot', methods=['GET'])
+def motion_snapshot():
+    global motion_frame_buffer
+    if motion_frame_buffer is not None:
+        _, buffer = cv2.imencode('.jpg', motion_frame_buffer, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        img_base64 = base64.b64encode(buffer).decode('utf-8')
+        return jsonify({
+            "image": img_base64,
+            "timestamp": time.time()
+        })
+    return jsonify({"error": "No frame available"}), 404
+
+@app.route('/api/motion/webhook', methods=['GET', 'POST'])
+def motion_webhook():
+    global webhook_url
+
+    if request.method == 'GET':
+        return jsonify({
+            "webhook_url": webhook_url or "",
+            "configured": webhook_url is not None and len(webhook_url) > 0
+        })
+
+    data = request.json or {}
+    new_url = data.get('url', '').strip()
+
+    if new_url:
+        webhook_url = new_url
+        return jsonify({
+            "status": "success",
+            "message": "Webhook URL configured",
+            "webhook_url": webhook_url
+        })
+    else:
+        webhook_url = None
+        return jsonify({
+            "status": "success",
+            "message": "Webhook URL cleared",
+            "webhook_url": None
+        })
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="RoboVision — camera/motion detection server")
+    parser.add_argument("--port", type=int, default=int(os.getenv("VISION_PORT", "5000")))
+    parser.add_argument("--motion-webhook-url", default=os.getenv("MOTION_WEBHOOK_URL", ""),
+                         help="where to POST a snapshot when motion is detected, e.g. http://localhost:5057/")
+    parser.add_argument("--motion-active", action="store_true",
+                         default=os.getenv("MOTION_ACTIVE", "").lower() in ("1", "true", "yes"),
+                         help="arm motion detection immediately on startup (no manual /api/motion/toggle call needed)")
+    args = parser.parse_args()
+
+    if args.motion_webhook_url:
+        webhook_url = args.motion_webhook_url
+    if args.motion_active:
+        motion_detection_active = True
+
+    print("=" * 60)
+    print("RoboVision - Raspberry Pi Vision Server (Minimal)")
+    print("=" * 60)
+    print(f"Starting Flask server on http://0.0.0.0:{args.port}")
+    if webhook_url:
+        print(f"Motion webhook: {webhook_url}")
+    print(f"Motion detection: {'ARMED' if motion_detection_active else 'off (POST /api/motion/toggle to arm)'}")
+    print("=" * 60)
+    app.run(host='0.0.0.0', port=args.port, debug=False, threaded=True)