Meine ersten Skills:

Bildanalyse mit Excel-Ausgabe – Ein Anfänger‑Guide

Ein kompakter, praxisnaher Einstieg: Bilder lokal analysieren und Ergebnisse als Excel exportieren – ganz ohne Datenbank oder komplexe APIs.

Inhaltsverzeichnis

• Einführung
• Warum ein Bildanalyse-Skill?
• Schritt 1: Die Grundstruktur verstehen
• Schritt 2: Mein Bildanalyse‑Skill
• Schritt 3: Den Skill testen
• Schritt 4: Integration in die Anwendung
• Schritt 5: Den Skill verwenden
• Was der Skill macht
• Erweiterte Funktionen (für Fortgeschrittene)
• Häufige Fehler und Lösungen
• Best Practices für Anfänger
• Nächste Schritte
• Fazit

Einführung

Für Anfänger in der AIssistants‑Welt wollte ich einen einfachen Skill erstellen, der Bilder analysiert und die Ergebnisse in Excel exportiert. Keine Datenbanken, keine komplexen APIs – nur grundlegende Bildverarbeitung und Excel‑Export.

Warum ein Bildanalyse-Skill?

Ich suchte nach einem Projekt, das:

• ✅ Einfach zu verstehen ist
• ✅ Praktisch nutzbar ist
• ✅ Keine Datenbanken benötigt
• ✅ Visuelle Ergebnisse liefert
• ✅ Excel‑Integration zeigt

Schritt 1: Die Grundstruktur verstehen

Zuerst schaute ich mir die Skill‑Struktur an:

#!/usr/bin/env python3
import os
import json
import logging

def main(raw_input, **unused):
    """
    Einfacher Skill-Einstiegspunkt
    """
    try:
        # Meine Logik hier
        return {"message": "Erfolgreich ausgeführt"}
    except Exception as exc:
        logging.exception("Fehler:")
        return {"error": str(exc)}

Wichtige Punkte für Anfänger:

• Jeder Skill braucht eine main()‑Funktion
• raw_input enthält die Benutzereingabe
• **unused ist für API‑Keys (können wir ignorieren)
• Immer try/except verwenden!

Schritt 2: Mein Bildanalyse‑Skill

Ich erstellte skills/image_analyzer.py:

#!/usr/bin/env python3
import os
import json
import logging
from PIL import Image
import pandas as pd
from datetime import datetime

def analyze_image(image_path):
    """
    Analysiert ein Bild und gibt grundlegende Informationen zurück
    """
    try:
        with Image.open(image_path) as img:
            # Grundlegende Bildinformationen
            width, height = img.size
            mode = img.mode
            format_type = img.format
            
            # Dateigröße
            file_size = os.path.getsize(image_path)
            
            # Farbanalyse (für RGB-Bilder)
            if mode == 'RGB':
                # Durchschnittliche Farbe berechnen
                img_array = img.convert('RGB')
                r, g, b = img_array.split()
                avg_r = sum(r.getextrema()) / 2
                avg_g = sum(g.getextrema()) / 2
                avg_b = sum(b.getextrema()) / 2
            else:
                avg_r = avg_g = avg_b = 0
            
            return {
                "filename": os.path.basename(image_path),
                "width": width,
                "height": height,
                "mode": mode,
                "format": format_type,
                "file_size_kb": round(file_size / 1024, 2),
                "aspect_ratio": round(width / height, 2),
                "avg_red": round(avg_r, 1),
                "avg_green": round(avg_g, 1),
                "avg_blue": round(avg_b, 1),
                "analysis_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
    except Exception as e:
        logging.error(f"Fehler bei der Bildanalyse: {e}")
        return None

def create_excel_report(image_data, output_path):
    """
    Erstellt einen Excel-Bericht mit den Bildanalysen
    """
    try:
        # DataFrame erstellen
        df = pd.DataFrame([image_data])
        
        # Excel-Datei erstellen
        with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
            df.to_excel(writer, sheet_name='Bildanalyse', index=False)
            
            # Arbeitsblatt formatieren
            worksheet = writer.sheets['Bildanalyse']
            
            # Spaltenbreiten anpassen
            for column in worksheet.columns:
                max_length = 0
                column_letter = column[0].column_letter
                for cell in column:
                    try:
                        if len(str(cell.value)) > max_length:
                            max_length = len(str(cell.value))
                    except:
                        pass
                adjusted_width = min(max_length + 2, 50)
                worksheet.column_dimensions[column_letter].width = adjusted_width
        
        return True
    except Exception as e:
        logging.error(f"Fehler beim Excel-Export: {e}")
        return False

def main(raw_input, **unused):
    """
    Bildanalyse-Skill für Anfänger
    Eingabe: JSON mit 'image_path' oder einfacher Dateipfad
    Ausgabe: Excel-Bericht mit Bildanalysen
    """
    try:
        logging.info(f"Bildanalyse-Skill aufgerufen mit: {raw_input[:100]}...")
        
        # Input parsen
        if raw_input.strip().startswith('{'):
            params = json.loads(raw_input)
            image_path = params.get("image_path", "")
        else:
            image_path = raw_input.strip()
        
        if not image_path:
            return {"error": "Kein Bildpfad angegeben"}
        
        if not os.path.isfile(image_path):
            return {"error": f"Datei nicht gefunden: {image_path}"}
        
        # Bild analysieren
        logging.info(f"Analysiere Bild: {image_path}")
        image_data = analyze_image(image_path)
        
        if not image_data:
            return {"error": "Bildanalyse fehlgeschlagen"}
        
        # Excel-Bericht erstellen
        output_dir = os.path.dirname(os.path.abspath(__file__))
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        excel_filename = f"bildanalyse_{timestamp}.xlsx"
        excel_path = os.path.join(output_dir, excel_filename)
        
        logging.info(f"Erstelle Excel-Bericht: {excel_path}")
        if create_excel_report(image_data, excel_path):
            return {
                "success": True,
                "message": "Bildanalyse erfolgreich abgeschlossen",
                "excel_file": excel_filename,
                "analysis": image_data
            }
        else:
            return {"error": "Excel-Export fehlgeschlagen"}
        
    except json.JSONDecodeError:
        return {"error": "Ungültiges JSON-Format"}
    except Exception as e:
        logging.error(f"Unerwarteter Fehler: {e}")
        return {"error": f"Skill fehlgeschlagen: {str(e)}"}

# Test-Code für lokales Testen
if __name__ == "__main__":
    # Test mit einem Beispielbild
    test_image = "test_image.jpg"  # Ersetzen Sie dies durch ein echtes Bild
    if os.path.exists(test_image):
        result = main(test_image)
        print(json.dumps(result, indent=2, ensure_ascii=False))
    else:
        print("Testbild nicht gefunden. Bitte erstellen Sie eine test_image.jpg")

Schritt 3: Den Skill testen

Lokaler Test

# In Python-Konsole
import sys
sys.path.append('skills')
import image_analyzer

# Test mit einem Bild
result = image_analyzer.main("path/to/your/image.jpg")
print(result)

Schritt 4: Integration in die Anwendung

Über den Assistants Editor

1. Anwendung öffnen → Assistants Library
2. „Add Assistant“ klicken
3. Felder ausfüllen:
   • Name: „BildAnalyzer“
   • Instructions: „Analysiert Bilder und erstellt Excel-Berichte mit Bildinformationen“
   • Model: „gpt-4o-mini“
   • Description: „Einfacher Bildanalyse-Skill mit Excel-Export“
4. Skill auswählen: image_analyzer.py
5. Save klicken

Schritt 5: Den Skill verwenden

Einfache Verwendung

"Analysiere dieses Bild: C:\\Users\\MeinName\\Pictures\\test.jpg"

JSON-Verwendung

{"image_path": "C:\\Users\\MeinName\\Pictures\\test.jpg"}

Beispiel-Ausgabe

{
  "success": true,
  "message": "Bildanalyse erfolgreich abgeschlossen",
  "excel_file": "bildanalyse_20241220_143022.xlsx",
  "analysis": {
    "filename": "test.jpg",
    "width": 1920,
    "height": 1080,
    "mode": "RGB",
    "format": "JPEG",
    "file_size_kb": 245.67,
    "aspect_ratio": 1.78,
    "avg_red": 128.5,
    "avg_green": 132.3,
    "avg_blue": 125.8,
    "analysis_date": "2024-12-20 14:30:22"
  }
}

Was der Skill macht

1) Bildanalyse

• Größe: Breite und Höhe
• Format: JPEG, PNG, etc.
• Modus: RGB, Grayscale, etc.
• Dateigröße: in KB
• Seitenverhältnis: Breite/Höhe
• Farbanalyse: Durchschnittliche RGB‑Werte

2) Excel‑Export

• Erstellt eine Excel‑Datei im skills/‑Ordner
• Automatische Spaltenbreiten‑Anpassung
• Zeitstempel im Dateinamen
• Übersichtliche Darstellung aller Daten

Erweiterte Funktionen (für Fortgeschrittene)

Mehrere Bilder analysieren

def analyze_multiple_images(image_paths):
    """Analysiert mehrere Bilder auf einmal"""
    results = []
    for path in image_paths:
        if os.path.isfile(path):
            data = analyze_image(path)
            if data:
                results.append(data)
    return results


def create_comparison_excel(image_data_list, output_path):
    """Erstellt einen Vergleichsbericht für mehrere Bilder"""
    df = pd.DataFrame(image_data_list)
    
    with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
        df.to_excel(writer, sheet_name='Bildvergleich', index=False)
        
        # Zusätzliche Statistiken
        stats_df = pd.DataFrame({
            'Statistik': ['Durchschnittliche Breite', 'Durchschnittliche Höhe', 'Größtes Bild', 'Kleinstes Bild'],
            'Wert': [
                df['width'].mean(),
                df['height'].mean(),
                df.loc[df['file_size_kb'].idxmax(), 'filename'],
                df.loc[df['file_size_kb'].idxmin(), 'filename']
            ]
        })
        stats_df.to_excel(writer, sheet_name='Statistiken', index=False)

Erweiterte Bildanalyse

def advanced_image_analysis(image_path):
    """Erweiterte Bildanalyse mit zusätzlichen Features"""
    with Image.open(image_path) as img:
        # Grundlegende Analyse
        basic_data = analyze_image(image_path)
        
        # Zusätzliche Analysen
        if img.mode == 'RGB':
            # Dominante Farben
            img_array = np.array(img)
            pixels = img_array.reshape(-1, 3)
            
            # Einfache Farbclustering
            from sklearn.cluster import KMeans
            kmeans = KMeans(n_clusters=5, random_state=42)
            kmeans.fit(pixels)
            
            # Dominante Farben extrahieren
            dominant_colors = kmeans.cluster_centers_.astype(int)
            
            basic_data.update({
                "dominant_colors": dominant_colors.tolist(),
                "color_variety": len(np.unique(kmeans.labels_))
            })
        
        return basic_data

Häufige Fehler und Lösungen

1) „Datei nicht gefunden“

# Lösung: Absoluten Pfad verwenden
image_path = os.path.abspath("relative/path/to/image.jpg")

2) „Bildformat nicht unterstützt“

# Lösung: Format prüfen
supported_formats = ['JPEG', 'PNG', 'BMP', 'GIF']
if img.format not in supported_formats:
    return {"error": f"Format {img.format} nicht unterstützt"}

Best Practices für Anfänger

1) Einfach anfangen

• Beginnen Sie mit grundlegenden Funktionen
• Erweitern Sie schrittweise
• Testen Sie jeden Schritt

2) Fehlerbehandlung

try:
    # Ihre Logik
    return {"success": True, "data": result}
except FileNotFoundError:
    return {"error": "Datei nicht gefunden"}
except Exception as e:
    return {"error": f"Unerwarteter Fehler: {e}"}

3) Logging verwenden

import logging

def main(raw_input, **unused):
    logging.info(f"Skill aufgerufen mit: {raw_input}")
    # ... Ihre Logik
    logging.info("Skill erfolgreich abgeschlossen")

Hinweis: Eine Konsolenfunktion für AIssistants ist erst später beabsichtigt. Man kann aber die Assistenten fragen: „Was war der konkrete Error“ oder „Gib mir den kompletten Error-String“ um das Problem einstweilig zu umgehen.

4) Dokumentieren Sie gut

def analyze_image(image_path):
    """
    Analysiert ein Bild und gibt Informationen zurück
    
    Args:
        image_path (str): Pfad zur Bilddatei
        
    Returns:
        dict: Bildinformationen oder None bei Fehler
    """

Nächste Schritte

Nach dem Erfolg meines ersten Skills plane ich:

1. Mehrere Bilder gleichzeitig analysieren
2. Erweiterte Bildanalyse mit OpenCV
3. PDF‑Berichte zusätzlich zu Excel
4. Web‑Interface für einfache Nutzung

Fazit

Dieser einfache Bildanalyse‑Skill zeigt, wie man:

• ✅ Grundlegende Bildverarbeitung implementiert
• ✅ Excel‑Export erstellt
• ✅ Robuste Fehlerbehandlung einbaut
• ✅ Skills in die Anwendung integriert

Für Anfänger perfekt geeignet, weil:

• Keine Datenbanken nötig
• Visuelle Ergebnisse
• Praktisch nutzbar
• Einfach zu erweitern

Nächste Schritte für Sie:

1. Erstellen Sie den Bildanalyse‑Skill
2. Testen Sie ihn mit eigenen Bildern
3. Erweitern Sie ihn um eigene Features
4. Teilen Sie Ihre Erfahrungen!

Viel Erfolg bei Ihrem ersten Skill! 🚀