VisionAI: Bilderkennung ohne Cloud — Objektdetektion, OCR & Analyse lokal

💰 Warum lokale Bilderkennung ein Business-Case ist

Google Vision, AWS Rekognition und Azure Computer Vision sind leistungsfähig — aber sie senden Ihre Bilder an US-Cloud-Server. Für Kliniken, Anwaltskanzleien, Produktionsbetriebe und den öffentlichen Sektor ist das datenschutzrechtlich ausgeschlossen. VisionAI beweist: Objektdetektion, OCR und Szenenanalyse funktionieren komplett lokal — mit State-of-the-Art-Qualität.

⚙️ So funktioniert's

Von der Bildeingabe zur Analyse — vollständig offline.

💻 Code-Einblicke

Ein Blick unter die Haube — so liest VisionAI digitale Displays aus Bildern:

🏗️ Architektur

🎥 Haupt-Loop: Kamera + ROI-Verarbeitung

def main():
    rois, camera_index = [], 0

    if os.path.exists("config.json"):
        with open("config.json", 'r') as f:
            data = json.load(f)
        rois = data.get('rois', [])
        camera_index = data.get('camera_index', 0)

    cap = cv2.VideoCapture(camera_index)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 3840)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 2160)

    while True:
        ret, frame = cap.read()
        vis_frame = frame.copy()

        for roi in rois:
            roi_id = roi['id']
            x, y, w, h = roi['rect']

            roi_img = frame[y:y+h, x:x+w]
            gray = cv2.cvtColor(roi_img, cv2.COLOR_BGR2GRAY)

            # Display-Kontur finden + Perspective Transform
            contour = image_utils.find_display_contour(gray)
            if contour is not None:
                warped = image_utils.four_point_transform(
                    gray, contour.reshape(4, 2))
            else:
                warped = gray

            # OCR-Optimierung + Tesseract
            processed = image_utils.preprocess_image(warped)
            text = pytesseract.image_to_string(
                processed, config='--psm 7 outputbase digits')

            # MQTT-Publishing
            payload = {
                "timestamp": datetime.now().isoformat(),
                "id": roi_id,
                "value": text.strip()
            }
            client.publish(f"visionai/meter/{roi_id}",
                          json.dumps(payload))

🖼️ Bildverarbeitung: Perspective Transform & Preprocessing

def four_point_transform(image, pts):
    rect = order_points(pts)
    (tl, tr, br, bl) = rect

    # Neue Bilddimensionen berechnen
    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
    maxWidth = max(int(widthA), int(widthB))

    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
    maxHeight = max(int(heightA), int(heightB))

    dst = np.array([[0, 0], [maxWidth-1, 0],
                    [maxWidth-1, maxHeight-1], [0, maxHeight-1]],
                    dtype="float32")
    M = cv2.getPerspectiveTransform(rect, dst)
    return cv2.warpPerspective(image, M, (maxWidth, maxHeight))

def preprocess_image(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    # CLAHE: Kontrastverstärkung
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    enhanced = clahe.apply(blurred)
    # Adaptive Threshold für optimale OCR
    thresh = cv2.adaptiveThreshold(enhanced, 255,
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
        cv2.THRESH_BINARY, 11, 2)
    return thresh

def find_display_contour(image):
    edged = cv2.Canny(image, 50, 200)
    cnts, _ = cv2.findContours(edged.copy(),
        cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
    cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:5]
    for c in cnts:
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.02 * peri, True)
        if len(approx) == 4:
            return approx
    return None

📡 MQTT-Integration

import paho.mqtt.client as mqtt

MQTT_BROKER = "localhost"
MQTT_PORT = 1883
MQTT_TOPIC = "visionai/meter/reading"

client = mqtt.Client(client_id="VisionAI_Client")

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT Broker!")
    else:
        print(f"Failed to connect, return code {rc}")

client.on_connect = on_connect
client.connect(MQTT_BROKER, MQTT_PORT, 60)
client.loop_start()

# Publishing pro ROI
client.publish(f"visionai/meter/{roi_id}", json_payload)

🚀 Gebaut mit Vibecoding — in Tagen statt Wochen

🗣️ Der System-Prompt hinter diesem Projekt

Du bist ein Experte für Computer Vision und lokale KI-Modelle.

Aufgabe: Erstelle ein lokales Bilderkennungssystem mit Objektdetektion, 
OCR und Szenenanalyse — ohne Cloud-Abhängigkeit.

Technische Anforderungen:
- Python 3.10+, OpenCV für Bildverarbeitung
- YOLO/Ultralytics für Objektdetektion (lokal)
- Tesseract/PaddleOCR für Texterkennung
- Lokale Vision-Transformer für Szenenbeschreibung
- Batch-Verarbeitung für mehrere Bilder

Funktionen:
1. Objektdetektion mit Bounding Boxes und Confidence Scores
2. OCR: Text aus Bildern extrahieren (mehrsprachig)
3. Szenenanalyse: Bildbeschreibung in natürlicher Sprache
4. Visuelle Suche: Ähnliche Bilder in Datenbank finden

Wichtig:
- Alle Modelle laufen komplett lokal — keine Cloud-API
- GPU-Beschleunigung via CUDA (optional)
- REST-API für Integration in bestehende Systeme
- Batch-Modus für Massenverarbeitung
- Export der Ergebnisse als JSON/CSV

🎯 Strategische Erkenntnisse aus diesem Projekt

Computer Vision ist einer der wirtschaftlichsten KI-Anwendungsfälle — wenn sie lokal läuft.