OM-1 Stacking Pipeline v4:

Jetzt mit moderner Web-UI und macOS App

15. März 2026 • Oliver Kümmel

TL;DR

Die OM-1 Macro Focus Stacking Pipeline ist jetzt als native macOS App verfügbar! Statt Terminal-Befehlen gibt's jetzt eine schicke Web-Oberfläche mit Live-Preview, Echtzeit-Progress und One-Click-Installation.

→ Download auf GitHub

Von der Kommandozeile zur App

Im letzten Artikel hab ich gezeigt, wie man mit Python-Scripts automatisch Focus-Stacks aus OM-1 RAW-Serien erstellt. Das funktionierte, war aber… sagen wir mal "entwicklerfreundlich". 😅

Das Problem:

  • Terminal-Befehle eintippen

  • Python-Environment aufsetzen

  • Kein visuelles Feedback

  • Für Nicht-Nerds eher abschreckend

Die Lösung: v4.0 🚀

Was ist neu?

🎨 Moderne Web-Oberfläche

Statt schwarzem Terminal-Fenster gibt's jetzt eine responsive Web-UI mit:

  • Thumbnail-Vorschau aller erkannten Serien

  • Interaktive Auswahl per Checkbox

  • Live-Progress mit Echtzeit-Logs

  • Statistiken (Zeit, Erfolgsrate, etc.)

Screenshot: (hier würde ein Screenshot der Web-UI hin)

📦 Native macOS App

Die Pipeline ist jetzt eine echte .app:

# Früher:
cd ~/Projects/stacking
source venv/bin/activate
python3 macro_stacking.py --watch /Volumes/SD-CARD

# Jetzt:
# Doppelklick auf "OM-1 Stacking Pipeline.app" → fertig!

Installation:

  1. DMG herunterladen

  2. App nach /Applications ziehen

  3. Doppelklick → Browser öffnet sich automatisch

⚡ Performance-Optimierungen

Smart Image Handling:

  • Nutzt OOC JPEGs wenn vorhanden (keine Konvertierung!)

  • Konvertiert RAW nur bei Bedarf

  • Thumbnail-Caching (beim 2. Mal instant)

Vorher/Nachher:

Vorher (v3): 10 Bilder → ~90 Sekunden
Jetzt (v4):  10 Bilder → ~15 Sekunden ⚡

🔍 Bessere Helicon-Integration

Helicon Focus wird jetzt direkt per CLI angesteuert:

# Konfiguration in ~/.stacking_config.yaml
helicon_method: C      # Pyramid (beste Qualität)
helicon_radius: 8      # Feintuning möglich
helicon_smoothing: 4   # Übergänge optimieren

Tipp: Method C dauert länger, liefert aber deutlich bessere Ergebnisse als die alte focus-stack-Lösung!

Der neue Workflow

1. SD-Karte einlegen

Die App erkennt automatisch alle gemounteten SD-Karten mit DCIM-Ordner.

Screenshot: (SD-Karten-Auswahl)

2. Serien reviewen

Für jede erkannte Serie wird ein Thumbnail generiert (aus dem ersten Bild):

  • Anzahl der Bilder

  • Zeitraum der Aufnahme

  • Dauer der Serie

Screenshot: (Serien-Grid mit Thumbnails)

3. Auswählen & Stacken

  • Checkboxen zum Auswählen

  • "Select All" / "Select None" Buttons

  • Live-Log zeigt jeden Schritt:

[21:35:42] → Serie 1: 12 images
[21:35:43] ✓ Serie 1: Prepared 12 images (8 OOC JPG, 4 converted)
[21:35:44] → Serie 1: Stacking with Helicon Focus (Method C)...
[21:36:07] ✓ Serie 1: Stack created in 23.4s → stack_20260315_213542.jpg

Screenshot: (Live-Progress-View)

4. Fertig!

Stacks landen in ~/Pictures/Stacked/ mit:

  • EXIF-Metadaten (Datum, Anzahl Bilder, Software)

  • Sinnvollem Dateinamen (stack_YYYYMMDD_HHMMSS.jpg)

  • macOS-Notification bei Fertigstellung

    • *

Technische Details

Architektur

┌─────────────────────────────────────┐
│   Web-UI (HTML/CSS/JS)              │
│   - Thumbnails                       │
│   - Live Updates via WebSocket      │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│   Flask + SocketIO Backend          │
│   - Series Detection                 │
│   - Image Processing                 │
│   - Progress Tracking                │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│   Processing Pipeline                │
│   - ImageMagick (RAW→JPG)           │
│   - Helicon Focus (Stacking)        │
│   - exiftool (Metadata)             │
└─────────────────────────────────────┘

py2app für macOS Apps

Die App wird mit py2app gebaut:

# setup.py
setup(
    app=['macro_stacking_web_v4.1.py'],
    options={'py2app': {
        'packages': ['flask', 'flask_socketio', 'PIL'],
        'iconfile': 'resources/app_icon.icns',
        'plist': {
            'CFBundleName': 'OM-1 Stacking Pipeline',
            'LSApplicationCategoryType': 'public.app-category.photography',
        }
    }}
)

Build:

python3 setup.py py2app

Ergebnis: Standalone-App (~50MB) mit embedded Python + Dependencies.

Thumbnail-Caching

Thumbnails werden gecacht mit Hash aus:

  • Dateiname

  • Dateigröße

  • Modification Time

cache_key = f"{filename}_{size}_{mtime}"
cache_hash = hashlib.md5(cache_key.encode()).hexdigest()[:16]
cache_path = ~/.stacking_cache/thumbnails/{cache_hash}.jpg

Vorteil: Beim 2. Öffnen der gleichen SD-Karte sind Thumbnails instant verfügbar!

Vergleich: v3 vs. v4

Feature v3.0 (CLI/Tkinter) v4.0 (Web + App)
Installation Python, pip, venv DMG → Drag & Drop
Interface Terminal / Tkinter Web-Browser
Thumbnails Langsam, kein Cache Schnell + Cache
Progress Text-Output Live-Log + Bar
Bedienung Keyboard Point & Click
Portabilität Python nötig Standalone App
Updates git pull Auto-Update (geplant)

Praxis-Beispiel: Pilz-Makro

Setup:

  • OM-1 + M.Zuiko 60mmMacro

  • Focus Bracketing: 15 Bilder, Step 3

  • Freihand

  • RAW + JPG

Workflow:

  1. Shooting: 30 Sekunden (15 Aufnahmen)

  2. SD-Karte einlegen: 5 Sekunden

  3. App starten: 2 Sekunden (Browser öffnet)

  4. Serie auswählen: 3 Sekunden

  5. Stacking: 18 Sekunden (Helicon Method C)

  6. Fertig! Stack in Lightroom importieren

Gesamt: ~1 Minute vom Shooting zum fertigen Stack! 🚀

Vorher/Nachher-Vergleich:

Einzelbild (mittlere Fokusebene):

  • Schärfebereich: ~2mm

  • Vorder-/Hintergrund unscharf

Gestacktes Bild:

  • Schärfebereich: ~15mm

  • Durchgehend scharf von vorne bis hinten

  • Keine Ghosting-Artefakte (dank Helicon Method C)

    • *

Installation & Setup

Voraussetzungen

# Homebrew Tools
brew install imagemagick exiftool

# Helicon Focus (Trial oder Lizenz)
# Download: https://www.heliconsoft.com

App installieren

  1. Download: GitHub Releases

  2. DMG öffnen und App nach /Applications ziehen

  3. Erste Ausführung: Rechtsklick → "Öffnen" (macOS Gatekeeper)

  4. Browser öffnet sich automatisch

Konfiguration

Config-Datei: ~/.stacking_config.yaml

# Wichtigste Settings:
output_dir: ~/Pictures/Stacked
helicon_method: C
helicon_radius: 8
time_threshold: 30  # Sekunden zwischen Bildern
min_images: 3       # Mindestanzahl pro Serie

Tipp: Für schnellere Tests helicon_method: A nutzen!

Tipps & Tricks

Optimales Shooting

Focus Bracketing Settings (OM-1):

Modus:           Focus BKT
Anzahl:          10-30 (je nach Motiv)
Fokus-Schritt:   3-5 (kleiner = mehr Überlappung)
Intervall:       0s (so schnell wie möglich)

Kamera-Settings:

  • RAW + JPG aktivieren → schnellere Thumbnails!

  • IS einschalten (auch auf Stativ)

  • Selbstauslöser 2s oder Fernauslöser

  • Manuelle Belichtung (keine Änderungen zwischen Frames)

Performance-Tuning

Schneller Workflow:

jpg_converter: imagemagick  # Schneller als dcraw
output_format: jpg          # Schneller als TIFF
helicon_method: A           # Für Previews

Beste Qualität:

helicon_method: C           # Pyramid-Methode
output_quality: 95          # Hohe JPG-Qualität
output_format: tiff         # Für weitere Bearbeitung

Troubleshooting

Problem: Thumbnails werden nicht generiert

# Check ImageMagick
magick --version

# Test RAW-Konvertierung
magick P3150001.ORF -resize 200x133 test.jpg

Problem: Helicon nicht gefunden

# Pfad prüfen
ls /Applications/HeliconFocus.app/Contents/MacOS/HeliconFocus

# In Config anpassen
nano ~/.stacking_config.yaml

Problem: Serien werden nicht erkannt

# Schwellwert erhöhen
time_threshold: 60  # Statt 30
min_images: 2       # Statt 3

Ausblick: Was kommt noch?

Geplante Features

v4.2 (Q2 2026):

  • Auto-Update Funktion

  • Presets für verschiedene Workflows

  • Batch-Export zu Lightroom/Capture One

  • GPU-Beschleunigung für RAW-Konvertierung

v5.0 (Q3 2026):

  • Windows/Linux Support

  • Cloud-Processing Option

  • AI-basierte Fokus-Optimierung

  • Plugin-System für andere Stacker

Community-Features

Gewünscht von Usern:

  • Depth-Map Export für 3D-Modelle

  • Vergleichs-Ansicht (Einzelbild vs. Stack)

  • Direkter Upload zu Flickr/500px

  • Mobile App (iOS/Android)

→ Feature-Requests auf GitHub willkommen!

Fazit

Die OM-1 Stacking Pipeline v4 macht Focus-Stacking endlich zugänglich und schnell:

✅ Keine Terminal-Kenntnisse mehr nötig
✅ Visuelles Feedback in Echtzeit
✅ Deutlich schneller durch Smart Processing
✅ Bessere Qualität mit Helicon Focus
✅ Native macOS App statt Script-Sammlung

Von der SD-Karte zum fertigen Stack in unter 1 Minute! 🚀

Download & Links

Lizenz: MIT (Open Source, kostenlos)

Feedback & Kontakt

Fragen? Probleme? Feature-Wünsche?

Pull Requests willkommen! 🤝

Beispiel-Galerie

Hier würden gestackte Beispielbilder hin - falls du welche hast, kann ich die Beschreibungen schreiben!

Beispiel 1: Pilz-Makro

  • Kamera: OM-1 + M.Zuiko 90mm f/3.5

  • Bilder: 15 Frames, Step 3

  • Stacking: Helicon Method C

  • Zeit: 18 Sekunden

Beispiel 2: Insekten-Detail

  • Kamera: OM-1 + M.Zuiko 60mm f/2.8

  • Bilder: 30 Frames, Step 2

  • Stacking: Helicon Method C

  • Zeit: 35 Sekunden

    • *

Happy Stacking! 📸🔬

Dieser Artikel ist auch auf GitHub verfügbar.