API de métadonnées

Sharp fournit des fonctionnalités riches pour manipuler les métadonnées, permettant de lire, modifier et écrire les informations de métadonnées des images.

Lire les métadonnées

Utilisation de base

import sharp from 'sharp';

// Lire les métadonnées de l'image
const metadata = await sharp('input.jpg').metadata();
console.log(metadata);

Structure de l'objet de métadonnées

{
  format: 'jpeg',           // Format de l'image
  width: 1920,              // Largeur
  height: 1080,             // Hauteur
  space: 'srgb',            // Espace colorimétrique
  channels: 3,              // Nombre de canaux
  depth: 'uchar',           // Profondeur de bits
  density: 72,              // Résolution
  hasProfile: false,        // Présence d'un profil de couleur
  hasAlpha: false,          // Présence d'un canal alpha
  isOpaque: true,           // Opacité
  orientation: 1,            // Orientation EXIF
  exif: { ... },            // Données EXIF
  icc: { ... },             // Profil ICC
  iptc: { ... },            // Données IPTC
  xmp: { ... },             // Données XMP
  tifftagPhotoshop: { ... } // Tags TIFF Photoshop
}

Données EXIF

Lire EXIF

const metadata = await sharp('input.jpg').metadata();

if (metadata.exif) {
  console.log('Données EXIF:', metadata.exif);
  
  // Parser les données EXIF
  const exif = sharp.exif(metadata.exif);
  console.log('Date de prise:', exif.DateTime);
  console.log('Modèle d'appareil:', exif.Model);
  console.log('ISO:', exif.ISOSpeedRatings);
}

Écrire EXIF

// Créer des données EXIF
const exif = sharp.exif({
  IFD0: {
    ImageDescription: 'Image traitée par Sharp',
    Copyright: '© 2024'
  },
  IFD1: {
    Orientation: 1
  },
  EXIF: {
    DateTimeOriginal: new Date().toISOString(),
    UserComment: 'Traitement avec Sharp'
  }
});

// Écrire les données EXIF
await sharp('input.jpg')
  .withMetadata({ exif })
  .jpeg()
  .toFile('output.jpg');

Profils de couleur ICC

Lire le profil ICC

const metadata = await sharp('input.jpg').metadata();

if (metadata.icc) {
  console.log('Profil ICC:', metadata.icc);
}

Intégrer le profil ICC

// Intégrer le profil sRGB
await sharp('input.jpg')
  .withMetadata({ icc: 'srgb' })
  .jpeg()
  .toFile('output.jpg');

// Intégrer un profil ICC personnalisé
const iccProfile = fs.readFileSync('custom.icc');
await sharp('input.jpg')
  .withMetadata({ icc: iccProfile })
  .jpeg()
  .toFile('output.jpg');

Données IPTC

Lire IPTC

const metadata = await sharp('input.jpg').metadata();

if (metadata.iptc) {
  console.log('Données IPTC:', metadata.iptc);
}

Écrire IPTC

const iptc = {
  '2:05': 'Object Name',
  '2:15': 'Category',
  '2:25': 'Keywords',
  '2:55': 'Date Created',
  '2:80': 'By-line',
  '2:116': 'Copyright'
};

await sharp('input.jpg')
  .withMetadata({ iptc })
  .jpeg()
  .toFile('output.jpg');

Données XMP

Lire XMP

const metadata = await sharp('input.jpg').metadata();

if (metadata.xmp) {
  console.log('Données XMP:', metadata.xmp);
}

Écrire XMP

const xmp = `
<x:xmpmeta xmlns:x="adobe:ns:meta/">
  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <rdf:Description rdf:about=""
      xmlns:dc="http://purl.org/dc/elements/1.1/">
      <dc:title>Image traitée par Sharp</dc:title>
      <dc:creator>Sharp</dc:creator>
    </rdf:Description>
  </rdf:RDF>
</x:xmpmeta>
`;

await sharp('input.jpg')
  .withMetadata({ xmp })
  .jpeg()
  .toFile('output.jpg');

Informations d'orientation

Lire l'orientation

const metadata = await sharp('input.jpg').metadata();
console.log('Orientation de l'image:', metadata.orientation);

Rotation automatique

// Rotation automatique selon l'orientation EXIF
await sharp('input.jpg')
  .rotate()  // Rotation automatique
  .jpeg()
  .toFile('output.jpg');

Informations de résolution

Lire la résolution

const metadata = await sharp('input.jpg').metadata();
console.log('Résolution:', metadata.density);

Définir la résolution

await sharp('input.jpg')
  .withMetadata({ density: 300 })
  .jpeg()
  .toFile('output.jpg');

Conserver les métadonnées

Conserver toutes les métadonnées

// Conserver toutes les métadonnées existantes
await sharp('input.jpg')
  .resize(800, 600)
  .withMetadata()
  .jpeg()
  .toFile('output.jpg');

Conservation sélective

// Conserver uniquement les données EXIF
await sharp('input.jpg')
  .resize(800, 600)
  .withMetadata({ exif: true })
  .jpeg()
  .toFile('output.jpg');

// Conserver EXIF et ICC
await sharp('input.jpg')
  .resize(800, 600)
  .withMetadata({ exif: true, icc: true })
  .jpeg()
  .toFile('output.jpg');

Supprimer les métadonnées

Supprimer toutes les métadonnées

// Supprimer toutes les métadonnées
await sharp('input.jpg')
  .resize(800, 600)
  .jpeg()
  .toFile('output.jpg');

Supprimer des métadonnées spécifiques

// Supprimer EXIF mais conserver le reste
await sharp('input.jpg')
  .resize(800, 600)
  .withMetadata({ exif: false })
  .jpeg()
  .toFile('output.jpg');

Traitement par lot des métadonnées

Lecture par lot

const fs = require('fs').promises;

async function batchReadMetadata(directory) {
  const files = await fs.readdir(directory);
  const results = [];
  
  for (const file of files) {
    if (file.match(/\.(jpg|jpeg|png|webp)$/i)) {
      try {
        const metadata = await sharp(`${directory}/${file}`).metadata();
        results.push({ file, metadata });
      } catch (error) {
        console.error(`Échec de la lecture des métadonnées de ${file}:`, error.message);
      }
    }
  }
  
  return results;
}

Écriture par lot

async function batchWriteMetadata(directory, metadata) {
  const files = await fs.readdir(directory);
  
  for (const file of files) {
    if (file.match(/\.(jpg|jpeg|png|webp)$/i)) {
      try {
        await sharp(`${directory}/${file}`)
          .withMetadata(metadata)
          .toFile(`${directory}/processed_${file}`);
      } catch (error) {
        console.error(`Échec du traitement de ${file}:`, error.message);
      }
    }
  }
}

Validation des métadonnées

Valider l'intégrité des métadonnées

async function validateMetadata(filePath) {
  try {
    const metadata = await sharp(filePath).metadata();
    
    // Vérifier les propriétés de base
    if (!metadata.width || !metadata.height) {
      throw new Error('Informations de dimensions manquantes');
    }
    
    // Vérifier le format
    if (!metadata.format) {
      throw new Error('Informations de format manquantes');
    }
    
    // Vérifier le nombre de canaux
    if (!metadata.channels) {
      throw new Error('Informations de canaux manquantes');
    }
    
    return {
      valid: true,
      metadata
    };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

Optimisation des performances

Lire uniquement les métadonnées nécessaires

// Lire uniquement les informations de base, sans parser EXIF
const metadata = await sharp('input.jpg')
  .metadata({ pages: -1 });

// Lire uniquement EXIF
const metadata = await sharp('input.jpg')
  .metadata({ exif: true });

Traitement en flux

const fs = require('fs');

// Lire les métadonnées en flux
const stream = fs.createReadStream('input.jpg');
const metadata = await sharp(stream).metadata();

Gestion des erreurs

try {
  const metadata = await sharp('input.jpg').metadata();
  console.log('Métadonnées:', metadata);
} catch (error) {
  if (error.code === 'VipsForeignLoad') {
    console.error('Format d'image non supporté');
  } else if (error.code === 'VipsForeignLoadLimit') {
    console.error('Image trop grande');
  } else {
    console.error('Échec de la lecture des métadonnées:', error.message);
  }
}

Liens connexes

• Constructeur Sharp
• API de traitement d'image
• API de format de sortie
• API d'utilitaires