Comment supprimer des fichiers JPG, mais uniquement si le fichier RAW correspondant existe?

Mes premières photos (Canon G2) sont toutes en JPG, mais quand j'ai eu mon Nikon D90, j'ai d'abord tourné en JPG, puis je suis passé en RAW + JPG, et maintenant je voudrais passer en RAW uniquement.

J'ai littéralement des milliers de photos sur mon disque dur. Les photos sont dans des sous-répertoires (par date) sous un seul répertoire appelé Import.

Je suis sur le point d'importer toutes ces photos dans Lightroom 3.0, cependant, je voudrais supprimer tous les fichiers JPG, mais uniquement là où il existe déjà un fichier RAW correspondant (c'est-à-dire que je ne souhaite plus conserver les mêmes versions JPG et RAW). fichier).

Si je peux le faire facilement dans Lightroom (après avoir tout importé, y compris les fichiers JPG en double), ce serait formidable. Ce serait également OK s'il y avait un moyen facile de le faire avant d'importer les fichiers (mais j'espère que cela n'impliquerait pas d'avoir à visiter chaque répertoire à la recherche de noms de fichiers avec les extensions JPG et NEF).

Quelqu'un connaît-il un moyen de le faire (dans Lightroom, ou avec un outil / script dans Windows)?

Sous Windows , accédez au dossier et exécutez-le dans une invite de commande:

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

Fondamentalement, il parcourt le dossier actuel, parcourt les fichiers NEF et supprime le JPG s'il est présent. Il ignore toutes les erreurs si le JPG n'est pas là.

Si vous voulez des sous-dossiers, incluez-les /sdans la dircommande.

Voici une version modifiée du script Python de Tomy . Différences:

• plusieurs extensions brutes autorisées
• supprimer jpg uniquement si les paires se trouvent dans le même dossier (éviter la suppression accidentelle d'un jpg nommé comme un fichier brut dans un autre dossier)
• insensible à la casse

#!/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)

Voici un script Python qui déplace des JPGfichiers lorsqu'il n'existe aucun RAWfichier correspondant . Utile sur 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)

• Créer une bibliothèque vide
• Dans le menu principal de Lightroom, choisissez Edition> Préférences (Windows) ou Lightroom> Préférences (Mac OS).
• Dans les préférences générales, désélectionnez "Traiter les fichiers JPEG à côté des fichiers bruts comme des photos séparées"
  • Ce devrait être la valeur par défaut.
• Importez tous vos fichiers (vous pouvez sélectionner des sous-dossiers de recherche), en lui disant de se déplacer vers un nouvel emplacement
• Les fichiers JPG contenant des fichiers RAW seront conservés à l'emplacement d'origine pour que vous puissiez les supprimer.

Si je comprends bien, la vignette dans lightroom pourrait indiquer RAW + JPG, mais le JPG n'est en fait ni stocké ni accessible de quelque manière que ce soit.

Vous pouvez également écrire un script batch assez simple avec n'importe quel langage de programmation.

J'aime le script bash pour OS X (par T.Toivonen ), mais j'ai remarqué qu'il y a quelques problèmes.

• Il n'aimait pas mes noms de répertoires, qui contiennent des espaces. Cela nécessitait une gestion un peu différente de la commande find.

• Le script d'origine ne fonctionne que pour les extensions en minuscules. J'ai légèrement amélioré cette partie du script pour tenir compte également des extensions en majuscules. Notez qu'il n'accepte DNG+JPGou ne fait que des dng+jpgpaires et qu'il ignorera toutes les combinaisons telles que DNG+jpgou DnG+JpG.

• La solution d'origine ne proposait qu'un seul wastediremplacement, alors que ma correction permet de créer un sous-répertoire sur chaque branche de répertoire au fur et à mesure de son déplacement. Vous définissez un nom du répertoire avant la boucle.

• J'aime voir ce qui se passe, surtout quand mvou des rmcommandes sont utilisées;)

Par souci d'espace, je ne montre que la dernière partie du script, de la définition de a basedir, wastediret la boucle.

[...]

#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

Voici une solution pour bash(Linux ou Mac OS X). Sous Windows, vous pouvez installer Cygwin pour obtenir une copie de 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

Voici une autre bashversion utilisant find(Linux). Comme pour la réponse de Ben Pingilley , vous pouvez installer Cygwin pour obtenir bash sur Windows.

#!/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

Voici mon point de vue sur cette question. Beaucoup de bonnes idées sont venues des scripts précédents mentionnés ici.

Ceci est un script bash pour OS X . Il recherche les fichiers qui existent avec le même nom de fichier de base et les mêmes dng+jpgextensions. Si un jpgest trouvé avec exactement le même nom que dng, ce nom de fichier s'affiche ( -e), le fichier est déplacé ( -m) ou supprimé ( -d).

Il passera par des sous-dossiers, vous pouvez donc l'utiliser pour l'ensemble de votre catalogue ou pour certaines parties de celui-ci.

Pour les autres extensions de fichiers brutes, remplacez simplement *.dngdans le script votre extension préférée.

Avertissement: vous pouvez avoir deux images différentes avec le même nom, mais une extension différente. Ce sont des victimes inévitables de ce script.

Voici comment utiliser le script:

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 

L'utilisation de base fonctionnerait comme ceci:

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

Cela ferait écho à tous les noms de jpgfichiers des fichiers qui correspondent aux critères d'avoir les deux dnget jpgfichier avec le même nom.

Le résultat ressemblerait à quelque chose comme ceci:

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.

Maintenant, si je veux supprimer les fichiers, je passerais simplement -eà -d:

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

Ou si je souhaite déplacer les fichiers vers / doublons, je l'exécuterai avec -m.

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

Maintenant, les jpgfichiers en double seraient dans/Volumes/photo/DNG/2015/duplicates

Voici le script: 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."

Voici un bashscript pour Mac OS X . Cela peut fonctionner sur Linux avec quelques modifications.

#!/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

rmtrashest un utilitaire qui déplace les fichiers vers la Corbeille, au lieu de les supprimer carrément. Vous pouvez l'obtenir auprès de MacPorts ainsi:

sudo port install rmtrash

Si vous souhaitez éviter cela, remplacez simplement rmtrashle script par rm, qui supprimera immédiatement les JPGfichiers.

J'ai écrit le script Python suivant . Comparé au script de ttaveira , il fait un travail supplémentaire.

• Recherche dans les sous-répertoires.
• Crée un répertoire de déchets de destination.
• Supprime les fichiers qui existent déjà dans le répertoire des déchets pour éviter les erreurs de déplacement.

# 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)

En travaillant sur Mac OS X , il me manquait un contrôle de cohérence pour le "même contenu" dans les réponses précédentes. J'avais des noms en double pour différentes photos car j'avais oublié d'activer le compteur d'images dans mon appareil photo. Voici ma version, qui vérifie les informations EXIF ​​pour le même temps de capture:

Vous devez courir

sudo port install rmtrash exiv2

avant de pouvoir utiliser la commande suivante. Il a été écrit pour être comparé JPGaux NEFfichiers de mon Nikon D90. Ajustez les extensions de fichiers en fonction de vos besoins.

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

sans la vérification de la santé mentale, le tout deviendrait un très court revêtement:

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