Wie lösche ich JPG-Dateien, aber nur wenn die passende RAW-Datei existiert?

Meine frühen Fotos (Canon G2) sind alle JPG-Bilder, aber als ich meine Nikon D90 bekam, habe ich zuerst JPG-Bilder aufgenommen, dann auf RAW + JPG umgestellt, und jetzt möchte ich nur noch auf RAW umstellen.

Ich habe buchstäblich Tausende von Fotos auf meiner Festplatte. Die Fotos befinden sich in Unterverzeichnissen (nach Datum) in einem einzigen Verzeichnis namens Import.

Ich bin dabei, alle diese Fotos in Lightroom 3.0 zu importieren. Ich möchte jedoch alle JPG-Dateien löschen, jedoch nur, wenn bereits eine entsprechende RAW-Datei vorhanden ist (dh ich möchte JPG- und RAW-Versionen nicht mehr beibehalten Datei).

Wenn ich das problemlos in Lightroom machen kann (nachdem ich alles importiert habe, einschließlich der doppelten JPG-Dateien), wäre das großartig. Es wäre auch in Ordnung, wenn es eine einfache Möglichkeit gäbe, dies vor dem Importieren der Dateien zu tun (dies würde jedoch hoffentlich nicht bedeuten, jedes Verzeichnis nach Dateinamen mit JPG- und NEF-Erweiterungen durchsuchen zu müssen).

Kennt jemand eine Möglichkeit, dies zu tun (in Lightroom oder mit einem Tool / Skript in Windows)?

Gehen Sie unter Windows zu dem Ordner und führen Sie diesen in einer Eingabeaufforderung aus:

for /f "delims==" %r in ('dir /b *.nef') do del "%~dpr%~nr.jpg" 2> nul

Im Grunde geht es durch den aktuellen Ordner, läuft durch die NEF-Dateien und löscht die JPG, falls vorhanden. Es ignoriert alle Fehler, wenn das JPG nicht vorhanden ist.

Wenn Sie Unterordner möchten, fügen Sie diese /sdem dirBefehl hinzu.

Hier ist eine modifizierte Version von Tomys Python-Skript . Unterschiede:

• Mehrere unformatierte Erweiterungen sind zulässig
• Entfernen Sie JPG nur, wenn sich die Paare im selben Ordner befinden. (Vermeiden Sie das versehentliche Entfernen eines JPGs, das wie eine Rohdatei in einem anderen Ordner benannt ist.)
• Groß- und Kleinschreibung wird nicht berücksichtigt

#!/usr/bin/env python
# Script:      remove_jpg_if_raw_exists.py
#
# Description: This script looks in all sub directories for
#              pairs of JPG and RAW files.
#              For each pair found the JPG is moved to a
#              waste basket directory.
#              Otherwise JPG is kept.
#
# Author:      Thomas Dahlmann
# Modified by: Renaud Boitouzet

import os
import shutil

# define your file extensions here, case is ignored.
# Please start with a dot.
# multiple raw extensions allowed, single jpg extension only
raw_extensions = (".Dng", ".cR2", ".nef", ".crw")
jpg_extension = ".jPg"

# define waste basket directory here. Include trainling slash or backslash.
# Windows : waste_dir = "C:\path\to\waste\"
waste_dir = "/Users/marvin/Pictures/waste/"

##### do not modify below ##########

# find files
def locate(folder, extensions):
    '''Locate files in directory with given extensions'''
    for filename in os.listdir(folder):
        if filename.endswith(extensions):
            yield os.path.join(folder, filename)

# make waste basket dir
if not os.path.exists(waste_dir):
    os.makedirs(waste_dir)

# Make search case insensitive
raw_ext = tuple(map(str.lower,raw_extensions)) + tuple(map(str.upper,raw_extensions))
jpg_ext = (jpg_extension.lower(), jpg_extension.upper())

root=os.curdir
#find subdirectories
for path, dirs, files in os.walk(os.path.abspath(root)):
    print path
    raw_hash = {}
    for raw in locate(path, raw_ext):
        base_name = os.path.basename(raw)
        base_name = os.path.splitext(base_name)[0]
        raw_hash[base_name] = True

    # find pairs and move jpgs of pairs to waste basket
    for jpg in locate(path, jpg_ext):
        base_name = os.path.basename(jpg)
        base_name = os.path.splitext(base_name)[0]
        if base_name in raw_hash:
            jpg_base_name_with_ext = base_name + jpg_extension
            new_jpg = waste_dir + jpg_base_name_with_ext
            print "%s: %s = %s => %s" % (path, base_name, jpg, waste_dir)
            if os.path.exists(new_jpg):
                os.remove(jpg)
            else:
                shutil.move(jpg, new_jpg)

Hier ist ein Python-Skript , das JPGDateien verschiebt , wenn keine entsprechende RAWDatei vorhanden ist. Nützlich unter Mac OS X !

import os
import shutil

raw_ext = '.CR2'
jpg_ext = '.JPG'
destination = '/Users/JohnSmith/Desktop/jpgs/'

for filename in os.listdir('.'):
    (shortname, extension) = os.path.splitext(filename)

    if extension == raw_ext:
        if os.path.isfile(shortname + jpg_ext):
            print 'Moving ' + shortname + jpg_ext + '...'
            shutil.move(shortname + jpg_ext, destination)

• Erstellen Sie eine leere Bibliothek
• Wählen Sie im Lightroom-Hauptmenü „Bearbeiten“> „Voreinstellungen“ (Windows) bzw. „Lightroom“> „Voreinstellungen“ (Mac OS).
• Deaktivieren Sie in den allgemeinen Einstellungen "JPEG-Dateien neben RAW-Dateien als separate Fotos behandeln".
  • Dies sollte die Standardeinstellung sein.
• Importieren Sie alle Ihre Dateien (Sie können Unterordner durchsuchen) und weisen Sie sie an , an einen neuen Speicherort zu wechseln
• Die JPG-Dateien mit RAW-Dateien verbleiben am ursprünglichen Speicherort, den Sie entfernen können

Soweit ich weiß, könnte das Vorschaubild in Lightroom RAW + JPG lauten, aber das JPG ist in keiner Weise gespeichert oder zugänglich.

Sie können auch ein ziemlich einfaches Stapelskript mit jeder Programmiersprache schreiben.

Ich mag das Bash-Skript für OS X (von T. Toivonen ), aber ich habe festgestellt, dass es einige Probleme gibt.

• Es hat mir nicht gefallen, meine Verzeichnisnamen, die Leerzeichen enthalten. Das erforderte eine etwas andere Behandlung des Find-Befehls.

• Das ursprüngliche Skript funktioniert nur für Erweiterungen in Kleinbuchstaben. Ich habe diesen Teil des Skripts leicht verbessert, um auch großgeschriebene Erweiterungen zu berücksichtigen. Beachten Sie, dass nur DNG+JPGoder dng+jpgPaare akzeptiert werden und Kombinationen wie DNG+jpgoder ignoriert werden DnG+JpG.

• Die ursprüngliche Lösung schlug nur einen wastedirSpeicherort vor, während mein Fix das Erstellen eines Unterverzeichnisses in jedem Verzeichniszweig während des Transports ermöglicht. Sie definieren einen Namen des Verzeichnisses vor der Schleife.

• Ich mag , um zu sehen , was los ist , vor allem , wenn mvoder rmBefehle verwendet werden;)

Aus Gründen des Raumes ich nur den letzten Teil des Skripts zeigt bin, von einer Einstellung basedir, wastedirund die Schleife.

[...]

#Now set it as a basedir
BASEDIR=$arg
WASTEDIR=duplicates
find "$BASEDIR" -iname '*.dng' -print0 | while read -d $'\0' filename 
    do
    filepath="${filename%/*}"
    basename="${filename##*/}"
    prefix="${basename%%.*}"
    suffix=${filename##*.}
    if [[ "$suffix" =~ [A-Z] ]]; then rsuffix="JPG"; else rsuffix="jpg"; fi 
    if [ -e "$filepath/$prefix.$rsuffix" ]; then
        let counter="$counter+1"
        if (( $isSetE==1 )); then
            echo "FOUND: $filepath/$prefix.$rsuffix"
        fi
        if (( $isSetM==1 )); then
            echo "Moving $filepath/$prefix.$rsuffix to $filepath/$WASTEDIR"
            if [ ! -d "$filepath/$WASTEDIR" ]; then mkdir "$filepath/$WASTEDIR"; fi
            mv "$filepath/$prefix.$rsuffix" "$filepath/$WASTEDIR"
        fi
        if (( $isSetD==1 )); then
            echo "Removing duplicate $filepath/$prefix.$rsuffix"
            rm "$filepath/$prefix.$rsuffix"
        fi
    fi
done

Hier ist eine Lösung für bash(Linux oder Mac OS X). Unter Windows können Sie Cygwin installieren , um eine Kopie von zu erhalten bash.

keep=$(ls | grep -v ps | grep -A1 JPG | grep NEF)
for i in $keep ; do
   mv $i $i.keep
done

ls | egrep -v '(JPG|keep)' | xargs rm -f

change=$(ls | grep keep | sed 's/.keep//g')
for i in $change ; do
   mv $i.keep $i
done

Hier ist eine andere bashVersion mit find(Linux). Wie bei Ben Pingilleys Antwort können Sie Cygwin installieren , um Bash unter Windows zu erhalten.

#!/bin/bash
read -p "please enter file suffix for raw format (e.g ORF, NEF, CR2): " suffix

find . -type f -iname "*.${suffix}" | \
while read line
do
  lowercase=$(echo "$line" | sed "s/${suffix}/jpg/gi")
  uppercase=$(echo "$line" | sed "s/${suffix}/JPG/gi")

  if [ -f "${lowercase}" ]
  then
    rm -v "${lowercase}"
  elif [ -f "${uppercase}" ]
  then
    rm -v "${uppercase}"
  else
    echo "${line}: no jpg present"
  fi
done

Hier ist meine Meinung zu diesem Thema. Viele gute Ideen kamen aus früheren Skripten, die hier erwähnt wurden.

Dies ist ein Bash - Skript für OS X . Es wird nach Dateien gesucht, die denselben Basisdateinamen und dieselben dng+jpgErweiterungen haben. Wenn a jpgmit genau demselben Namen wie gefunden wird dng, wird dieser Dateiname angezeigt ( -e), die Datei wird verschoben ( -m) oder gelöscht ( -d).

Es werden Unterordner durchsucht, sodass Sie es für Ihren gesamten Katalog oder nur für Teile davon verwenden können.

Für andere unformatierte Dateierweiterungen ersetzen Sie diese einfach *.dngim Skript durch Ihre bevorzugte Erweiterung.

Warnung: Sie können zwei verschiedene Bilder mit demselben Namen, aber unterschiedlicher Erweiterung haben. Das sind unvermeidliche Opfer dieses Skripts.

So verwenden Sie das Skript:

Usage: dng-jpg.sh [-m <path>] [-d <path>] [-e <path>] [-h]

-m: for move   (moves files to <path>/duplicates)
-d: for delete (deletes duplicate files)
-e: for echo   (lists duplicate files)
-h: for help 

Die grundlegende Verwendung würde folgendermaßen aussehen:

$ ./dng-jpg.sh -e /Volumes/photo/DNG/2015

Das würde alle Dateinamen von jpgDateien wiedergeben, die den Kriterien von beidem entsprechen, dngund jpgDateien mit demselben Namen.

Das Ergebnis würde ungefähr so ​​aussehen:

Echo selected with path: /Volumes/photo/DNG/2015
/Volumes/photo/DNG/2015/03/18/2015-03-18_02-11-17.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-10-50.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-10-56.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-11-39.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-11-54.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-12-26.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-12-43.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-13-21.jpg
/Volumes/photo/DNG/2015/06/01/2015-06-01_05-13-56.jpg
9 files found.

Wenn ich nun die Dateien löschen möchte, wechsle ich einfach -ezu -d:

$ ./dng-jpg.sh -d /Volumes/photo/DNG/2015

Oder wenn ich die Dateien nach / duplizieren möchte, führe ich sie mit aus -m.

$ ./dng-jpg.sh -m /Volumes/photo/DNG/2015

Jetzt jpgwären die doppelten Dateien in/Volumes/photo/DNG/2015/duplicates

Hier ist das Skript: dng-jpg.sh

#!/bin/bash

# Init variables
isSetM=0
isSetD=0
isSetE=0
isSetCount=0
counter=0

#Display usage info
usage() {

    cat <<EOF

Usage: dng-jpg.sh [-m <path>] [-d <path>] [-e <path>] [-h]

-m: for move   (moves files to <path>/duplicates)
-d: for delete (deletes duplicate files)
-e: for echo   (lists duplicate files)
-h: for help 

EOF
  exit 1
}

#Check for parameters
while getopts ":m:d:e:h" opt; do
  case ${opt} in
    m)
        isSetM=1
        let isSetCount="$isSetCount+1"
        arg=${OPTARG}
      echo "Move selected with path:" $arg
      ;;
    d)
        isSetD=1
        let isSetCount="$isSetCount+1"
        arg=${OPTARG}
      echo "Delete selected with path:" $arg
      ;;
    e)
        isSetE=1
        let isSetCount="$isSetCount+1"
        arg=${OPTARG}
      echo "Echo selected with path:" $arg
      ;;
    h)
        let isSetCount="$isSetCount+1"
        usage
      ;;
    \?)
      echo "Invalid option: -$OPTARG" >&2
      usage
      ;;
    :)
      echo "Option -$OPTARG requires a directory argument." >&2
      usage
      ;;
    *)
      usage
      ;;
  esac
done

# If no parameters, show usage help and exit
if test -z "$1"; then
    usage
fi

# If multiple parameters (not counting -a), show usage help and exit
if (($isSetCount > 1)); then
    usage
fi

#Verify directory
if [ ! -d "$arg" ]; then
  echo "$arg is not a path to a directory." >&2
  usage
fi

#Now set it as a basedir
BASEDIR=$arg
WASTEDIR="$BASEDIR/duplicates/"
if (( $isSetM==1 )); then
    mkdir $WASTEDIR
fi

for filename in $(find $BASEDIR -name '*.dng' -exec echo {} \; | sort); do
   prefix=${filename%.dng}
    if [ -e "$prefix.jpg" ]; then
        let counter="$counter+1"
        if (( $isSetE==1 )); then
            echo "$prefix.jpg"
        fi
        if (( $isSetM==1 )); then
            mv $prefix.jpg $WASTEDIR
        fi
        if (( $isSetD==1 )); then
            rm $prefix.jpg
        fi
    fi
done

echo "$counter files found."

Hier ist ein bashSkript für Mac OS X . Es kann unter Linux mit einigen Änderungen funktionieren.

#!/bin/bash
read -p "Delete JPEGs when DNG exists? Ctrl-C to cancel. [Enter] to continue: "

for FILE in *.dng; do
  JPG_FILE=$(echo "$FILE" | sed "s/dng/jpg/g")
  rmtrash "${JPG_FILE}" 1>/dev/null
done

rmtrashist ein Dienstprogramm, das Dateien in den Papierkorb verschiebt, anstatt sie sofort zu löschen. Sie können es von MacPorts folgendermaßen erhalten:

sudo port install rmtrash

Wenn Sie das vermeiden möchten, ersetzen Sie einfach rmtrashim Skript durch rm, wodurch die JPGDateien sofort gelöscht werden.

Ich habe das folgende Python-Skript geschrieben . Verglichen mit dem Skript von ttaveira leistet es zusätzliche Arbeit.

• Sucht in Unterverzeichnissen.
• Erstellt ein Zielmüllverzeichnis.
• Entfernt Dateien, die bereits im Abfallverzeichnis vorhanden sind, um Fehler beim Verschieben zu vermeiden.

# Script:      remove_jpg_if_raw_exists.py
#
# Description: This script looks in all sub directories for
#              pairs of JPG and RAW files.
#              For each pair found the JPG is moved to a
#              waste basket directory.
#              Otherwise JPG is kept.
#
# Author:      Thomas Dahlmann

import os, fnmatch

# define your file extensions here, case is ignored
raw_extension = "nef"
jpg_extension = "jpg"

# define waste basket directory here
waste_dir = "c:\image_waste_basked"

##### do not modify below ##########

# recursive find files 
def locate(pattern, root=os.curdir):
    '''Locate all files matching supplied filename pattern 
    in and below root directory.'''
    for path, dirs, files in os.walk(os.path.abspath(root)):
        for filename in fnmatch.filter(files, pattern):
            yield os.path.join(path, filename) 

# get base names from raw's
raw_hash = {}
for raw in locate("*." + raw_extension):
    base_name = os.path.basename(raw)
    base_name = os.path.splitext(base_name)[0]
    raw_hash[base_name] = True

# make waste basket dir
if not os.path.exists(waste_dir):
    os.makedirs(waste_dir)

# find pairs and move jpgs of pairs to waste basket    
for jpg in locate("*." + jpg_extension):
    base_name = os.path.basename(jpg)
    base_name = os.path.splitext(base_name)[0]
    if base_name in raw_hash:
        jpg_base_name_with_ext = base_name + "." + jpg_extension
        new_jpg = waste_dir + "\\" + jpg_base_name_with_ext
        print "%s => %s" % (jpg, waste_dir)
        if os.path.exists(new_jpg):
            os.remove(jpg)
        else:
            os.rename(jpg, new_jpg)

Bei der Arbeit mit Mac OS X fehlte mir in den vorherigen Antworten eine Überprüfung auf "gleichen Inhalt". Ich hatte doppelte Namen für verschiedene Bilder, weil ich vergessen hatte, den Bildzähler in meiner Kamera zu aktivieren. Hier ist meine Version, die die EXIF-Informationen auf die gleiche Aufnahmezeit überprüft:

Du musst rennen

sudo port install rmtrash exiv2

bevor Sie den folgenden Befehl verwenden können. Es wurde geschrieben, um JPGmit NEFDateien von meiner Nikon D90 zu vergleichen . Passen Sie die Dateierweiterungen an Ihre Bedürfnisse an.

find . -name \*.NEF |sed s/\.NEF/.JPG/g | xargs find 2>/dev/null | \
xargs perl -e 'foreach(@ARGV) {my $jpg=$_;my $nef=s/\.JPG/.NEF/r; my $tjpg = `exiv2 -g Exif.Photo.DateTimeOriginal -pt $jpg`; my $nef=s/\.JPG/.NEF/r; my $tnef = `exiv2 -g Exif.Photo.DateTimeOriginal -pt $nef`; if($tjpg eq $tnef) {print "$jpg\n"}}' | \
xargs rmtrash

Ohne die Vernunftsprüfung würde das Ganze zu einem sehr kurzen One-Liner:

find . -name \*.NEF |sed s/\.NEF/.JPG/g | xargs find 2>/dev/null | xargs rmtrash