import os
from gpt4all import GPT4All
import keyboard

# Modell initialisieren
model = GPT4All("em_german_mistral_v01.Q4_0.gguf")

# Eingabeaufforderung für Titel abfragen
titel = input("Titel/Dateiname: ")

# Eingabeaufforderung für Anweisung abfragen
eingabeaufforderung = input("Hier bitte die Anweisung eintragen und mit Enter bestätigen: ")

# Ordner "output" erstellen, wenn er nicht existiert
output_ordner = "output"
if not os.path.exists(output_ordner):
    os.makedirs(output_ordner)

# Generierung der Texte 10-mal durchlaufen lassen
for i in range(1, 11):
    # Ausgabe generieren
    output = model.generate(eingabeaufforderung, max_tokens=5000)
    
    # Output in eine Datei im Ordner "output" speichern
    output_dateipfad = os.path.join(output_ordner, f"{titel}_{i}.txt")
    with open(output_dateipfad, "w", encoding="utf-8") as datei:
        datei.write(output)

    # Ausgabe anzeigen
    print(f"Output wurde unter dem Titel '{titel}_{i}' im Ordner 'output' gespeichert.")

import cv2
import numpy as np
import os
import matplotlib.pyplot as plt

def process_frame(frame, threshold, grid_size, face_cascade):
    # Wandle das Bild in Graustufen um
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Suche nach Gesichtern im Bild
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)

    noise_frames = []

    # Wenn Gesichter gefunden wurden, sortiere sie nach Größe
    if len(faces) > 0:
        # Sortiere Gesichter nach Fläche (Größe)
        faces = sorted(faces, key=lambda x: x[2] * x[3], reverse=True)

        # Verwende nur das größte Gesicht
        (x, y, w, h) = faces[0]

        # Begrenze die Bildverarbeitung auf das Gesicht (ROI)
        face_roi = frame[y:y+h, x:x+w]

        # Teile das Gesicht in Bereiche auf
        regions = np.array_split(face_roi, grid_size[0], axis=0)
        regions = [np.array_split(region, grid_size[1], axis=1) for region in regions]

        std_deviations = [[np.std(region) for region in row] for row in regions]

        # Berechne den Durchschnitt des Pixelrauschens in der Gesichtsregion
        face_avg_noise = np.mean(std_deviations)

        for i, row in enumerate(std_deviations):
            for j, std_deviation in enumerate(row):
                # Vergleiche das Pixelrauschen mit dem Durchschnitt der Gesichtsregion
                if std_deviation > threshold * face_avg_noise:
                    noise_frames.append((i, j, (x, y, w, h)))

                    # Zeichne einen Rahmen um den erkannten Bereich
                    y_start = int(y + i * h / grid_size[0])
                    y_end = int(y + (i + 1) * h / grid_size[0])
                    x_start = int(x + j * w / grid_size[1])
                    x_end = int(x + (j + 1) * w / grid_size[1])

                    cv2.rectangle(frame, (x_start, y_start), (x_end, y_end), (0, 0, 255), 2)

    return noise_frames, frame

def detect_noise(video_path, threshold=1.5, grid_size=(50, 50), top_n_frames=5):
    # Erstelle den Ausgabeordner, falls er nicht existiert
    output_folder = "analyse/video"
    os.makedirs(output_folder, exist_ok=True)

    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    video_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    video_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    frame_number = 0
    noise_frames = []

    # Lade den Gesichts-Kaskadenklassifikator von OpenCV
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

    # Extrahiere den Dateinamen ohne Pfad und Erweiterung
    file_name = os.path.splitext(os.path.basename(video_path))[0]

    # Erstelle einen VideoWriter für die Ausgabe mit dem angepassten Dateinamen
    output_video_path = os.path.join(output_folder, f"{file_name}_analyzed.mp4")
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_video_path, fourcc, fps, (video_width, video_height))

    # Erstelle ein Fenster für die Anzeige
    cv2.namedWindow("Frame", cv2.WINDOW_NORMAL)

    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    total_noise_frames = 0
    top_n_frames_info = []

    # Zusätzliche Variable für statistische Analyse
    frame_with_noise_count = np.zeros(total_frames)

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        # Führe die Bildverarbeitung in einem Thread aus
        noise_frames, frame_with_annotations = process_frame(frame.copy(), threshold, grid_size, face_cascade)

        # Schriftformausgabe im Video
        cv2.putText(frame_with_annotations, f"Pixelrauschen: {len(noise_frames)}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)

        # Schreibe den aktuellen Frame in die Ausgabedatei
        out.write(frame_with_annotations)

        # Zeige das aktuelle Frame in einem Fenster an
        cv2.imshow("Frame", frame_with_annotations)

        # Berechne Statistiken
        total_noise_frames += len(noise_frames)
        if len(noise_frames) > top_n_frames:
            top_n_frames_info.append((frame_number, len(noise_frames)))

        # Speichere die Anzahl der Auffälligkeiten für jedes Frame
        frame_with_noise_count[frame_number] = len(noise_frames)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

        frame_number += 1

    cap.release()
    out.release()
    cv2.destroyAllWindows()

    print(f"Analysevideo wurde gespeichert unter: {output_video_path}")
    print(f"Durchschnittliche Anzahl der Rauschframes pro Frame: {total_noise_frames / total_frames}")
    print(f"Durchschnittliche Anzahl der Rauschframes pro Sekunde: {total_noise_frames / fps}")

    # Statistik für die N frames mit den meisten Auffälligkeiten
    print(f"\nTop {top_n_frames} Frames mit den meisten Auffälligkeiten:")
    for idx, (frame_num, num_auffaelligkeiten) in enumerate(sorted(top_n_frames_info, key=lambda x: x[1], reverse=True)[:top_n_frames]):
        print(f"Frame Nummer: {frame_num}, Auffälligkeiten: {num_auffaelligkeiten}")

    # Zeichnen Sie ein Diagramm der zeitlichen Verteilung der Auffälligkeiten
    plt.plot(frame_with_noise_count)
    plt.xlabel('Frame Nummer')
    plt.ylabel('Anzahl der Auffälligkeiten')
    plt.title('Zeitliche Verteilung der Auffälligkeiten')
    plt.show()

# Beispielaufruf
video_path = input("Geben Sie den Pfad zur Videodatei ein: ")
detect_noise(video_path)

import sounddevice as sd
import numpy as np
from scipy.io.wavfile import write
import os
import subprocess
import pyttsx3
import time
import pyperclip
import pyautogui

def transkription_und_uebersetzung(aufnahme_dateiname):
    # Führe die Transkription durch
    command_transkrip = f"whisper {aufnahme_dateiname} --device cuda --model medium --output_dir transkrip"
    os.system(command_transkrip)

    # Führe die Übersetzung durch
    command_transl = f"whisper {aufnahme_dateiname} --device cuda --model medium --output_dir transl --task translate"
    os.system(command_transl)

# Konfiguration der Aufnahme
fs = 44100  # Abtastrate (Samples pro Sekunde)

# Starte die kontinuierliche Aufnahme
aufnahme = sd.InputStream(samplerate=fs, channels=1, dtype='int16')
aufnahme.start()

buffer = []
recording = True

print("Bitte sprechen Sie etwas ins Mikrofon...")

try:
    while recording:
        # Lies die aktuellen Audiodaten
        audiodaten, _ = aufnahme.read(fs)

        # Füge die aktuellen Audiodaten zum Puffer hinzu
        buffer.extend(audiodaten)

        # Überprüfe, ob der Puffer zu groß ist (2 Sekunden Stille)
        if len(buffer) > fs * 20:
            recording = False

except KeyboardInterrupt:
    print("\nAufnahme manuell gestoppt.")

finally:
    # Stoppe die Aufnahme
    aufnahme.stop()

    # Konvertiere den Buffer zu einem NumPy-Array
    buffer = np.array(buffer)

    # Speichern der Aufnahme als WAV-Datei mit fester Bezeichnung "aufnahme.wav"
    aufnahme_dateiname = "aufnahme.wav"
    write(aufnahme_dateiname, fs, buffer)

    # Führe die restlichen Befehle aus
    transkription_und_uebersetzung(aufnahme_dateiname)

    print("Aufnahme, Transkription und Übersetzung abgeschlossen.")

    # Wechsle zum Ordner "transl"
    transl_ordner = "transkrip"
    os.chdir(transl_ordner)

    # Lese den Inhalt der Datei "aufnahme.txt"
    ergebnis_dateiname = "aufnahme.txt"
    with open(ergebnis_dateiname, 'r', encoding='utf-8') as file:
        inhalt = file.read()

    print(f"Inhalt der Datei {ergebnis_dateiname}:\n{inhalt}")

    # Vorlesen des Inhalts per Audio
    text_to_speech = pyttsx3.init()
    text_to_speech.say(inhalt)
    text_to_speech.runAndWait()

    # Warte für eine kurze Zeit, damit das Vorlesen abgeschlossen werden kann
    time.sleep(2)

# Lese den Inhalt der Datei "aufnahme.txt"
ergebnis_dateiname = "aufnahme.txt"
with open(ergebnis_dateiname, 'r', encoding='utf-8') as file:
    inhalt = file.read()

print(f"Inhalt der Datei {ergebnis_dateiname}:\n{inhalt}")

# Kopiere den Text in die Zwischenablage
pyperclip.copy(inhalt)

# Füge den Text an der aktuellen Cursorposition ein (zum Beispiel durch Tastenkombination Strg+V)
pyautogui.hotkey('ctrl', 'v')

print("Text wurde an der aktuellen Cursorposition eingefügt.")