Computer Vision Projekte

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# GPU-Support prüfen
print("GPU available:", tf.config.list_physical_devices('GPU'))

# Datenaugmentation für bessere Generalisierung
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2,
    validation_split=0.2
)

test_datagen = ImageDataGenerator(rescale=1./255)

# Daten laden (angenommen: dogs-vs-cats Dataset)
train_generator = train_datagen.flow_from_directory(
    'data/train',
    target_size=(150, 150),
    batch_size=32,
    class_mode='binary',
    subset='training'
)

validation_generator = train_datagen.flow_from_directory(
    'data/train',
    target_size=(150, 150),
    batch_size=32,
    class_mode='binary',
    subset='validation'
)

print(f"Gefundene Klassen: {train_generator.class_indices}")
print(f"Trainingsbilder: {train_generator.samples}")
print(f"Validierungsbilder: {validation_generator.samples}")

# CNN-Architektur definieren
model = models.Sequential([
    # Erste Convolution-Schicht
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
    layers.MaxPooling2D(2, 2),
    
    # Zweite Convolution-Schicht
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    
    # Dritte Convolution-Schicht
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    
    # Vierte Convolution-Schicht
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    
    # Flatten für Dense Layer
    layers.Flatten(),
    
    # Dropout gegen Overfitting
    layers.Dropout(0.5),
    
    # Dense Layer
    layers.Dense(512, activation='relu'),
    
    # Output Layer (binäre Klassifikation)
    layers.Dense(1, activation='sigmoid')
])

# Modell kompilieren
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Modell-Architektur anzeigen
model.summary()

import cv2
import numpy as np
import argparse

class YOLODetector:
    def __init__(self, weights_path, config_path, names_path):
        # YOLO-Netzwerk laden
        self.net = cv2.dnn.readNet(weights_path, config_path)
        
        # Klassennamen laden
        with open(names_path, 'r') as f:
            self.classes = [line.strip() for line in f.readlines()]
        
        # Output-Layer bestimmen
        layer_names = self.net.getLayerNames()
        self.output_layers = [layer_names[i[0] - 1] for i in self.net.getUnconnectedOutLayers()]
        
        # Farben für Bounding Boxes
        self.colors = np.random.uniform(0, 255, size=(len(self.classes), 3))
    
    def detect_objects(self, image, confidence_threshold=0.5, nms_threshold=0.4):
        height, width, channels = image.shape
        
        # Bild für YOLO vorbereiten
        blob = cv2.dnn.blobFromImage(
            image, scalefactor=1/255.0, size=(416, 416), 
            mean=(0, 0, 0), swapRB=True, crop=False
        )
        
        # Forward Pass
        self.net.setInput(blob)
        outputs = self.net.forward(self.output_layers)
        
        # Erkennungen verarbeiten
        boxes, confidences, class_ids = [], [], []
        
        for output in outputs:
            for detection in output:
                scores = detection[5:]
                class_id = np.argmax(scores)
                confidence = scores[class_id]
                
                if confidence > confidence_threshold:
                    # Bounding Box Koordinaten
                    center_x = int(detection[0] * width)
                    center_y = int(detection[1] * height)
                    w = int(detection[2] * width)
                    h = int(detection[3] * height)
                    
                    # Box-Koordinaten berechnen
                    x = int(center_x - w / 2)
                    y = int(center_y - h / 2)
                    
                    boxes.append([x, y, w, h])
                    confidences.append(float(confidence))
                    class_ids.append(class_id)
        
        # Non-Maximum Suppression
        indices = cv2.dnn.NMSBoxes(boxes, confidences, confidence_threshold, nms_threshold)
        
        return boxes, confidences, class_ids, indices
    
    def draw_detections(self, image, boxes, confidences, class_ids, indices):
        if len(indices) > 0:
            for i in indices.flatten():
                x, y, w, h = boxes[i]
                
                # Klasse und Konfidenz
                label = f"{self.classes[class_ids[i]]}: {confidences[i]:.2f}"
                color = self.colors[class_ids[i]]
                
                # Bounding Box zeichnen
                cv2.rectangle(image, (x, y), (x + w, y + h), color, 2)
                cv2.putText(
                    image, label, (x, y - 10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2
                )
        
        return image

import face_recognition
import cv2
import numpy as np
import os
import pickle
from datetime import datetime

class FaceRecognitionSystem:
    def __init__(self):
        self.known_face_encodings = []
        self.known_face_names = []
        self.face_locations = []
        self.face_encodings = []
        self.face_names = []
        
    def load_known_faces(self, faces_dir):
        """Bekannte Gesichter aus Ordner laden"""
        print("Lade bekannte Gesichter...")
        
        for filename in os.listdir(faces_dir):
            if filename.endswith(('.jpg', '.jpeg', '.png')):
                # Bild laden
                image_path = os.path.join(faces_dir, filename)
                image = face_recognition.load_image_file(image_path)
                
                # Gesichts-Encoding extrahieren
                face_encodings = face_recognition.face_encodings(image)
                
                if face_encodings:
                    # Name aus Dateiname extrahieren
                    name = os.path.splitext(filename)[0]
                    
                    self.known_face_encodings.append(face_encodings[0])
                    self.known_face_names.append(name)
                    print(f"Gesicht geladen: {name}")
                else:
                    print(f"Kein Gesicht gefunden in: {filename}")
    
    def save_encodings(self, filepath):
        """Encodings speichern"""
        data = {
            'encodings': self.known_face_encodings,
            'names': self.known_face_names
        }
        with open(filepath, 'wb') as f:
            pickle.dump(data, f)
        print(f"Encodings gespeichert in: {filepath}")
    
    def load_encodings(self, filepath):
        """Encodings laden"""
        try:
            with open(filepath, 'rb') as f:
                data = pickle.load(f)
            self.known_face_encodings = data['encodings']
            self.known_face_names = data['names']
            print(f"Encodings geladen von: {filepath}")
            return True
        except FileNotFoundError:
            print(f"Encodings-Datei nicht gefunden: {filepath}")
            return False
    
    def recognize_faces_in_image(self, image):
        """Gesichter in einem Bild erkennen"""
        # Bild von BGR zu RGB konvertieren
        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        
        # Gesichter finden und encodieren
        face_locations = face_recognition.face_locations(rgb_image)
        face_encodings = face_recognition.face_encodings(rgb_image, face_locations)
        
        face_names = []
        for face_encoding in face_encodings:
            # Gesicht mit bekannten Gesichtern vergleichen
            matches = face_recognition.compare_faces(
                self.known_face_encodings, face_encoding, tolerance=0.6
            )
            name = "Unbekannt"
            
            # Beste Übereinstimmung finden
            face_distances = face_recognition.face_distance(
                self.known_face_encodings, face_encoding
            )
            
            if matches and len(face_distances) > 0:
                best_match_index = np.argmin(face_distances)
                if matches[best_match_index]:
                    name = self.known_face_names[best_match_index]
            
            face_names.append(name)
        
        return face_locations, face_names