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!Code-Sprache: PHP (php)

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 optimierenCode-Sprache: PHP (php)

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.jpgCode-Sprache: CSS (css)

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',
        }
    }}
)Code-Sprache: PHP (php)

Build:

python3 setup.py py2appCode-Sprache: CSS (css)

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}.jpgCode-Sprache: JavaScript (javascript)

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.comCode-Sprache: PHP (php)

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 SerieCode-Sprache: PHP (php)

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)Code-Sprache: HTTP (http)

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 PreviewsCode-Sprache: PHP (php)

Beste Qualität:

helicon_method: C           # Pyramid-Methode
output_quality: 95          # Hohe JPG-Qualität
output_format: tiff         # Für weitere BearbeitungCode-Sprache: PHP (php)

Troubleshooting

Problem: Thumbnails werden nicht generiert

# Check ImageMagick
magick --version

# Test RAW-Konvertierung
magick P3150001.ORF -resize 200x133 test.jpgCode-Sprache: CSS (css)

Problem: Helicon nicht gefunden

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

# In Config anpassen
nano ~/.stacking_config.yamlCode-Sprache: PHP (php)

Problem: Serien werden nicht erkannt

# Schwellwert erhöhen
time_threshold: 60  # Statt 30
min_images: 2       # Statt 3Code-Sprache: PHP (php)

---

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

• GitHub: okuemmel/om1-stacking-pipeline
• Download: Latest Release
• Dokumentation: README.md
• Build-Anleitung: BUILD.md

Lizenz: MIT (Open Source, kostenlos)

---

Feedback & Kontakt

Fragen? Probleme? Feature-Wünsche?

• GitHub Issues: github.com/okuemmel/om1-stacking-pipeline/issues
• Email: [email protected]
• Blog: kmml.uk

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.