Comment supprimer des données EXIF ​​sans recompresser le JPEG?

Je souhaite supprimer les informations EXIF ​​(y compris la vignette, les métadonnées, les informations de l'appareil photo ... tout!) Des fichiers JPEG, mais je ne veux pas les recompresser, car recompresser le JPEG dégradera la qualité, ainsi que généralement augmenter le taille du fichier.

Je recherche une solution Unix / Linux, encore meilleure si vous utilisez la ligne de commande. Si possible, utilisez ImageMagick (outil de conversion). Si ce n'est pas possible, un petit script Python, Perl, PHP (ou un autre langage courant sur Linux) conviendrait.

Il y a une question similaire, mais liée à .NET .

exiftool fait le travail pour moi, il est écrit en perl donc devrait fonctionner pour vous sur n'importe quel o / s

https://exiftool.org/

utilisation:

exiftool -all= image.jpg

Avec imagemagick:

convert <input file> -strip <output file>

ImageMagick a le paramètre -strip , mais il recompresse l'image avant de l'enregistrer. Ainsi, ce paramètre est inutile pour mon besoin.

Ce sujet du forum ImageMagick explique qu'il n'y a pas de support pour les opérations JPEG sans perte dans ImageMagick (chaque fois que cela change, veuillez poster un commentaire avec un lien!), Et suggère d'utiliser jpegtran (de libjpeg):

jpegtran -copy none -progressive image.jpg > newimage.jpg
jpegtran -copy none -progressive -outfile newimage.jpg image.jpg

(Si vous n'êtes pas sûr que je réponde à ma propre question, lisez ceci et ceci et cela )

Vous voudrez peut-être également vous pencher sur Exiv2 - c'est très rapide (C ++ et pas de recompression), c'est une ligne de commande, et il fournit également une bibliothèque pour la manipulation EXIF ​​avec laquelle vous pouvez établir un lien. Je ne sais pas combien de distributions Linux le rendent disponible, mais dans CentOS, il est actuellement disponible dans le dépôt de base.

Usage:

exiv2 rm image.jpg

Je proposerais jhead:

man jhead
jhead -purejpg image.jpg

Seulement 123 Ko sur debian / ubuntu, ne se recompresse pas. Notez cependant que cela mute l'image, alors copiez l'original si vous en avez besoin.

J'ai récemment entrepris ce projet en C. Le code ci-dessous fait ce qui suit:

1) Obtient l'orientation actuelle de l'image.

2) Supprime toutes les données contenues dans APP1(Données Exif) et APP2(Données Flashpix) en les effaçant.

3) Recrée le APP1marqueur d'orientation et le définit sur la valeur d'origine.

4) Recherche le premier EOImarqueur (Fin de l'image) et tronque le fichier si nécessaire.

Certaines choses à noter en premier sont:

1) Ce programme est utilisé pour mon appareil photo Nikon. Le format JPEG de Nikon ajoute quelque chose à la toute fin de chaque fichier qu'il crée. Ils encodent ces données jusqu'à la fin du fichier image en créant un deuxième EOImarqueur. Normalement, les programmes d'image lisent jusqu'au premier EOImarqueur trouvé. Nikon a des informations après cela que mon programme tronque.

2) Comme il s'agit du format Nikon, il suppose l' big endianordre des octets. Si votre fichier image utilise little endian, certains ajustements doivent être effectués.

3) En essayant de ImageMagicksupprimer des données exif, j'ai remarqué que je me suis retrouvé avec un fichier plus volumineux que celui avec lequel j'avais commencé. Cela m'amène à croire qu'il Imagemagicks'agit d'encoder les données que vous souhaitez supprimer et de les stocker ailleurs dans le fichier. Appelez-moi à l'ancienne, mais lorsque je supprime quelque chose d'un fichier, je veux qu'une taille de fichier soit plus petite sinon la même taille. Tous les autres résultats suggèrent l'exploration de données.

Et voici le code:

#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <string.h>
#include <errno.h>

// Declare constants.
#define COMMAND_SIZE     500
#define RETURN_SUCCESS     1
#define RETURN_FAILURE     0
#define WORD_SIZE         15

int check_file_jpg (void);
int check_file_path (char *file);
int get_marker (void);
char * ltoa (long num);
void process_image (char *file);

// Declare global variables.
FILE *fp;
int orientation;
char *program_name;

int main (int argc, char *argv[])
{
// Set program name for error reporting.
    program_name = basename(argv[0]);

// Check for at least one argument.
    if(argc < 2)
    {
        fprintf(stderr, "usage: %s IMAGE_FILE...\n", program_name);
        exit(EXIT_FAILURE);
    }

// Process all arguments.
    for(int x = 1; x < argc; x++)
        process_image(argv[x]);

    exit(EXIT_SUCCESS);
}

void process_image (char *file)
{
    char command[COMMAND_SIZE + 1];

// Check that file exists.
    if(check_file_path(file) == RETURN_FAILURE)
        return;

// Check that file is an actual JPEG file.
    if(check_file_jpg() == RETURN_FAILURE)
    {
        fclose(fp);
        return;
    }

// Jump to orientation marker and store value.
    fseek(fp, 55, SEEK_SET);
    orientation = fgetc(fp);

// Recreate the APP1 marker with just the orientation tag listed.
    fseek(fp, 21, SEEK_SET);
    fputc(1, fp);

    fputc(1, fp);
    fputc(18, fp);
    fputc(0, fp);
    fputc(3, fp);
    fputc(0, fp);
    fputc(0, fp);
    fputc(0, fp);
    fputc(1, fp);
    fputc(0, fp);
    fputc(orientation, fp);

// Blank the rest of the APP1 marker with '\0'.
    for(int x = 0; x < 65506; x++)
        fputc(0, fp);

// Blank the second APP1 marker with '\0'.
    fseek(fp, 4, SEEK_CUR);

    for(int x = 0; x < 2044; x++)
        fputc(0, fp);

// Blank the APP2 marker with '\0'.
    fseek(fp, 4, SEEK_CUR);

    for(int x = 0; x < 4092; x++)
        fputc(0, fp);

// Jump the the SOS marker.
    fseek(fp, 72255, SEEK_SET);

    while(1)
    {
// Truncate the file once the first EOI marker is found.
        if(fgetc(fp) == 255 && fgetc(fp) == 217)
        {
            strcpy(command, "truncate -s ");
            strcat(command, ltoa(ftell(fp)));
            strcat(command, " ");
            strcat(command, file);
            fclose(fp);
            system(command);
            break;
        }
    }
}

int get_marker (void)
{
    int c;

// Check to make sure marker starts with 0xFF.
    if((c = fgetc(fp)) != 0xFF)
    {
        fprintf(stderr, "%s: get_marker: invalid marker start (should be FF, is %2X)\n", program_name, c);
        return(RETURN_FAILURE);
    }

// Return the next character.
    return(fgetc(fp));
}

int check_file_jpg (void)
{
// Check if marker is 0xD8.
    if(get_marker() != 0xD8)
    {
        fprintf(stderr, "%s: check_file_jpg: not a valid jpeg image\n", program_name);
        return(RETURN_FAILURE);
    }

    return(RETURN_SUCCESS);
}

int check_file_path (char *file)
{
// Open file.
    if((fp = fopen(file, "rb+")) == NULL)
    {
        fprintf(stderr, "%s: check_file_path: fopen failed (%s) (%s)\n", program_name, strerror(errno), file);
        return(RETURN_FAILURE);
    }

    return(RETURN_SUCCESS);
}

char * ltoa (long num)
{
// Declare variables.
        int ret;
        int x = 1;
        int y = 0;
        static char temp[WORD_SIZE + 1];
        static char word[WORD_SIZE + 1];

// Stop buffer overflow.
        temp[0] = '\0';

// Keep processing until value is zero.
        while(num > 0)
        {
                ret = num % 10;
                temp[x++] = 48 + ret;
                num /= 10;
        }

// Reverse the word.
        while(y < x)
        {
                word[y] = temp[x - y - 1];
                y++;
        }

        return word;
}

J'espère que cela aide quelqu'un!

Astuce pour plus de commodité: si vous êtes sous Windows, vous pouvez appliquer un fichier REG au registre, pour installer une entrée dans le menu contextuel, afin de pouvoir facilement supprimer les métadonnées en cliquant avec le bouton droit sur le fichier et en sélectionnant la commande.

Par exemple (n'oubliez pas de modifier les chemins pour pointer vers l'endroit où les exécutables sont installés sur votre ordinateur):

Pour les fichiers JPEG, JPG, JPE, JFIF: commande " Supprimer les métadonnées "
(à l'aide d' ExifTool , conserve le fichier d'origine comme sauvegarde)
exiftool -all= image.jpg

JPG-RemoveExif.reg

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Classes\jpegfile\shell\RemoveMetadata]
@="Remove metadata"
[HKEY_CURRENT_USER\Software\Classes\jpegfile\shell\RemoveMetadata\command]
@="\"C:\\Path to\\exiftool.exe\" -all= \"%1\""
[HKEY_CURRENT_USER\Software\Classes\jpegfile\shell\RemoveMetadata]
"Icon"="C:\\Path to\\exiftool.exe,0"

Pour les fichiers PNG: commande " Convertir en PNG minifié "
(en utilisant ImageMagick , change les données en écrasant le fichier d'origine)
convert -background none -strip -set filename:n "%t" image.png "%[filename:n].png"

PNG-Minify.reg

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Classes\pngfile\shell\ConvertToMinifiedPNG]
@="Convert to minified PNG"
[HKEY_CURRENT_USER\Software\Classes\pngfile\shell\ConvertToMinifiedPNG\command]
@="\"C:\\Path to\\convert.exe\" -background none -strip -set filename:n \"%%t\" \"%1\" \"%%[filename:n].png\""
[HKEY_CURRENT_USER\Software\Classes\pngfile\shell\ConvertToMinifiedPNG]
"Icon"="C:\\Path to\\convert.exe,0"

Connexes: convertir des PNG en ICO dans le menu contextuel .

Nous l'avons utilisé pour supprimer les données de latitude du fichier TIFF:

exiv2 mo -M"del Exif.GPSInfo.GPSLatitude" IMG.TIF où vous pouvez utiliser exiv2 -pa IMG.TIFpour répertorier toutes les métadonnées.

Pour la bande EXIF ​​sans perte, vous pouvez utiliser libexif , qui est disponible avec cygwin . Supprimez à la fois EXIF ​​et la vignette pour anonymiser une image:

$ exif --remove --tag=0 --remove-thumbnail exif.jpg -o anonymized.jpg

.batFichier glisser- déposer à utiliser avec cygwin:

@ECHO OFF
exif --remove --tag=0 --remove-thumbnail %~1

Autre logiciel:

MetAbility QuickFix

"MetabilityQuickFix supprime toutes vos informations personnelles et données de localisation GPS de toutes vos photos, d'un simple clic de souris. Il supprime en toute sécurité tous les éléments de métadonnées des blocs de données Exif, Iptc et XMP de vos fichiers JPEG et effectue automatiquement des copies de sauvegarde des fichiers originaux "

Décapant JPEG et PNG

"Un outil pour supprimer / nettoyer / supprimer les métadonnées (indésirables) inutiles des fichiers JPG / JPEG / JFIF et PNG. La qualité d'image N'EST PAS AFFECTÉE. Inclut la prise en charge de la ligne de commande. Spécifiez simplement un dossier ou un fichier sur la ligne de commande (caractères génériques autorisés)"

Si vous utilisez déjà jpegoptim, vous pouvez également l'utiliser pour supprimer l'exif.

jpegoptim -s *