Der große RAW-Batch-Workflow-Thread

Ruler_of_the_Thirds · 1 August 2008

Nun die zugehörigen 100%-Crops:

1. JPEG-out-of-cam
2. NEF, konvertiert mit Bibble
3. NEF, konvertiert mit obigem Skript

Ruler_of_the_Thirds · 1 August 2008

Auf, zum zweiten Beispiel!
Gleiche Reihenfolge:
1. Bild: JPEG out of cam
2. Bild: NEF, konvertiert mit Bibble (allerdings nicht mit Default-Werten)
3. Bild: NEF, konvertiert mit obigem Skript

Ruler_of_the_Thirds · 1 August 2008

... auch 100%-Crops sollen nicht fehlen:
1. JPEG aus der Kamera
2. RAW, konvertiert mit Bibble Light (gibt's für nur 50,- Euro - auch für Linux!)
3. RAW, konvertiert mit dem Skript nef2jpg.sh (siehe oben)

Ruler_of_the_Thirds · 1 August 2008

Fazit:
Besonders die Grün-Wiedergabe gefällt mir bei den Original-D80-JPEGs am Besten. In Bibble und mit dcraw (Bibble basiert ja auf dcraw-Code) ist das Gras-Grün zu blass, zu "schilfig". Bei der D80 scheinen dcraw und Bibble - anders als bei den Olympus E-Kameras - mit der Rot-Wiedergabe kaum Probleme zu haben.

Mit meiner Standard-Einstellung der Bildoptimierung liefert die D80 knackige Bilder, die durchaus "fertig", d.h. ausbelichtbar oder druckreif sind. Auf RAW kann ich in den meisten Fällen verzichten. Der Zeitaufwand rechtfertigt nicht den geringen Gewinn an Qualität.

Hier die von mir empfohlene Bildoptimierung:

Aufnahme-Menü -> Bildoptimierung -> Benutzerdefiniert ->

Scharfzeichung : A(uto)
Tonwertkorrektur : A(uto) - eines der besten Features der D80!
Farbwiedergabe : IIIa
Farbsättigung : + Verstärkt
Farbtonkorrektur : 0°

Fertig -> OK

Auch Ken Rockwell (für Nikon-Freunde mein Nummer-Eins-Internet-Tipp!) hält nicht viel von RAW. In vielen Fällen hat er Recht, auch wenn er die Dinge manchmal etwas überzeichnet und sich auch selbst gerne widerspricht.

Ich werde in Kürze ein umfangreiches Fotobuch bei fotobuch-xxl (die Design-Software gibt es auch für Linux!!!) in Auftrag geben - erstmals mit unbearbeiteten JPEGs-out-of-cam. Meine Vorab-Einschätzung ist, dass die meisten DSLRs - bei entsprechender Konfiguration - brauchbarere Ergebnisse liefern, die unbearbeitet ausgegeben werden können, als so manche digitale Kompakte!

Natürlich muss man - zumindest bei der D80 - dann auch mit unkorrigierten CAs leben (eine automatische CA-Korrektur bei Verwendung von Nikkoren, wie bei den neuen Nikon-Profimodellen, wäre mein Hauptanliegen für eine verbesserte Firmware der D80 oder das Nachfolgemodell).

Übrigens: wer Lust hat, kann in das Skript ja eine automatisierte CA-Korrektur einbauen (dcraw bietet seit einiger Zeit eine CA-Korrekturfunktion). Einfach per ExifTool bei jeder NEF-Datei das verwendete Objektiv abfragen und über eine kleine Datenbank mit empirisch für bestimmte Brennweitenbereiche gewonnenen CA-Korrekturwerten die CAs eliminieren ...

Ruler_of_the_Thirds · 1 August 2008

Für viele dürften die beiden Hauptbeweggründe, in RAW aufzunehmen, darin bestehen, dass man sich am Set keine Gedanken über den Weißabgleich zu machen braucht und das Material (die RAW-Datei) einem mehr Nachlässigkeiten bei der Belichtung durchgehen lässt.

Wie haben nur die analogen Fotografen existieren können?
Die Belichtung und der Weißabgleich mussten schon bei Aufnahme stimmen.

Was die Belichtung angeht, verwende ich ohnehin fast nur die Spotmessung (meist Messung auf die Lichter). Wenn der Kontrastumfang zu groß für das Material ist, verwende ich Grauverlaufsfilter.
Den Weißabgleich habe ich auch bei RAW-Aufnahme immer schon bei Aufnahme "korrekt" bzw. wie beabsichtigt eingestellt.

Apropos Weißabgleich: es gibt nicht wenige Analog-Naturfotografen, die Tageslichtfilm, beispielsweise Fuji Velvia, verwenden - grundsätzlich ohne Konversions- oder Farbkorrekturfilter (d.h. Grau-, Grauverlaufs- und Polfilter ausgenommen), egal zu welcher Tages- oder Nachtzeit! Dem entspricht die digitale Arbeitsweise, bei Natur- und Landschaftsaufnahmen grundsätzlich ~5200 Kelvin oder den "Sonnenschein"-Festwert zu verwenden. Dies ist auch mein Ansatz - in den meisten der Fälle. Nur so bleibt der Seheindruck des menschlichen Auges und die empfundene Lichtstimmung im Bild erhalten (Produktfotografie ist da ein ganz anderer Spezialfall).

Eine stimmige Belichtung im Moment der Aufnahme und ein auf Anhieb sitzender Weißabgleich - beides sind zwei Gründe weniger für RAW. Außerdem gibt es ja noch so nette Dinge, wie D-Lighting ...

Kawasaki · 1 August 2008

Ruler_of_the_Thirds schrieb:
.........
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).
........

Hallo Ruler,

ist es richtig, dass sich diese Aussage auf die Verwendung von:

# -H = Highlight recovery (Lichter wiederherstellen, Wert von 0 bis 9, 8 = zweithöchste Stufe)

bezieht? Hast Du diverse Parameter für dcraw durchgetestet, oder warum bist Du bei dem Wert 8 angelangt? Sind keine falschen Farben aufgetreten? Bisweilen verwende ich den Wert 5 und habe den Eindruck, dass auch dadurch noch ein wenig in den Lichtern fehlt, welches ich mit anderen Konvertern (z.B. RSW oder C1) doch noch rausholen kann.

dcraw ist ja ständig in der Fortentwicklung begriffen - gibts denn noch andere Parameter, die für das Abgreifen des vollständigen Dynamikbereiches zuständig sind? Vielleicht weißt Du da mehr.

VG
Kawa

Ruler_of_the_Thirds · 2 August 2008

Kawasaki schrieb:
Hallo Ruler,

ist es richtig, dass sich diese Aussage auf die Verwendung von:

[Parameter -H]

bezieht? Hast Du diverse Parameter für dcraw durchgetestet, oder warum bist Du bei dem Wert 8 angelangt? Sind keine falschen Farben aufgetreten? Bisweilen verwende ich den Wert 5 und habe den Eindruck, dass auch dadurch noch ein wenig in den Lichtern fehlt, welches ich mit anderen Konvertern (z.B. RSW oder C1) doch noch rausholen kann.
[...]

Ja.

Ich habe nicht viel durchgetestet, aber festgestellt, dass bei Werten um 3 bis 5 einfach zuviel in den Lichtern verloren geht. Mit dem Wert 9 scheint dcraw sämtliche Informationen im rechten Bereich des Histogramms zu retten, daher habe ich dann 8 gewählt, damit die Lichter nicht so arg dunkel abgebildet wirken.
Falsche Farben: bei ausfressenen Lichtern, d.h. Bereichen, für die schon im RAW mindestens zwei Kanäle übergelaufen sind, tritt im entwickelten JPEG leider statt reinweiß oft rosa auf. Dies Problem besteht bei dcraw schon lange, wenn sich das verhalten auch gebessert zu haben scheint; auch bei Bibble hatte ich es früher mal ganz stark mit RAW-Dateien aus der Olympus E-500.

amq · 2 August 2008

Schöne Gegenüberstellung. Hast Du mit viel Aufwand toll erklärt und veranschaulicht

Ich bin momentan auch wieder bei JPEG zurück und vermisse bisher nichts *g*. Eine automatische Kontrastspreizung, so dass das Histogramm gefüllt ist wäre aber

Ruler_of_the_Thirds · 2 August 2008

So ... wir kommen der Sache näher.

Das Schema der Umbennung der RAW-Files habe ich dahingehend geändert, dass der Benutzer ein sprechendes Text-Label (mit Bezug zum Aufnahmeort, zu Personen oder zum Anlass der Aufnahmen) eingeben kann, welches dem Dateinamen beigegeben wird: PYYMMDD-HHMMSS-NN-bezeichnung.raw

Ich habe noch ein paar Dinge bei dcraw geändert:
-H 0 (kein Highlight-Recovery; ausgefressene Lichter werden abgeschnitten, behebt eventuelles Problem mit pink in Highlights)
-q 3 (neu eingefügt: AHD-Interpolations-Algorithmus, evtl. abweichend vom Default-Wert, den dcraw automatisch je nach Kameramodell selbst wählt)

Bei convert habe ich geändert:
-sigmoidal-contrast 2,0% (neu eingefügt: zur leichten Aufhellung)
-unsharp 2x1.2+1.3+0.02 (dritten Wert auf 1.3 erhöht)

Außerdem lasse ich zur Geschwindigkeitssteigerung dcraw und convert über nice aufrufen (vielleicht bringt es ja etwas).

Die neue Version folgt im nächsten Posting. Die nun erzielten Ergebnisse gefallen mir noch besser bzw. kommen den JPEGs-out-of-cam noch näher.

Ein gutes Tutorial zu dcraw habe ich bei Guillermo Luijk gefunden:
http://www.guillermoluijk.com/tutorial/dcraw/index_en.htm
Dort werden auch die meisten Parameter erklärt.

Ruler_of_the_Thirds · 2 August 2008

Verbesserte Version:

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
# improved version: 2008-08-02
#
# 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
# Dateien umbenennen
# Namensschema: "PYYMMDD-HHMMSS-NN-bezeichnung.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
# bezeichnung wird vom Benutzer abgefragt
echo "The files are going to be renamed according to the scheme"
echo "PYYMMDD-HHMMSS-NN-label.$extension."
echo "The label may refer to the location, person or reason of the photos." 
echo "Please enter label text (no spaces, only 0-9 and a-z):"
read text_label
echo
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-$text_label.$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 (0=clip, 1=no clip, 2=neutral grey blown areas, 3-9=highlight recovery)
# -n = wavelet deNoising (Entrauschung, Wert von 100 bis 1000)
# -o = Output color mode (0=none, 1=sRGB, 2=AdobeRGB, 3=WideGamut, 4=ProPhoto, 5=XYZ)
# -q = Quality (0=bilinear, 1=VNG, 2=PPG, 3=AHD)
# -4 = Ausgabe als lineares 16-Bit PPM (ohne Gamma)
    nice dcraw -v -w -H 0 -n 250 -o 1 -q 3 -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
    nice convert $i \
      -gamma 2.2 \
      -contrast-stretch 0 \
      -sigmoidal-contrast 2,0% \
      -modulate 100,135,100 \
      -unsharp 2x1.2+1.3+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.

Ruler_of_the_Thirds · 14 August 2008

Für andere RAW-Dateien als .NEF einfach in Zeile 18 statt "nef" die Dateiendung (ohne Punkt) eingeben. Insofern als dcraw und exiftool das jeweilige Format unterstützen, dürfte das Skript diese problemlos abarbeiten.

third · 5 September 2008

Hallo zusammen,

Glaube mit diesem wunderbaren Skript endlich gefunden zu haben was ich suche.
Allerdings stimmt bei der RAW-Entwicklung mit dcraw bei mir noch irgendetwas nicht, helle bereiche werden pink.
Dennoch hier die abgespeckte Windows des Skripts.
Bis auf den 50%-Resize habe alle Parameter aus dem Original Linux-Skript übernommen aber ich war leider nicht in der Lage die Ausgabe und Umbenennung in Windows Batch zu übersetzen.

Code:

FOR %%I IN (*.ORF) DO (dcraw -v -w -H 0 -n 250 -o 1 -q 3 -4 %%I)

FOR %%I IN (*.ppm) DO (convert.exe %%I -resize 50%% -contrast-stretch 0 -sigmoidal-contrast 2,0%% -modulate 100,135,100  -unsharp 2x1.2+1.3+0.02 -quality 97 %%~nI.JPG) 

FOR %%I IN (*.ORF) DO (exiftool -TagsFromFile %%I -x Orientation %%~nI.JPG)

DEL *.ppm

Wenn jemand weiß wie ich das pink weg bekomme kann ich es sogar so benutzen ;-)
Um vorerst leicht optimierte, verkleinerte Bilder zu bekommen wende ich das folgende Skript auf meine out-of-the-camera-JPEGs an und bin sehr zufrieden:
Es schärft etwas, hellt ein bisschen auf und setzt die Sättigung etwas hinauf, alles klein aber fein.
Dann verkleinert es noch auf 50% und macht das ganze noch einmal in Schwarz-Weiß.

Code:

FOR %%I IN (*.JPG) DO (convert.exe %%I -resize 50%% -contrast-stretch 0 -sigmoidal-contrast 1,0%% -modulate 100,110,100  -unsharp 2x1.2+1.3+0.02 -quality 97 %%~nI_50.JPG
convert.exe %%I -resize 50%% -contrast-stretch 0 -sigmoidal-contrast 1,0%% -modulate 100,110,100  -unsharp 2x1.2+1.3+0.02 -quality 97 -colorspace Gray %%~nI_50_bw.JPG)

Vielleicht gibt es noch jemanden, der sich damit auskennt und mir die folgenden magischen Zeilen zur Umbenennung mittels Exif-Daten in Windows-Batch übersetzen kann?

Code:

read text_label
echo
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-$text_label.$extension"
    mv $i $i_renamed
    echo "$i -> $i_renamed"
done

Die erste Zeile zum einlesen "Set /P T=" hab ich schon ;-)

Ist ein echt tolles Forum mit klasse Beiträgen.

pkolloch · 12 September 2008

Habt ihr schon mal ExifTool zum Raw konvertieren verwendet?

exiftool -b -JpgFromRaw raw_name.NEF >jpeg_name.jpg

Das ist auf meinem Rechner sehr flott und ich bin mit den resultaten bis auf wenige Ausnahmen zufrieden. Allerdings muss ich zugeben, dass ich nach den ersten RAW-Versuchen wieder daran denke, die Kamera das Umwandeln uebernehmen zu lassen...

exiftool kann man wohl auch ohne zusaetzliches Skript rekursiv verwenden:

exiftool -b -JpgFromRaw -w _JFR.JPG -ext CRW -r .

(noch nie ausprobiert)

nubi · 12 September 2008

pkolloch schrieb:
Habt ihr schon mal ExifTool zum Raw konvertieren verwendet?

exiftool -b -JpgFromRaw raw_name.NEF >jpeg_name.jpg

Damit extrahierst Du die von der Kamera erzeugten JPEG-Vorschauen. :ugly:

nabla² · 16 Oktober 2008

Hi ruler,

ich habe den ersten Teil deines Skripts fuer mein Skript, welches nur
die Daten von der Kamera zieht, verwendet. Ich finde das mit der
unique_num nicht optimal geloest, da sie ja mehr oder weniger
zufaellig ist. Ich habe einen Zaehler hinzugefuegt, der einfach
hochzaehlt, wenn Dateien mit gleicher Zeit vorhanden sind. Dadurch
bleiben die Bilder in der richtigen Reihenfolge. Ich poste einfach
mein Skript (welches ich an meine Anforderung angepasst habe), bei
Interesse findest du ja den angesprochenen Teil.

Danke

Code:

#!/bin/bash 

extension=CR2
FOLDER=/home/sebschub/Dokumente/Bilder/RAW


extensionLC=`echo $extension | tr "[:upper:]" "[:lower:]"`

echo Getting RAW files from camera

mkdir $FOLDER/temp
cd $FOLDER/temp

echo Temporary saving to $FOLDER/temp

gphoto2 --get-all-raw-data

for i in *.$extension; do
    # Datum fuer Dateinamen
    date_stamp=`exiftool -DateTimeOriginal -d "%Y%m%d-%H%M%S" $i`
    yyyymmdd_hhmmss=$(expr substr "`echo $date_stamp`" 22 36)

    # Datum fuer Verzeichnisse mit Bindestrichen
    date_stamp=`exiftool -DateTimeOriginal -d "%Y-%m-%d" $i`
    yyyymmdd=$(expr substr "`echo $date_stamp`" 22 32)
    yyyymm=$(expr substr "`echo $yyyymmdd$`" 1 7)

    mkdir -p ../$yyyymm/$yyyymmdd

    unique_num=1
    i_renamed="../$yyyymm/$yyyymmdd/$yyyymmdd_hhmmss-`printf "%02i" $unique_num`.$extensionLC"
    while [ -e $i_renamed ]; do
	unique_num=$[$unique_num+1]
	i_renamed="../$yyyymm/$yyyymmdd/$yyyymmdd_hhmmss-`printf "%02i" $unique_num`.$extensionLC"
    done
    mv $i $i_renamed
    echo "$i -> $i_renamed"
done

cd ..

rmdir $FOLDER/temp
echo Removing temporary folder $FOLDER/temp

echo FINISHED

third · 26 Dezember 2008

wollte nur mitteilen, dass ich mit imagemagick und jhead (autorot anhand exif) nach wie vor äußerst zufrieden bin und nach meinem linux-Umzug nun mit folgenden Schnipseln die jpegs die meine Olympus E 410 liefert zum schnellen betrachten und umhertauschen nachberabeite:

Code:

mkdir resized; for i in *.jpg; do convert ${i} -resize 50% -contrast-stretch 0 -sigmoidal-contrast 1,0% -modulate 100,105,100 -unsharp 1x1.2+1.3+0.02 -quality 93 resized/${i}; done

und

Code:

jhead -nf%Y%m%d-%Hh%Mm%S_TAG -ft *.JPG
jhead -autorot *.JPG

picture'sulm · 2 April 2009

Hallo,

da ich momentan Krank geschrieben bin und viel Zeit habe, habe ich mich mit dem Thema RAW und meiner Olympus E-520 etwas auseinandergesetzt.
Da bin ich auf diesen Thread gestoßen und mußte das gleich mal probieren.
Grund dafür ist, dass ich kein Programm gefunden habe zum schnellem erstellen von jpg's. Ich habe mich durch mehrere Programme getestet und kein passendes gefunden was mir richtig spaß macht.
Problem war nur die Tools im Thread auch für Windows nutzbar zu machen und so habe es nach einem Tag endlich geschaft. Meine Lösung besteht aus dcraw/imagemagick und exiftool. Alles als quasi portable Version, man muß nix installieren oder so. Alles in einen Ordner packen, Verknüpfungen in der bat anpassen und fertig. Das ganze habe ich noch ins "sendto" von Windows gepackt und kann nun per rechte Maustaste problemlos jpg's erstellen ohne weiteres zutun. Verwendet habe ich folgende Versionen

Dcraw für Windows
Imagemagick für Windows
Exiftool Windows Executable

Und hier meine Bat-Datei

Code:

@echo off
md "%~dp1"jpg
for %%I in ("%~dp1"*.orf) do (
d:\programme\raw_tools\dcraw.exe -v -w -H 8 -n 250 -o 1 -4 %%I
D:\Programme\raw_tools\ImageMagick-6.5.1\convert.exe %%~dpnI.ppm -gamma 2.2 -contrast-stretch 0 -sigmoidal-contrast 2,0%% -modulate 100,135,100 -unsharp 2x1.2+1.3+0.02 -quality 90 %~dp1jpg\%%~nI.jpg
del %%~dpnI.ppm
d:\programme\raw_tools\exiftool.exe -overwrite_original -TagsFromFile %%I -x Orientation %~dp1jpg\%%~nI.JPG
)

Mit den verschiedenen Einstellungen der Tools kann ja jeder selber noch experimientieren und sein Optimum finden.

Ruler_of_the_Thirds · 14 April 2009

So, das hier funktioniert mit der Fujifilm FinePix S100FS:

Code:

#!/bin/bash
#
# raf2jpg
# Automatisierter RAW-Workflow für die Fujifilm FinePix S100FS
# unter Benutzung von dcraw, ImageMagick und ExifTool
# (c) 2009 dagg_och_gryning
#
# ACHTUNG:
# erfolgreich getested mit dcraw 8.88
# (die meisten Linux-Distributionen enthalten ein veraltetes dcraw!)
#
# ANLEITUNG:
# Datei als raf2jpg speichern, mit chmod u+x raf2jpg ausführbar machen
# und in das Verzeichnis mit den zu konvertierenden RAW-Dateien kopieren.
# Aufruf in der Konsole: ./raf2jpg
#
if [ -e raf2jpg_done ]; then
    echo "raf2jpg has already been run. Nothing to be done."
    echo "Press <RETURN> to exit."
    read some_key && exit 1
fi
start_time=`date +%R`
all_files="`ls DSCF*.RAF | wc -w`"
echo "Starting raf2jpg by dagg_och_gryning"
echo "   $all_files files to be processed."
echo

echo "Preparation: renaming RAF files"
echo "-------------------------------------------------"
echo "The files are going to be renamed according to the scheme"
echo "PYYMMDD-HHMMSS-NN-label.RAF."
echo "The label may refer to the location, person or occasion." 
echo "Please enter label text (no spaces, only 0-9 and a-z):"
read text_label
echo
for raffile in DSCF*.RAF; do
    date_stamp=`exiftool -DateTimeOriginal -d "%Y%m%d-%H%M%S" $raffile`
    yymmdd_hhmmss=$(expr substr "`echo $date_stamp`" 24 36)
    unique_num=$(expr substr `date +"%N"` 8 9)
    raf_renamed="P$yymmdd_hhmmss-$unique_num-$text_label.RAF"
    mv $raffile $raf_renamed
    echo "$raffile -> $raf_renamed"
done
echo "... Renaming done."
echo
count_files=1
echo "Step 1 of 3: starting RAW-conversion (RAF->TIFF)"
echo "------------------------------------------------"
for rawfile in P*.RAF; do
    echo "processing RAF-file $count_files / $all_files"
    dcraw -w -H 4 -b 2.1 -n 64 -T $rawfile
    let count_files=( $count_files + 1)
done
echo "... Conversion done."
echo
echo "Step 2 of 3: starting TIFF-processing (TIFF->JPG)"
echo "-------------------------------------------------"
count_files=1
for tifffile in P*.tiff; do
    echo "processing TIFF-file $count_files / $all_files"
    convert \
      -contrast-stretch 0 \
      -sigmoidal-contrast 5,30% \
      -modulate 100,115 \
      -unsharp 1.5x1+4.0+0.10 \
      -quality 99 \
      $tifffile \
      `basename $tifffile .tiff`.jpg
    let count_files=( $count_files + 1)
done
echo
echo "Tidying up ..."
rm -f P*.tiff
echo "... TIFF files deleted."
echo
echo "Step 3 of 3: transferring EXIF data"
echo "-------------------------------------------------"
count_files=1
for rawfile in `ls P*.RAF`; do
    echo "processing $count_files / $all_files"
    jpgfile=`basename $rawfile .RAF`.jpg
    exiftool -TagsFromFile $rawfile -x Orientation $jpgfile
    sleep 2
    let count_files=( $count_files + 1)
done
echo
echo "Tidying up ..."
mkdir JPG_backup
mkdir JPG
mv -f P*.jpg_original JPG_backup/
mv -f P*.jpg JPG/
touch raf2jpg_done
echo "... JPG files moved."
echo
echo "Workflow finished."
echo "Duration: started $start_time, finished `date +%R`."
echo "-------------------------------------------------"
# Ende des Skripts

Sobald ich weiß, wie dcraw die Parameter für die CA-Korrektur erwartet und verwendet, könnte ich eine Brennweitenabhängige CA-Korrektur einbauen ...
Was mich bis dahin noch stört ist, dass bei der Umwandlung von TIFF nach JPG (convert-Befehl) CAs an Spitzlichtern manchmal sehr dunkel, fast schwarz, werden und dabei hässliche Artefakte bekommen.

Man könnte vielleicht auch nach 16-Bit-TIFFs ausgeben, statt nach 8 Bit. Dann sähe der convert-Befehl natürlich anders aus.
Was mir nachwievor nicht gefällt, ist die Grün-Wiedergabe (zu blass, heufarben). Ein Farb-Profil für die S100FS habe ich im Netz bisher nicht gefunden.

Shake · 15 Mai 2009

Vielen Dank erstmal für die bisherige Arbeit. Das Resultat ist wirklich schon recht gut.
Ich hoffe, das geht so weiter.

Eine Anregung hätte ich: Wie wäre es, wenn du die Endung der Raw-Dateien in einer Variablen speichern würdest, da doch jeder Hersteller hier eine andere hat...

cantorice · 4 Juli 2009

Ich habe vor einiger Zeit mal auf Basis des Skripts ein eigenes erstellt, welches ich letzte Woche vervollständigt habe. Vielleicht interessiert es den ein oder anderen.

Ich verwende greycstoration zum entrauschen der Bilder (nur das Farbrauschen wird entfernt, das Helligkeitsrauschen bleibt erhalten. Das ganze erfolgt ISO abhängig.
Anschließend wird das Bild mittels ImageMagick skaliert und geschärft. Zum Schluss werden noch die Exifs kopiert (greycstoration entfernt sie) und in eine Ordnerstruktur kopiert.

Als Ausgangsmaterial dienen bei mir JPG Dateien von UFRaw.

Code:

#!/bin/bash
#
# Automated RAW workflow using ImageMagick
# tested with ImageMagick 6.2.4 (2008-Feb-28)
#
# Original script by photourist
# https://www.dslr-forum.de/showthread.php?p=1390951
#
# 2006-Nov-29 - photourist
# 2008-Feb-28 - icecold
# 2009-Jun-29 - icecold
#
# Variable festlegen
cpu=2

# JPG-Dateien zählen
all_files="`ls *.jpg | wc -w`"
echo "Starting RAW workflow by icecold"
echo "   $all_files files to be processed."
echo
count_files=1
echo "starting JPG-processing"
for i in *.jpg
  do
    date_stamp=`exiftool -DateTimeOriginal -d "%Y-%m-%d" $i`
    yymmdd=$(expr substr "`echo $date_stamp`" 24 30)
    mkdir $yymmdd
    mkdir $yymmdd/Original
    mkdir $yymmdd/greycstoration
    
    echo "processing JPG-file $count_files / $all_files"
    isowert=`exiftool $i | grep "ISO                         "`
    echo "processing file $i"
    echo "$isowert"	
	if [[ $isowert =~ " 3200" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 200 \
			-p 0 \
			-a 0 \
			-alpha 32 \
			-sigma 32 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
		convert `basename $i .jpg`_gc.jpg \
		     -resize 1920x1920 \
		     -unsharp 1x0.5+0.5+0.2 \
		     -quality 95 \
		     `basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 2500" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 200 \
			-p 0 \
			-a 0 \
			-alpha 12 \
			-sigma 10 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
   		convert `basename $i .jpg`_gc.jpg \
		     -resize 1920x1920 \
		     -unsharp 1x1+1+0.1 \
		     -quality 95 \
		     `basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 2000" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 120 \
			-p 0.1 \
			-a 0.1 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
   		convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1x1.2+1.1+0.1 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 1600" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 120 \
			-p 0.1 \
			-a 0.1 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg      
   		convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1x1.2+1.1+0.1 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg 

	elif [[ $isowert =~ " 1250" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 100 \
			-p 0.2 \
			-a 0.2 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
      
	   	convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1x1.2+1.1+0.1 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
    	elif [[ $isowert =~ " 1000" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 100 \
			-p 0.2 \
			-a 0.2 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
        		-o `basename $i .jpg`_gc.jpg    
   		convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1x1.2+1.1+0.1 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    	
	elif [[ $isowert =~ " 800" ]]
	then
		greycstoration \
			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 100 \
			-p 0.2 \
			-a 0.2 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg      
   		convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1x1.2+1.1+0.1 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 640" ]]
	then
		greycstoration \
		      	-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 80 \
			-p 0.4 \
			-a 0.4 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
  		      	-o `basename $i .jpg`_gc.jpg
	     	convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1.2x1.1+1.05+0.05 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 500" ]]
	then
		greycstoration \
   		   	-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 80 \
			-p 0.4 \
			-a 0.4 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
   		     	-o `basename $i .jpg`_gc.jpg
	     	convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1.2x1.1+1.05+0.05 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 400" ]]
	then
		greycstoration \
		      	-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 80 \
			-p 0.4 \
			-a 0.4 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
     		convert `basename $i .jpg`_gc.jpg \
     			-resize 1920x1920 \
     			-unsharp 1.2x1.1+1.05+0.05 \
     			-quality 95 \
     			`basename $i .jpg`_.jpg
    
	elif [[ $isowert =~ " 320" ]]
	then
		greycstoration \
    			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 50 \
			-p 0.8 \
			-a 0.8 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg
	
	elif [[ $isowert =~ " 250" ]]
	then
		greycstoration \
    			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 50 \
			-p 0.8 \
			-a 0.8 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg
	elif [[ $isowert =~ " 200" ]]
	then
		greycstoration \
    			-restore $i \
			-cbase 1 \
			-crange 1,2 \
			-visu false \
			-se 0 \
			-threads $cpu \
			-fast true \
			-dt 50 \
			-p 0.8 \
			-a 0.8 \
			-alpha 1 \
			-sigma 1 \
			-prec 1 \
			-dl 0.8 \
			-da 30 \
			-interp 0 \
		        -o `basename $i .jpg`_gc.jpg
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg

	elif [[ $isowert =~ " 160" ]]
	then
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg
	elif [[ $isowert =~ " 125" ]]
	then
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg
	elif [[ $isowert =~ " 100" ]]
	then
		convert `basename $i .jpg`_gc.jpg \
		     	-resize 1920x1920 \
		     	-unsharp 1.2x1.1+1.05+0.05 \
		     	-quality 95 \
		     	`basename $i .jpg`_.jpg
	fi
    	echo "copy exif data..."
		exiftool -TagsFromFile $i `basename $i .jpg`_gc.jpg
		rm `basename $i .jpg`_gc.jpg_original
	    	exiftool -TagsFromFile $i `basename $i .jpg`_.jpg
		rm `basename $i .jpg`_.jpg_original
	echo "rename original..."
		mv $i `basename $i .jpg`_original.jpg
		mv `basename $i .jpg`_.jpg $i
	echo "move to $yymmdd"
		mv `basename $i .jpg`_original.jpg $yymmdd/Original/
		mv $i $yymmdd/
		mv `basename $i .jpg`_gc.jpg $yymmdd/greycstoration/
	
    let count_files=( $count_files + 1)
done
echo "Workflow finished."
# Ende des Skripts.