• Herzlich willkommen im "neuen" DSLR-Forum!

    Wir hoffen, dass Euch das neue Design und die neuen Features gefallen und Ihr Euch schnell zurechtfindet.
    Wir werden wohl alle etwas Zeit brauchen, um uns in die neue Umgebung einzuleben. Auch für uns ist das alles neu.

    Euer DSLR-Forum-Team

  • In eigener Sache!

    Liebe Mitglieder, liebe Besucher und Gäste
    ich weiß, es ist ein leidiges Thema, aber ich muss es ansprechen: Werbung, Werbeblocker und Finanzierung des Forums.
    Bitte hier weiterlesen ...

  • DSLR-Forum Fotowettbewerb neu erfunden!
    Nach wochenlanger intensiver Arbeit an der Erneuerung des Formates unseres internen Fotowettbewerbes ist es Frosty als Moderator
    und au lait als Programmierer gelungen, unseren Wettbewerb auf ein völlig neues Level zu heben!
    Lest hier alle Infos zum DSLR-Forum Fotowettbewerb 2.0
    Einen voll funktionsfähigen Demowettbewerb kannst du dir hier ansehen.
  • Neuer Partner: AkkuShop.de
    Akkus, Ladegeräte und mehr (nicht nur) für Digitalkameras und Drohnen
  • Neuer Gutscheincode unseres Partners Schutzfolien24:
    DSLR-Forum2024
    Dauerhaft 10% Rabatt auf alle Displayschutzfolien der Eigenmarken "Upscreen", "Brotec", "Savvies".
    Der Code ist für alle Geräteklassen gültig.
  • Mitmachen beim DSLR-Forum Fotowettbewerb Juni 2024.
    Thema: "Wiederholung"

    Jeden Monat attraktive Gewinnprämien, gesponsert von unserem Partner PixelfotoExpress.
    Alle Infos zum Juni-Wettbewerb hier!
WERBUNG

Der große RAW-Batch-Workflow-Thread

photourist

Themenersteller
Vollautomatische RAW-Konvertierung
mit Ufraw, ImageMagick und ExifTool

Man kommt mit 1001 RAW-Dateien aus dem Urlaub zurück. Man möchte schnell Ergebnisse sehen, die qualitätsmäßig mehr bieten als die in die Rohdateien eingebetteten JPEG-Vorschauen. Man möchte eine bequeme Basis haben, um bei Optimierungen einzelner Bilder im Konverter nicht bei Null anfangen zu müssen.

Da bietet sich doch ein skriptbasierter, vollautomatischer RAW-Workflow an, welcher die Bilder linear konvertiert, leicht entrauscht, ganz dezent vorschärft und als EXIF-JPEGs ausgibt.

Ufraw ( http://ufraw.sourceforge.net/ ), ImageMagick ( http://www.imagemagick.org/script/index.php ) und ExifTool ( http://www.sno.phy.queensu.ca/~phil/exiftool/ ) sind wie geschaffen für diese Aufgabe.

Ufraw lässt sich mit grafischer Oberfläche sowohl stand-alone (ufraw) als auch als GIMP-Plugin (ufraw-gimp) nutzen. Eine dritte Möglichkeit bietet die Ausführung ohne interaktive Oberfläche im Batchmodus (ufraw-batch). Die pro Bild ausgegebenen ID-Files enthalten alle für die Konvertierung notwendigen Daten. Zur erneuten Konvertierung eines Bildes ist nur das jeweilige ID-File (*.ufraw) mit ufraw aufzurufen.

Das folgende Skript (my_workflow) läuft unter der BourneAgainShell (bash) unter Linux, BSD und anderes Unix-Abarten. Unter Windows muss es für WSH angepasst werden oder in einer CygWin-Umgebung ( http://www.cygwin.com/ ) ausgeführt werden.

Das Skript soll zeigen, was auf der Kommandozeile möglich ist und als Anregung zu eigenen Versuchen dienen. Sicherlich lässt sich einiges verbessern oder einfach anders machen.

Viel Spaß beim Experimentieren!

Skript: my_workflow
Code:
#!/bin/bash
#
# Automated RAW workflow using dcraw, ImageMagick and ExifTool
# tested with ufraw 0.9.1, ImageMagick 6.2.8 and ExifTool (Nov. 12/03)
#
# Schutz vor unbeabsichtigtem Zweitlauf abfragen
if [ -e workflow_done ]; then
    echo "my_workflow has already been run. Nothing to be done."
    echo "Press <RETURN> to exit."
    read some_key && exit 1
fi
start_time=`date +%R`
# RAW-Dateien zählen
all_files="`ls *.ORF | wc -w`"
echo "Starting RAW workflow by photourist"
echo "   $all_files files to be processed."
echo
count_files=1
echo "Step 1 of 3: starting RAW-conversion"
echo "--------------------------------------"
for i in *.ORF; do
    echo "processing ORF-file $count_files / $all_files"
# Lineare Konvertierung mit ufraw-batch. Ausgabe nach 16-Bit-PPM und der ID-Files
    ufraw-batch \
      --wb=camera \
      --base-curve=linear \
      --curve=linear \
      --clip \
      --gamma=0.45 \
      --linearity=0.10 \
      --saturation=1.2 \
      --exposure=auto \
      --black-point=auto \
      --interpolation=ahd \
      --out-type=ppm16 \
      --create-id=also \
      $i
    let count_files=( $count_files + 1)
done
echo "   done."
echo
echo "Step 2 of 3: starting PPM-processing"
echo "--------------------------------------"
count_files=1
for i in *.ppm; do
    echo "processing PPM-file $count_files / $all_files"
# Leichte Entrauschung durch Gauss-Filter und USM. Umwandlung nach JPEG.
    convert $i \
      -gaussian 1x1 \
      -unsharp 2x1.4+1+0.02 \
      -quality 97 \
      `basename $i .ppm`.jpg
    let count_files=( $count_files + 1)
done
echo
echo "Tidying up ..."
# Löschen der PPM-Dateien.
rm -f *.ppm
echo "   done."
echo
echo "Step 3 of 3: transferring EXIF data"
echo "--------------------------------------"
count_files=1
for orffile in `ls *.ORF`; do
    echo "processing $count_files / $all_files"
    jpgfile=`basename $orffile .ORF`.jpg
# Übertragung der EXIF-Daten von den ORF- auf die JPEG-Dateien.
    exiftool -TagsFromFile $orffile -x Orientation $jpgfile
    sleep 2
    let count_files=( $count_files + 1)
done
echo
echo "Tidying up ..."
# Ordner für JPEG-Dateien ohne EXIFs.
mkdir JPG_backup
# Ordner für JPEG-Dateien mit EXIFs.
mkdir JPG
mv -f *.jpg_original JPG_backup/
mv -f *.jpg JPG/
# Schutz vor unbeabsichtigtem Zweitlauf setzen.
touch workflow_done
echo "   done."
echo
echo "Workflow finished."
echo "Duration from $start_time to `date +%R`"
echo "--------------------------------------"
# Ende des Skripts.
 
Obiger Beitrag ist zwar auf das Olympus E-System zugeschnitten, kann aber ganz leicht angepasst werden, und sollte als Kristallisationspunkt für Eure Beiträge dienen, die mich sehr interessieren würden.
Was ich nicht unbedingt diskutieren will, ist die Frage, ob soetwas überhaupt Sinn macht. Die Antwort dazu habe ich in den ersten Sätzen des Eröffnungspostings schon umrissen; und es kann letztlich auch nur ein Kompromiss sein. Immerhin sind die Ergebnisse, die ich auf diese Weise erziele, für mich durchaus befriedigend. Besser als JPEG out-of-the-Cam ist's allemal. Ein großer Vorteil ist, wenn man soetwas ersteinmal ausgetüftelt hat, dass der Ablauf beliebig modifiziert und erweitert werden kann (Ausgabe verschiedener Bildskalierungen, Rahmung, Anwendung von Gradationskurven, Farbtemperatur-Reihen, Watermarking etc). Damit hat man aus dem Stand doch mehr, als mit der Speicherung von RAW+JPEG.

Hier ist die Help-Seite von ufraw[-batch]:
Code:
UFRaw 0.9.1 - Unidentified Flying Raw converter for digital camera images.

Usage: ufraw [ options ... ] [ raw-image-files ... ]
       ufraw-batch [ options ... ] [ raw-image-files ... ]
       ufraw [ options ... ] [ default-directory ]

By default 'ufraw' displays a preview window for each raw image allowing
the user to tweak the image parameters before saving. If no raw images
are given at the command line, UFRaw will display a file chooser dialog.
To process the images with no questions asked (and no preview) use
'ufraw-batch'.

The input files can be either raw images or ufraw's ID files. ID file
contain a raw image filename and the parameters for handling the image.
One can also use and ID file with the option:

--conf=ID-file        Apply the parameters in ID-file to other raw images.

The rest of the options are separated into two groups.
The options which are related to the image manipulation are:

--wb=camera|auto      White balance setting.
--temperature=TEMP    Color temperature in Kelvins (2000 - 7000).
--green=GREEN         Green color normalization.
--base-curve=manual|linear|camera|custom|CURVE
                      Type of base tone curve to use. CURVE can be any curve
                      that was previously loaded in the GUI.
                      (default camera if such exsists, linear otherwise).
--base-curve-file=file
                      Use base tone curve included in specified file.
                      Overrides --base-curve option.
--curve=manual|linear|CURVE
                      Type of luminosity curve to use. CURVE can be any
                      curve that was previously loaded in the GUI.
                      (default linear).
--curve-file=file     Use luminosity curve included in specified file.
                      Overrides --curve option.
--[un]clip            Unclip [clip] highlights (default clip).
--gamma=GAMMA         Gamma adjustment of the base curve (default 0.45).
--linearity=LINEARITY Linearity of the base curve (default 0.10).
--saturation=SAT      Saturation adjustment (default 1.0, 0 for B&W output).
--exposure=auto|EXPOSURE
                      Auto exposure or exposure correction in EV (default 0).
--black-point=auto|BLACK
                      Auto black-point or black-point value (default 0).
--interpolation=ahd|vng|four-color|bilinear
                      Interpolation algorithm to use (default ahd).

The options which are related to the final output are:

--shrink=FACTOR       Shrink the image by FACTOR (default 1).
--size=SIZE           Downsize max(height,width) to SIZE.
--out-type=ppm8|ppm16|tiff8|tiff16|jpeg
                      Output file format (default ppm8).
--create-id=no|also|only
                      Create no|also|only ID file (default no).
--compression=VALUE   JPEG compression (0-100, default 85).
--[no]exif            Embed exif in output JPEG (default embed exif).
--[no]zip             Enable [disable] TIFF zip compression (default nozip).
--out-path=PATH       PATH for output file (default use input file's path).
--output=FILE         Output file name, use '-' to output to stdout.
--darkframe=FILE      Use FILE for raw darkframe subtraction.
--overwrite           Overwrite existing files without asking (default no).

UFRaw first reads the setting from the resource file $HOME/.ufrawrc.
Then, if an ID file is specified it setting are read. Next, the setting from
the --conf option are taken, ignoring input/output filenames in the ID file.
Lastly, the options from the command line are set. In batch mode, the second
group of options is NOT read from the resource file.

Last, but not least, --version displays the version number and compilation
options for ufraw and --help displays this help message and exits.
 
Zuletzt bearbeitet:
Alternativ kann man auch mit dcraw konvertieren.
Die Bilder sind dann automatisch immer korrekt belichtet. Das wäre ein besserer Ausgangspunkt, da die Belichtungsautomatik von ufraw etwas heikel ist.
Danach wäre eine Tonwertspreizung durchzuführen. Allerdings ist es mir mit ImageMagick nicht befriedigend gelungen, eine standardisierte Histogramm-Bearbeitung zu erreichen, die bei jedem Bild den Schwarzpunkt auf ca. 0,1 % der vorhandenen Tonwerte und den Weisspunkt auf ca. 100% der vorhandenen Tonwerte setzt (hellsten Punkt im Bild auf 254 oder #FEFEFE setzen).
Mit "convert --normalize" wird zuviel von den Lichtern abgeschnitten. Mit "--contrast-stretch" und mit "--level" bin ich auch nicht weitergekommen.
Deshalb habe ich ufraw-batch gewählt, da dessen Automatik insofern etwas besser funktioniert, als eine Histogramm-Bearbeitung dann nicht unbedingt nötig wäre. Leider ist auch dort die automatische Belichtung ein wenig zu hell, so dass bei einem gut gefüllten Histogramm immer etwas Lichter ausreissen. Es gibt keine Möglichkeit, die automatische Belichtung in ufraw etwas nach unten zu korrigieren. Die Ausgabe in ufraw von PPM8 nach PPM16 zu wechseln brachte etwas Besserung. Erschwerend kommt aber hinzu, dass ufraw - im Gegensatz zu dcraw (Parameter -H) - für das Highlight-Clipping wohl keine "restore"-Funktion (Rekonstruktion der ausgerissenen Lichter aus den Rest-Informationen in den Kanälen) hat.
Ich muss mir wohl mal den Quelltext von ufraw-batch unter die Lupe nehmen und ein bischen an der Belichtungsautomatik schrauben ...

Hat jemand Ideen?
 
Zuletzt bearbeitet:
Ich habe dein Script mal etwas modifiziert, wenn es recht ist.
Grund:
du arbeitest mit mehreren Schleifen (raw, ppm, exiftool), löscht aber hinterher die erstellten ppm-Daten.
Ich habe das in einer Schleife zusammengefasst, weil ich auf meiner Platte nicht genügend Platz habe ;)
Hier jetzt für mit Raw-Files der 300D (crw):
Code:
#!/bin/bash
#
# Automated RAW workflow using dcraw, ImageMagick and ExifTool
# tested with ufraw 0.9.1, ImageMagick 6.2.8 and ExifTool (Nov. 12/03)
#
# Schutz vor unbeabsichtigtem Zweitlauf abfragen
if [ -e workflow_done ]; then
    echo "my_workflow has already been run. Nothing to be done."
    echo "Press <RETURN> to exit."
    read some_key && exit 1
fi
start_time=`date +%R`
# RAW-Dateien zählen
all_files="`ls *.crw | wc -w`"
echo "Starting RAW workflow by photourist/modified frank21"
echo "   $all_files files to be processed."
echo
count_files=1
echo "Step 1 of 3: starting RAW-conversion"
echo "--------------------------------------"
for crwfile in *.crw; do
    echo "processing crw-file $count_files / $all_files"
    ppmfile=`basename $crwfile .crw`.ppm
    jpgfile=`basename $crwfile .crw`.jpg
# Lineare Konvertierung mit ufraw-batch. Ausgabe nach 16-Bit-PPM und der ID-Files
    ufraw-batch \
      --wb=camera \
      --base-curve=linear \
      --curve=linear \
      --clip \
      --gamma=0.45 \
      --linearity=0.10 \
      --saturation=1.2 \
      --exposure=auto \
      --black-point=auto \
      --interpolation=ahd \
      --out-type=ppm16 \
      --create-id=also \
      $crwfile
    echo "   done."
    echo
    echo "Step 2 of 3: starting PPM-processing"
    echo "--------------------------------------"
    echo "processing PPM-file $count_files / $all_files"
# Leichte Entrauschung durch Gauss-Filter und USM. Umwandlung nach JPEG.
    convert $ppmfile \
      -gaussian 1x1 \
      -unsharp 2x1.4+1+0.02 \
      -quality 97 \
      $jpgfile
# Löschen der PPM-Dateien.
    rm -f $ppmfile
    echo "   done."
    echo
    echo "Step 3 of 3: transferring EXIF data"
    echo "--------------------------------------"
# Übertragung der EXIF-Daten von den crw- auf die JPEG-Dateien.
    exiftool -TagsFromFile $crwfile -x Orientation $jpgfile
    let count_files=( $count_files + 1)
    sleep 2
done
echo
echo "Tidying up ..."
# Ordner für JPEG-Dateien ohne EXIFs.
mkdir JPG_backup
# Ordner für JPEG-Dateien mit EXIFs.
mkdir JPG
mv -f *.jpg_original JPG_backup/
mv -f *.jpg JPG/
# Schutz vor unbeabsichtigtem Zweitlauf setzen.
touch workflow_done
echo "   done."
echo
echo "Workflow finished."
echo "Duration from $start_time to `date +%R`"
echo "--------------------------------------"
# Ende des Skripts.
 
@frank21:
Vielen Dank.

Man kann mit Pipes noch mehr verkürzen und sich so jede Zwischenspeicherung sparen. Ich selbst wollte mir aber die Option offen lassen, die PPMs zu behalten. Oft habe ich diese dann nach PNG gewandelt, als verlustloses Zweitformat zur Archivierung, was mir allerdings inzwischen zu viel Platz in Anspruch nimmt (weshalb TIFF auch nicht in Frage kommt). Möglicherweise werde ich DNG nutzen. Der Adobe DNG-Converter läuft mit Wine auch unter Linux.
 
Ich selbst wollte mir aber die Option offen lassen, die PPMs zu behalten.
Dann einfach ein # vor das rm ;) - in deinem Script müsstest du ja auch die entsprechnde Zeile auskommentieren.
Man könnte das ganze auch über switches steuern, so mit --keep-ppm etc.
Vielleicht leg ich auch noch mal ne Bastelstunde ein :)
 
Hallo Ihr zwei,

ich war schon seit längerem auf der Suche nach so einem Skript und habe es deshalb mal für Nikon NEF-Dateien angepasst (eigentlich nur Dateiendung ersetzt) und muß sagen tolle Arbeit. Bei dem Vergleich der Bilder mit denen über NikonView konvertierten Bilder ist mir zwar aufgefallen das diese etwas dunkler und weicher konvertiert werden, aber dadurch meiner Meinung nach realistischer aussehen. Also vielen Dank(y) .

Gruß
Michael
 
Hat jemand inzwischen eigene bzw. neue Erfahrungen gesammelt?

Sowohl dcraw als auch Ufraw und digiKam haben ja inzwischen einige Fortschritte gemacht (auch in Hinblick auf Farbmanagement).

Vor wenigen Tagen ist auch LightZone offiziell für Linux erschienen (läuft allerdings unter Java - nicht sehr prickelnd).
 
Alternativ kann man auch mit dcraw konvertieren.
Die Bilder sind dann automatisch immer korrekt belichtet. Das wäre ein besserer Ausgangspunkt, da die Belichtungsautomatik von ufraw etwas heikel ist.
Danach wäre eine Tonwertspreizung durchzuführen. Allerdings ist es mir mit ImageMagick nicht befriedigend gelungen, eine standardisierte Histogramm-Bearbeitung zu erreichen, die bei jedem Bild den Schwarzpunkt auf ca. 0,1 % der vorhandenen Tonwerte und den Weisspunkt auf ca. 100% der vorhandenen Tonwerte setzt (hellsten Punkt im Bild auf 254 oder #FEFEFE setzen).
Mit "convert --normalize" wird zuviel von den Lichtern abgeschnitten. Mit "--contrast-stretch" und mit "--level" bin ich auch nicht weitergekommen.
Deshalb habe ich ufraw-batch gewählt, da dessen Automatik insofern etwas besser funktioniert, als eine Histogramm-Bearbeitung dann nicht unbedingt nötig wäre. Leider ist auch dort die automatische Belichtung ein wenig zu hell, so dass bei einem gut gefüllten Histogramm immer etwas Lichter ausreissen. Es gibt keine Möglichkeit, die automatische Belichtung in ufraw etwas nach unten zu korrigieren. Die Ausgabe in ufraw von PPM8 nach PPM16 zu wechseln brachte etwas Besserung. Erschwerend kommt aber hinzu, dass ufraw - im Gegensatz zu dcraw (Parameter -H) - für das Highlight-Clipping wohl keine "restore"-Funktion (Rekonstruktion der ausgerissenen Lichter aus den Rest-Informationen in den Kanälen) hat.
Ich muss mir wohl mal den Quelltext von ufraw-batch unter die Lupe nehmen und ein bischen an der Belichtungsautomatik schrauben ...

Hat jemand Ideen?

DAS war genau der Punkt warum ich meinen (Dos Shell) Batch Konverter erstmal nicht weitergeführt hatte. Insofern ist mein Post jetzt also problemlösungstechnisch nicht hilfreich. Mein Hauptproblem war soweit ich mich erinnere, für manche Bilder ist Automatische Belichtung erwünscht, für andere nicht. Ich war auch noch nicht am Punkt eigene Kurven in ImageMagick zu machen, die Frage ob man die Defaults da irrgendwo einstellen kann. Immerhin war ich soweit gekommen (hab mir jetzt Dein Script nicht angeschaut) in die JPEG Previews einzelne EXIF-Werte als Overlay reinzustempeln, was ich mittlerweile aber nur noch selten brauche.... Auf Ufraw war ich nicht gekommen, danke für den Hinweis, das muß ich mir auch noch mal anschauen.
 
LightZone 3.5 ist wohl - so mein erster Eindruck - eine klasse Software. Das "nicht so prickelnd" bezog sich auf Java. Die Performance ist dafür zwar noch erstaunlich gut - gemessen an nativen Implementierungen aber eher lahm. Selbst Silkypix 3.0 läuft unter Wine wohl noch schneller. Außerdem ist es natürlich keine große Kunst, wenn die Software ohnehin auf Java basiert, ein bischen hinzuzubasteln, so dass sie auch unter Linux läuft. Ich meine mich zu erinnern, dass die früheren Versionen nicht auf Java basierten.
 
Doch, auch meine Version hat schon Java dabei. Leider habe ich keinen großen Vergleich, aber vielleicht kannst Du meine Angaben mit Deinen mal vergleichen. Ich habe einen ca. 3 Jahre alten PC. Das Öffnen eines Verzeichnisses mit 666 .nef-Fotos dauert 4 Sekunden. Der Programmstart liegt etwa ähnlich, eher kürzer, wenn man die Vorschaubilder abzieht. Ein Bild zum Bearbeiten öffnen braucht bei mir einen Wimpernschlag. Ich finde die Geschwindigkeit als Anwender ausreichend. Batchverarbeitung (geht sowas damit?), habe ich noch keine laufen lassen, da meine Fotos zu sehr unterschiedlich sind für sowas. Was ist sonst noch zu bemängeln, wenn Du das nicht meinst? :eek:
 
Hat jemand inzwischen eigene bzw. neue Erfahrungen gesammelt?

Sowohl dcraw als auch Ufraw und digiKam haben ja inzwischen einige Fortschritte gemacht (auch in Hinblick auf Farbmanagement).

Ich stelle hier mal mein Skript cr2make zur Diskussion. Getreu dem Unix-Motto möglichst auf vorhandene Werkzeuge zu setzen, verwende ich make für den Workflow. Make hat auch den Vorteil, Jobs parallel abarbeiten zu können.

Das Skript sieht auf den ersten Blick vielleicht kompliziert aus, macht aber nur drei Dinge:

1) Ein Template (Workflow.ufraw) erstellen (falls es noch nicht existiert)
2) Ein Makefile erstellen (falls es noch nicht existiert)
3) make aufrufen

Über Workflow.ufraw definiere ich meine üblichen Ausgangsparameter, wie ICC-Profil, Basecurve, EV, ...

Wer es benutzen will, muss sich die Definition von Workflow.ufraw und für Makefile auf seine Bedürfnisse anpassen. Bei Workflow.ufraw mindestens die ICC-Profile, bei Makefile mindestens die Dateiendung RAWEXT für die Raw-Dateien.

Code:
#!/bin/bash
#
# Automated RAW workflow using ufraw, ImageMagick, ExifTool, and enfuse
#
#set -x

# Per-directory ufraw-Konfigurationsdatei erstellen, nur falls nicht schon vorhanden
test -e ./Workflow.ufraw || cat >./Workflow.ufraw <<'HERE_UFRAW'
<?xml version="1.0" encoding="utf-8"?>
<UFRaw Version='7'>
<WB>Camera WB</WB>
<Temperature>5000</Temperature>
<Green>1.0000</Green>
<Exposure>0.67</Exposure>
<AutoBlack>1</AutoBlack>
<WaveletDenoisingThreshold>10</WaveletDenoisingThreshold>
<Saturation>1.050000</Saturation>
<BaseCurve Current='no'>fotogenetic_point_and_shoot_v41
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.175758 0.250505</AnchorXY>
	<AnchorXY>0.353535 0.501010</AnchorXY>
	<AnchorXY>0.612658 0.749495</AnchorXY>
	<AnchorXY>1.000000 0.876573</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>fotogenetic_ev3_v42
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.201886 0.250505</AnchorXY>
	<AnchorXY>0.301010 0.377778</AnchorXY>
	<AnchorXY>0.404040 0.503030</AnchorXY>
	<AnchorXY>1.000000 0.876768</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>fotogenetic_provia_v40
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.183962 0.204541</AnchorXY>
	<AnchorXY>0.624116 0.709266</AnchorXY>
	<AnchorXY>0.749495 0.803597</AnchorXY>
	<AnchorXY>1.000000 0.963636</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>fotogenetic_white_wedding_v35
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.175758 0.250505</AnchorXY>
	<AnchorXY>0.353535 0.501010</AnchorXY>
	<AnchorXY>0.501010 0.672727</AnchorXY>
	<AnchorXY>0.747475 0.817914</AnchorXY>
	<AnchorXY>0.880808 0.880942</AnchorXY>
	<AnchorXY>0.957844 0.931716</AnchorXY>
	<AnchorXY>0.989899 0.975758</AnchorXY>
	<AnchorXY>1.000000 1.000000</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>OldSkoOLs mtb v1
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.117647 0.141176</AnchorXY>
	<AnchorXY>0.242647 0.299403</AnchorXY>
	<AnchorXY>0.867647 0.867647</AnchorXY>
	<AnchorXY>1.000000 1.000000</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>OldSkoOLs mtc_v1
	<AnchorXY>0.000000 0.000000</AnchorXY>
	<AnchorXY>0.117647 0.141176</AnchorXY>
	<AnchorXY>0.312960 0.391314</AnchorXY>
	<AnchorXY>0.867647 0.867647</AnchorXY>
	<AnchorXY>1.000000 1.000000</AnchorXY>
</BaseCurve>
<BaseCurve Current='no'>Optima2
	<AnchorXY>0.000000 0.022222</AnchorXY>
	<AnchorXY>0.047564 0.048483</AnchorXY>
	<AnchorXY>0.122449 0.176871</AnchorXY>
	<AnchorXY>0.164142 0.251701</AnchorXY>
	<AnchorXY>0.689971 0.765811</AnchorXY>
	<AnchorXY>1.000000 0.952381</AnchorXY>
</BaseCurve>
<BaseCurve Current='yes'>sReala2
	<AnchorXY>0.000000 0.011765</AnchorXY>
	<AnchorXY>0.055377 0.076976</AnchorXY>
	<AnchorXY>0.133333 0.207843</AnchorXY>
	<AnchorXY>0.690196 0.768627</AnchorXY>
	<AnchorXY>1.000000 0.952941</AnchorXY>
</BaseCurve>
<ManualCurve Current='yes'>
</ManualCurve>
<InputProfile Current='no'>6131_N
	<File>/usr/local/share/color/icc/6131_N.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='no'>6131_F
	<File>/usr/local/share/color/icc/6131_F.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Gamma>0.447368</Gamma>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='no'>6131_L
	<File>/usr/local/share/color/icc/6131_L.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='no'>6131_S
	<File>/usr/local/share/color/icc/6131_S.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='no'>6131_P
	<File>/usr/local/share/color/icc/6131_P.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='no'>6131_ntl
	<File>/usr/local/share/color/icc/6131_ntl.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<InputProfile Current='yes'>6131_std
	<File>/usr/local/share/color/icc/6131_std.icc</File>
	<ProductName>Canon EOS-1D</ProductName>
	<Linearity>0.100000</Linearity>
</InputProfile>
<sRGBOutputProfile Current='no'>
</sRGBOutputProfile>
<OutputProfile Current='yes'>sRGB_IEC61966-2-1_withBPC
	<File>/usr/local/share/color/icc/sRGB_IEC61966-2-1_withBPC.icc</File>
	<ProductName>IEC 61966-2-1 Default RGB Colour Space - sRGB</ProductName>
	<Gamma>1.000000</Gamma>
</OutputProfile>
<OutputProfile Current='no'>AdobeRGB1998
	<File>/usr/local/share/color/icc/AdobeRGB1998.icc</File>
	<ProductName>Adobe RGB (1998)</ProductName>
</OutputProfile>
</UFRaw>
HERE_UFRAW



# Makefile erzeugen, nur falls nicht vorhanden
test -e ./Makefile || cat >>./Makefile <<'HERE_MAKEFILE'
RAWEXT=CR2

WDTDIVISOR=8
JPGVIA=png

UFRAWOPTS=--overwrite --zip
DEPTH=16
USM=2.6x1.6+1.7+0.02
JPGQUALITY=90
IMOPTS=-unsharp $(USM) -quality $(JPGQUALITY)
EXIFOPTS=-exif:all -XMP:all -Meta:all -GeoTiff:all --ICC_Profile:all --XResolution --YResolution

EFEXPOSURES=-3 -2 -1 0 +1 +2 +3
EFOPTS=--compression=LZW
EFIMOPTS=-level 5% -unsharp $(USM) -quality $(JPGQUALITY)
EFUFRAWOPTS=--restore=clip --clip=digital --base-curve=linear --black-point=0 \
		--nozip --overwrite
EFEXIFOPTS=-exif:all -XMP:all -ICC_Profile:all -Meta:all -GeoTiff:all --XResolution --YResolution

ifndef VERBOSE
QUIET=>/dev/null
NOERR=2>/dev/null
SILENT=--silent
.SILENT:
endif

VPATH=./PNG:./JPG:./TIF:./PPM:./EFTIF:./EFJPG
.SUFFIXES: .$(RAWEXT) .ufraw .png .jpg .tif .ppm .ef.tif .ef.jpg

RAWFILES=$(shell find . -maxdepth 1 -name '*.$(RAWEXT)' | sort | sed -e 's/ /\\ /g')
UFRFILES=$(RAWFILES:.$(RAWEXT)=.ufraw)
PNGFILES=$(RAWFILES:.$(RAWEXT)=.png)
JPGFILES=$(RAWFILES:.$(RAWEXT)=.jpg)
TIFFILES=$(RAWFILES:.$(RAWEXT)=.tif)
PPMFILES=$(RAWFILES:.$(RAWEXT)=.ppm)
EFTIFFILES=$(RAWFILES:.$(RAWEXT)=.ef.tif)
EFJPGFILES=$(RAWFILES:.$(RAWEXT)=.ef.jpg)
EFFILES=$(shell find . -maxdepth 1 -name '*.ef' | sort | sed -e 's/ /\\ /g')

ifndef NOINTERMEDIATES
.SECONDARY: $(UFRFILES) $(PNGFILES) $(TIFFILES) $(PPMFILES) $(EFTIFFILES)
endif


all: jpg ef

jpg: $(JPGFILES)

png: $(PNGFILES)

tif: $(TIFFILES)

ppm: $(PPMFILES)

eftif: $(EFTIFFILES)

efjpg: $(EFJPGFILES)

ufraw: $(UFRFILES)

ef: $(EFFILES:.ef=.ef.jpg)

%.ufraw : %.$(RAWEXT)
	echo "[ Generating UFRAW file $@ for $< ]" 
	test -n "$(VERBOSE)" && set -x; \
	if [ -n "$(WDT)" ]; then \
		WDT=$(WDT); \
	else \
		ISO=`exiftool -ISO -s -s -s $<`; \
		WDT=`expr $$ISO / \( $(WDTDIVISOR) \* 10 \) \* 10`; \
	fi; \
	ufraw-batch --conf=./Workflow.ufraw --wavelet-denoising-threshold=$$WDT \
		--create-id=only $(UFRAWOPTS) $(SILENT) $<

ifeq ($(JPGVIA),direct)
%.jpg : %.ufraw %.$(RAWEXT)
	echo "[ Processing $(<:.ufraw=.$(RAWEXT)) into JPG file using $< ]"
	mkdir -p ./JPG
	ufraw-batch --out-type=jpeg --compression=$(JPGQUALITY) \
		--output=./JPG/$(@F) --create-id=no $(UFRAWOPTS) $(SILENT) $<
else
%.jpg : %.$(JPGVIA)
	echo "[ Converting $(<F) to JPG file ]"
	mkdir -p ./JPG
	convert ./$(shell echo "$(JPGVIA)" | tr a-z A-Z)/$(<F) $(IMOPTS) ./JPG/$(@F)
endif

%.png : %.ufraw %.$(RAWEXT)
	echo "[ Processing $(<:.ufraw=.$(RAWEXT)) into PNG file using $< ]"
	mkdir -p ./PNG
	ufraw-batch --out-type=png$(DEPTH) --output=./PNG/$(@F) --create-id=no \
		$(UFRAWOPTS) $(SILENT) $<

%.tif : %.ufraw %.$(RAWEXT)
	echo "[ Processing $(<:.ufraw=.$(RAWEXT)) into TIF file using $< ]"
	mkdir -p ./TIF
	ufraw-batch --out-type=tiff$(DEPTH) --output=./TIF/$(@F) --create-id=no \
		$(UFRAWOPTS) $(SILENT) $<
	exiftool -q -TagsFromFile $(<:.ufraw=.$(RAWEXT)) $(EXIFOPTS) -overwrite_original ./TIF/$(@F)

%.ppm : %.ufraw %.$(RAWEXT)
	echo "[ Processing $(<:.ufraw=.$(RAWEXT)) into PPM file using $< ]"
	mkdir -p ./PPM
	ufraw-batch --out-type=ppm$(DEPTH) --output=./PPM/$(@F) --create-id=no \
		$(UFRAWOPTS) $(SILENT) $<

%.ef.tif : %.ufraw %.$(RAWEXT)
	echo "[ Processing $(<:.ufraw=.$(RAWEXT)) into exposure fused TIF file using $< ]"
	test -n "$(VERBOSE)" && set -x; \
	mkdir -p ./EFTIF; \
	EFEXPOSURES="$(EFEXPOSURES)"; \
	EFOPTS="$(EFOPTS)"; \
	EFUFRAWOPTS="$(EFUFRAWOPTS)"; \
	EFEXIFOPTS="$(EFEXIFOPTS)"; \
	test -s $(<:.ufraw=.ef) && source $(<:.ufraw=.ef); \
	TMPFILES=""; \
	for e in $$EFEXPOSURES; do \
		FILE="$(@:.ef.tif=-$$e.tif)"; \
		TMPFILES="$$TMPFILES $$FILE"; \
		ufraw-batch --exposure=$$e --output=$$FILE --out-type=tiff8 --create-id=no \
			$$EFUFRAWOPTS $(SILENT) $< ; \
	done; \
	enfuse -o ./EFTIF/$(@F) $$EFOPTS $$TMPFILES $(QUIET); \
	exiftool -q -TagsFromFile $(<:.ufraw=.$(RAWEXT)) $$EFEXIFOPTS \
		-TagsFromFile $$FILE $$EFEXIFOPTS -overwrite_original ./EFTIF/$(@F) $(NOERR); \
	rm -f $$TMPFILES

%.ef.jpg : %.ef.tif
	echo "[ Converting $(<F) to exposure fused JPG file ]"
	test -n "$(VERBOSE)" && set -x; \
	mkdir -p ./EFJPG; \
	EFIMOPTS="$(EFIMOPTS)"; \
	EXIFOPTS="$(EXIFOPTS)"; \
	test -s $(<:.ef.tif=.ef) && source $(<:.ef.tif=.ef); \
	convert ./EFTIF/$(<F) $$EFIMOPTS ./EFJPG/$(@F) $(NOERR); \
	exiftool -q -TagsFromFile ./EFTIF/$(<F) $$EXIFOPTS  -overwrite_original ./EFJPG/$(@F) $(NOERR) 

clean: cleanpng cleanjpg cleantif cleanppm cleaneftif cleanefjpg

cleanpng:
	rm -f $(addprefix ./PNG/, $(PNGFILES))

cleanjpg:
	rm -f $(addprefix ./JPG/, $(JPGFILES))

cleantif:
	rm -f $(addprefix ./TIF/, $(TIFFILES))

cleanppm:
	rm -f $(addprefix ./PPM/, $(PPMFILES))

cleaneftif:
	rm -f $(addprefix ./EFTIF/, $(EFTIFFILES))

cleanefjpg:
	rm -f $(addprefix ./EFJPG/, $(EFJPGFILES))

allclean: clean
	rm -f $(UFRFILES)
	rm -rf ./JPG
	rm -rf ./PNG
	rm -rf ./TIF
	rm -rf ./PPM
	rm -rf ./EFTIF
	rm -rf ./EFJPG

HERE_MAKEFILE


# make ausführen
make -j 2 "$@"
 
Ich habe mir nochmals mein Bash-Skript aus dem ersten Posting dieses Threads (damals publiziert als "photourist") vorgenommen.

Vollautomatische RAW-Konvertierung
mit dcraw, ImageMagick und ExifTool
- 2. Version -

Da sich mittlerweile bei dcraw einiges getan hat, sowohl hinsichtlich der Erhaltung der Lichter (Highlight-Recovery) als auch hinsichtlich der Rauschunterdrückung, habe ich diesmal wieder auf dcraw anstatt auf ufraw-batch gesetzt.

Zielsetzung war und ist, ohne Einzelbild-bezogene Parametrierung eine größere Anzahl von Raw-Dateien vollautomatisch so zu konvertieren, dass sämtliche Bildinformationen erhalten bleiben und zugleich in bester und zugleich ansprechender Qualität in JPEG-Dateien umgesetzt werden.
Natürlich muss der Weißabgleich bereits bei der Raw-Aufnahme korrekt vorgenommen worden sein - der Wert wird hier übernommen.

Das Skript ist auf die Nikon D80 abgestimmt (.nef-Dateien), kann aber leicht für andere Kameras angepasst werden. Es setzt die Installation von dcraw, ExifTool und ImageMagick voraus. Es macht Folgendes:

In einem vorbereitenden Schritt werden alle im Verzeichnis des Skripts befindlichen Raw-Dateien nach folgendem Schema umbenannt:
Pyymmdd-hhmmss-nn.nef
Das eindeutige, auf dem Original-Aufnahmedatum der Raw-Dateien basierende Benennungsschema, tritt dem Umstand entgegen, dass bei den Nikon-DSLRs sich die Dateinamen nach Überlaufen des Zählers immer wiederholen. P steht für "Picture", yymmdd ist das Datum und hhmmss die Zeit aus den EXIF-Daten. nn ist eine eindeutige zweistellige Ergänzung, da es ja möglich sein kann, das zwei oder mehr Dateien dasselbe Datum und - sekundengenau - die gleiche Zeit aufweisen (bei Serienaufnahme, Dauer-Shooting).

In dem ersten Schritt werden die Dateien mit dcraw linear nach 16-Bit-PPM im sRGB-Farbraum konvertiert. Dabei wird auch die neue Wavelet-Denoise-Funktion genutzt.

Im zweiten Schritt werden die PPM-Dateien mittels ImageMagick (hier: Befehl "convert") nach JPEG umgewandelt. Dabei wird die Gammakorrektur, eine verlustfreie Kontrastspreizung (Erhaltung der hellsten und dunkelsten Pixel) und eine leichte USM-Schärfung vorgenommen. Abschließend werden die PPM-Dateien gelöscht.

Im dritten Schritt schließlich erfolgt die Übertragung der EXIF-Daten aus den Raw-Dateien durch Aufruf von ExifTool in die JPEG-Dateien; diese werden einmal mit und einmal ohne EXIF-Daten auf zwei Ordner (JPG und JPG_no-exif) verteilt. Als besonderes Highlight wird zum Schluss noch eine Index-Datei erzeugt (zur Übersicht, quasi als "Kontrollabzug").

Natürlich kann man das Skript optimieren (z.B. durch Pipes oder durch Zusammenfassung der vier Durchläufe in einen). Ich habe es jedoch bewusst einfach gehalten, so dass es leicht nachvollziehbar ist und auch ohne Weiteres von ungeübten "Skript-Programmierern" (wie mir) bei Bedarf angepasst werden kann.

Das Skript selbst folgt im nächsten Posting.
 
Zuletzt bearbeitet:
Hier nun der Code, optimiert für die Nikon D80 unter Ubuntu 8.04 Hardy Heron:
Code:
#!/bin/bash
#
# nef2jpg.sh
#
# Automated RAW workflow using dcraw, ImageMagick and ExifTool
# tested with dcraw 8.80, ImageMagick 6.3.7 and ExifTool 7.00
# on Linux (Ubuntu 8.04 'Hardy Heron')
# by Ruler_of_the_Thirds, 2008-07-31
#
# ANLEITUNG:
# Datei als nef2jpg.sh speichern, mit chmod u+x nef2jpg.sh ausführbar machen
# und in das Verzeichnis mit den zu konvertierenden RAW-Dateien kopieren.
# Aufruf in der Konsole: ./nef2jpg.sh
#
#
# Datei-Erweiterung der RAW-Dateien (hier: "nef" für Nikon) vorgeben
extension="nef"
# Abfragen, ob Programm im aktuellen Ordner bereits ausgeführt wurde
if [ -e nef2jpg.sh_COMPLETED ]; then
    echo "nef2jpg.sh has already been run. Nothing to be done."
    echo "Press <RETURN> to exit."
    read some_key && exit 1
fi
# Startzeit merken
start_time=`date +%R`
# RAW-Dateien zählen und Anzahl ausgeben
all_files="`ls *.$extension | wc -w`"
echo
echo "nef2jpg.sh by Ruler_of_the_Thirds"
echo "   $all_files files to be processed."
echo
echo "Preparation: renaming RAW files"
echo "--------------------------------------"
echo
# RAW-Dateien umbenennen
# Namensschema: "PYYMMDD-HHMMSS-NN.raw"
# YYMMDD-HHMMSS ist das Original-Datum mit Uhrzeit aus den EXIF-Daten
# NN wird aus den letzten zwei Stellen der Systemzeit in Nanosekunden gebildet
for i in *.$extension; do
    date_stamp=`exiftool -DateTimeOriginal -d "%Y%m%d-%H%M%S" $i`
    yymmdd_hhmmss=$(expr substr "`echo $date_stamp`" 24 36)
    unique_num=$(expr substr `date +"%N"` 8 9)
    i_renamed="P$yymmdd_hhmmss-$unique_num.$extension"
    mv $i $i_renamed
    echo "$i -> $i_renamed"
done
echo
echo "Renaming done."
echo
# Konvertierung mit dcraw. Ausgabe nach 16-Bit-PPM
count_files=1
echo "Step 1 of 3: starting RAW-conversion"
echo "--------------------------------------"
for i in *.$extension; do
    echo
    echo "converting RAW file $count_files / $all_files"
# -v = Verbose (Protokollierung auf Bildschirm)
# -w = Weißabgleich wie in der Kamera
# -H = Highlight recovery (Lichter wiederherstellen, Wert von 0 bis 9, 8 = zweithöchste Stufe)
# -n = wavelet deNoising (Entrauschung, Wert von 100 bis 1000)
# -o = Output color mode (1 = sRGB)
# -4 = Ausgabe als lineares 16-Bit PPM (ohne Gamma)
    dcraw -v -w -H 8 -n 250 -o 1 -4 $i
    let count_files=( $count_files + 1)
done
echo
echo "RAW-conversion done."
echo
echo "Step 2 of 3: starting PPM-processing"
echo "--------------------------------------"
count_files=1
for i in *.ppm; do
    echo
    echo "processing PPM file $count_files / $all_files"
# Umwandlung nach JPEG mit ImageMagick (hier: convert)
# -gamma = Gamma-Wert vorgeben
# -sigmoidal-contrast = Bild aufhellen
# -modulate = (hier: Sättigung erhöhen)
# -gaussian = Leichte Entrauschung durch Gauss-Filter
# -unsharp = Unscharfmaskierung (schärfen)
# -quality = JPEG-Komprimierung vorgeben
#  falls nötig: -gaussian 1x1
#  falls nötig: -sigmoidal-contrast 3,0%
    convert $i \
      -gamma 2.2 \
      -contrast-stretch 0 \
      -modulate 100,135,100 \
      -unsharp 2x1.3+1.2+0.02 \
      -quality 97 \
      `basename $i .ppm`.jpg
    echo "`basename $i .ppm`.jpg written."
    let count_files=( $count_files + 1)
done
echo
echo "PPM-processing done."
echo "Tidying up ..."
# Löschen der nicht mehr benötigten PPM-Dateien
rm -f *.ppm
echo "   done."
echo
echo "Step 3 of 3: transferring EXIF data"
echo "--------------------------------------"
count_files=1
for rawfile in `ls *.$extension`; do
    echo
    echo "transferring EXIF data $count_files / $all_files"
    jpgfile=`basename $rawfile .$extension`.jpg
# Übertragung der EXIF-Daten von den NEF- auf die JPEG-Dateien
    exiftool -TagsFromFile $rawfile -x Orientation $jpgfile
    sleep 2
    let count_files=( $count_files + 1)
done
echo
echo "Tidying up ..."
# Ordner für JPEG-Dateien ohne EXIFs anlegen
mkdir JPG_no-exif
# Ordner für JPEG-Dateien mit EXIFs anlegen
mkdir JPG
mv -f *.jpg_original JPG_no-exif/
mv -f *.jpg JPG/
# Index-Dateien generieren
echo "Generating index files ..."
convert 'vid:JPG/*.jpg' HTML:index.html
# Schutz vor unbeabsichtigtem Zweitlauf setzen
touch nef2jpg.sh_COMPLETED
echo "   done."
echo
echo "nef2jpg.sh finished."
# Startzeit und Endzeit ausgeben
echo "Time started: $start_time - finished: `date +%R`"
echo "--------------------------------------"
# Ende des Skripts.
 
Zuletzt bearbeitet:
P.S.
Nicht wundern, wenn die Zwischenergebnisse der PPM-Dateien während des Skriptlaufes im Konqueror oder Nautilus fast schwarz, dunkel-lila oder sonstwie merkwürdig aussehen - die wenigsten Linux-Programme können 16- bzw. 48-Bit-Bilddateien bisher korrekt darstellen (außer z.B. Krita, was aber m.E. noch nicht richtig rund läuft).
 
Wollt ihr Mal ein JPEG ooc gegen ein derart entwickeltes RAW zeigen? Würd mich sehr interessieren + die Frage wie ich das unter Windows mache.

Normal würd ich Lightroom nehmen, aber das mag meine NEFs nicht.
 
Für mich ist das Skript eher experimentelle Spielerei.
Ich will nicht sagen, dass die Ergebnisse schlecht wären oder man so nicht arbeiten könnte, doch finde ich die JPEGs direkt aus der D80 immer noch am besten - auch im Vergleich mit in Bibble konvertierten NEFs.
Um die Bildqualität der JPEGs out of cam über einen RAW-Konverter zu erreichen, muss man sich schon sehr anstrengen, d.h. auch Zeit und Know-How in die Parametrierung der Konvertierung für jedes einzelne Bild investieren.

Das Tolle an dcraw ist, dass die Bilder - auch ohne an das Einzelbild angepasste Belichtungskorrektur - so umgesetzt werden, dass keine Tonwerte abgeschnitten werden (solange nicht die RAW-Datei ausgefressene Lichter oder abgesoffene Schatten enthält).

Mindestens die Bilder, die das Histogramm nicht ganz ausfüllen, benötigen in der Regel noch eine Konstrastspreizung (Schwarz- und Weißpunkt) - Ausnahmen sind u.a. Highkey- und Lowkey-Aufnahmen (diese kann man aber ohnehin nicht automatisiert abfertigen wollen). Genau hier liegt der Haken: die Funktion "-contrast-stretch" von convert (oder modulate, beides Bestandteile von ImageMagick) arbeitet nur mit 0 als Parameter korrekt. Sobald man abweichend von 0 angibt, wieviel Pixel oder wieviel Prozent am oberen und unteren Ende des Histogramms abzuschneiden sind, gibt es Farbstiche, da die einzelnen Kanäle offensichtlich unabhängig voneinander bearbeitet werden. Auch die explizite Angabe mit "-channel RGB", was eigentlich der Defaultwert sein sollte, führt nicht zum farbstichfreien Ergebnis. Auch die Funktion "-normalize" ist kein Ausweg, da diese - obwohl farbstichfrei - zuviel Schatten und Lichter abschneidet. Die viel zu hohen, festeingebauten Werte lassen sich nicht beeinflussen.

"-contrast-stretch 0" führt nun dazu, dass selbst in einem sehr hellen Bild ohne große Tiefenanteile aber mit einem ganzen schwarzen "Dead-Pixel" der Schwarzpunkt nicht hochgesetzt wird, da ja keine Pixel abgeschnitten werden. Das "Dead-Pixel" ist dann die Referenz für den Schwarzpunkt. Entsprechend verhält es sich mit den Lichtern. Nicht nur Dead-Pixel, auch das Helligkeitsrauschen enthält unter Umständen Pixel, die außerhalb des normalen Kontrastumfang eines Bildes liegen. Sie bilden dann die Grenzen für "-contrast-stretch 0".

Immerhin bietet das Skript so den Vorteil, dass - im Rahmen der auf 8 Bit pro Farbkanal reduzierten Bilddaten - keine Bildinformation verloren geht. In der Regel ergibt sich so ein leichter Gewinn gegenüber der JPEG-out-of-cam-Datei, sofern man die mittels dieses Skripts erhaltenen JPEG-Dateien nachbearbeitet. Nachbearbeitung sollte ja aber gerade durch das Skript vermieden werden.

Die mittels des Skripts - bei den von mir gewählten Parametern - erhaltenen JPEG-Dateien zeigen grundsätzlich mehr Rauschen (die Erhöhung des Wertes in dcraw dürfte zuviel Details glattbügeln), dabei in Schattenbereichen besonders starkes Chroma-Rauschen. Immerhin sind die Bilder aber in den Schatten sehr gut durchgezeichnet, haben aber auch eine etwas flache, DRI-ähnliche Anmutung. Die Schärfe dürfte gleich gut oder etwas besser sein, als sie die Kamera sonst liefert.

Natürlich kann man am Ergebnis noch viel drehen: z.B. Gamma-Wert etwas runter, dafür aber "-sigmoidal-contrast 3%" (oder 4%) einfügen, um eine andere Tonwertverteilung zu erhalten. Auch kann man mit "-gaussian 1x1" das Grundrauschen reduzieren - dies geht aber zu Lasten der Detail-Schärfe.

Einfach mal selbst austesten. Mindestens eine Ubuntu-DVD dürfte ja fast jeder Leser irgendeines Computer-Magazines herumliegen haben ...
Daher verzichte ich auch auf den Aufwand, Vergleichsbilder (JPEG-out-of-cam, NEF-Bibble, NEF-dieses-Skript usw., die ich durchaus zahlreich zur Verfügung habe) hier forengerecht zu präsentieren - okay, zwei Beispiele folgen dennoch gleich.
 
Zuerst die ganzen Bilder, forengerecht kubisch herunterskaliert, nicht weiter geschärft:

1. Bild: JPEG-out-of-cam
2. Bild: NEF, konvertiert mit Bibble (allerdings mit feingetunten Parametern, etwas zu stark geschärft)
3. Bild: NEF, konvertiert mit dem obigen Skript
 
WERBUNG
Zurück
Oben Unten