AWS Rekognition

Le service de vision par ordinateur qui utilise le deep learning pour identifier des objets, personnes, textes et activités dans les images et vidéos, transformant des données visuelles en informations exploitables.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'AWS Rekognition ?

Imaginez avoir un assistant capable d'analyser instantanément des milliers de photos et vidéos pour y repérer des visages, des objets, du texte ou même des comportements spécifiques. C'est exactement ce que fait AWS Rekognition : il "voit" et comprend le contenu visuel comme le ferait un humain, mais à une échelle et une vitesse bien supérieures.

AWS Rekognition est comme un expert en analyse d'images et de vidéos qui peut rapidement parcourir vos fichiers visuels et vous dire qui ou quoi y apparaît, si le contenu est inapproprié, ou même reconnaître du texte dans les images.

Ce que Rekognition peut faire pour vous

Reconnaissance faciale

Détecter des visages dans les images, analyser leurs caractéristiques, estimer l'âge et les émotions, ou même vérifier si deux visages correspondent à la même personne.

Identification d'objets

Reconnaître automatiquement des milliers d'objets, de scènes et d'activités dans les images et les vidéos, comme des voitures, des animaux ou des paysages.

Modération de contenu

Détecter automatiquement le contenu inapproprié ou offensant dans les images et vidéos, aidant à protéger votre marque et vos utilisateurs.

Analyse vidéo

Suivre les personnes et objets à travers une vidéo, comprendre leurs mouvements et comportements, et créer des chronologies d'événements.

En résumé, AWS Rekognition transforme vos données visuelles brutes en informations structurées et exploitables, sans nécessiter d'expertise en vision par ordinateur. Il permet aux entreprises d'automatiser l'analyse d'images et de vidéos, de renforcer la sécurité, d'améliorer l'expérience utilisateur et de découvrir des insights précieux cachés dans leurs contenus visuels.

Pour les développeurs

Fonctionnement technique

AWS Rekognition est un service de vision par ordinateur entièrement géré qui utilise des réseaux de neurones profonds (deep learning) pour analyser des images et des vidéos. Il propose des API simples à utiliser qui peuvent identifier des objets, des personnes, du texte, des scènes et des activités, ainsi que détecter tout contenu inapproprié.

Fonctionnalités principales et exemples

Analyse d'image et détection d'objets

L'API de détection de labels identifie les objets, concepts, scènes et actions présents dans une image stockée dans S3, renvoyant des informations précises avec des scores de confiance et la localisation des objets.

Analyse d'images avec Node.js et AWS SDK

// Exemple d'utilisation de l'SDK AWS avec Node.js pour l'analyse d'images
import { RekognitionClient, DetectLabelsCommand } from "@aws-sdk/client-rekognition";
import { readFileSync } from "fs";

async function detectLabels(imagePath) {
  // Lire l'image depuis le système de fichiers
  const imageBytes = readFileSync(imagePath);
  
  // Initialiser le client Rekognition
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  // Configuration de la requête
  const params = {
    Image: {
      Bytes: imageBytes
    },
    MaxLabels: 10,
    MinConfidence: 70
  };

  try {
    // Exécuter la commande de détection de labels
    const command = new DetectLabelsCommand(params);
    const response = await client.send(command);
    
    // Traiter les résultats
    console.log("Labels détectés:");
    
    response.Labels.forEach(label => {
      console.log(`${label.Name} (confiance: ${label.Confidence.toFixed(2)}%)`);
      
      // Afficher les instances (localisations) des objets s'il y en a
      if (label.Instances && label.Instances.length > 0) {
        console.log("  Instances trouvées:");
        label.Instances.forEach(instance => {
          const box = instance.BoundingBox;
          console.log(`  - Position: x=${box.Left.toFixed(2)}, y=${box.Top.toFixed(2)}, largeur=${box.Width.toFixed(2)}, hauteur=${box.Height.toFixed(2)}`);
        });
      }
    });
    
    return response.Labels;
    
  } catch (error) {
    console.error("Erreur lors de la détection de labels:", error);
    throw error;
  }
}

// Exemple d'utilisation
async function analyzeProductImage() {
  console.log("Analyse de l'image produit...");
  const labels = await detectLabels("./product_image.jpg");
  
  // Vérifier si l'image contient certaines catégories spécifiques
  const categories = {
    "Électronique": ["Electronics", "Phone", "Computer", "Laptop", "Tablet", "Camera"],
    "Vêtements": ["Clothing", "Apparel", "Shirt", "Pants", "Dress", "Shoe"],
    "Alimentation": ["Food", "Fruit", "Vegetable", "Meat", "Beverage"],
    "Mobilier": ["Furniture", "Chair", "Table", "Sofa", "Bed", "Desk"]
  };
  
  // Déterminer la catégorie la plus probable
  const foundCategories = new Map();
  
  for (const [category, keywords] of Object.entries(categories)) {
    for (const label of labels) {
      if (keywords.includes(label.Name)) {
        if (!foundCategories.has(category)) {
          foundCategories.set(category, 0);
        }
        foundCategories.set(category, foundCategories.get(category) + label.Confidence);
      }
    }
  }
  
  if (foundCategories.size > 0) {
    // Trouver la catégorie avec le score de confiance total le plus élevé
    let highestCategory = "";
    let highestScore = 0;
    
    for (const [category, score] of foundCategories.entries()) {
      if (score > highestScore) {
        highestCategory = category;
        highestScore = score;
      }
    }
    
    console.log(`
Catégorie de produit détectée: ${highestCategory} (score: ${(highestScore / 100).toFixed(2)})`);
  } else {
    console.log("
Aucune catégorie de produit identifiée clairement");
  }
}

analyzeProductImage();

Analyse faciale

Rekognition peut détecter des visages dans les images, analyser leurs attributs (âge, émotions, présence de lunettes, etc.) et même comparer des visages pour vérifier leur similarité.

Analyse faciale avec AWS Rekognition

// Exemple d'analyse faciale avec AWS Rekognition
import { RekognitionClient, DetectFacesCommand, CompareFacesCommand } from "@aws-sdk/client-rekognition";
import { readFileSync } from "fs";

async function analyzeFace(imagePath) {
  // Lire l'image depuis le système de fichiers
  const imageBytes = readFileSync(imagePath);
  
  // Initialiser le client Rekognition
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  // Configuration de la requête
  const params = {
    Image: {
      Bytes: imageBytes
    },
    // Demander tous les attributs faciaux disponibles
    Attributes: ["ALL"]
  };

  try {
    // Exécuter la commande de détection de visages
    const command = new DetectFacesCommand(params);
    const response = await client.send(command);
    
    // Traiter les résultats
    const { FaceDetails } = response;
    
    console.log(`${FaceDetails.length} visage(s) détecté(s):`);
    
    FaceDetails.forEach((face, index) => {
      console.log(`
Visage #${index + 1}:`);
      
      // Données démographiques estimées
      console.log("Attributs démographiques estimés:");
      
      if (face.AgeRange) {
        console.log(`- Âge estimé: ${face.AgeRange.Low}-${face.AgeRange.High} ans`);
      }
      
      if (face.Gender) {
        console.log(`- Genre: ${face.Gender.Value} (confiance: ${face.Gender.Confidence.toFixed(2)}%)`);
      }
      
      // Émotions détectées
      if (face.Emotions && face.Emotions.length > 0) {
        console.log("
Émotions détectées:");
        face.Emotions.sort((a, b) => b.Confidence - a.Confidence).forEach(emotion => {
          console.log(`- ${emotion.Type}: ${emotion.Confidence.toFixed(2)}%`);
        });
      }
      
      // Caractéristiques du visage
      console.log("
Caractéristiques du visage:");
      
      // Présence de lunettes
      if (face.Eyeglasses) {
        console.log(`- Lunettes: ${face.Eyeglasses.Value ? "Oui" : "Non"} (confiance: ${face.Eyeglasses.Confidence.toFixed(2)}%)`);
      }
      
      // Présence de barbe
      if (face.Beard) {
        console.log(`- Barbe: ${face.Beard.Value ? "Oui" : "Non"} (confiance: ${face.Beard.Confidence.toFixed(2)}%)`);
      }
      
      // Yeux ouverts ou fermés
      if (face.EyesOpen) {
        console.log(`- Yeux ouverts: ${face.EyesOpen.Value ? "Oui" : "Non"} (confiance: ${face.EyesOpen.Confidence.toFixed(2)}%)`);
      }
      
      // Sourire
      if (face.Smile) {
        console.log(`- Sourire: ${face.Smile.Value ? "Oui" : "Non"} (confiance: ${face.Smile.Confidence.toFixed(2)}%)`);
      }
      
      // Position du visage (orientation)
      if (face.Pose) {
        console.log("
Orientation du visage:");
        console.log(`- Pitch (inclinaison verticale): ${face.Pose.Pitch.toFixed(2)} degrés`);
        console.log(`- Roll (inclinaison latérale): ${face.Pose.Roll.toFixed(2)} degrés`);
        console.log(`- Yaw (rotation): ${face.Pose.Yaw.toFixed(2)} degrés`);
      }
      
      // Qualité de l'image du visage
      if (face.Quality) {
        console.log("
Qualité de l'image:");
        console.log(`- Netteté: ${face.Quality.Sharpness.toFixed(2)}`);
        console.log(`- Luminosité: ${face.Quality.Brightness.toFixed(2)}`);
      }
    });
    
    return FaceDetails;
    
  } catch (error) {
    console.error("Erreur lors de l'analyse faciale:", error);
    throw error;
  }
}

// Fonction pour comparer deux visages
async function compareFaces(sourceImagePath, targetImagePath, similarityThreshold = 80) {
  // Lire les images
  const sourceImageBytes = readFileSync(sourceImagePath);
  const targetImageBytes = readFileSync(targetImagePath);
  
  // Initialiser le client Rekognition
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  // Configuration de la requête
  const params = {
    SourceImage: {
      Bytes: sourceImageBytes
    },
    TargetImage: {
      Bytes: targetImageBytes
    },
    SimilarityThreshold: similarityThreshold
  };

  try {
    // Exécuter la commande de comparaison de visages
    const command = new CompareFacesCommand(params);
    const response = await client.send(command);
    
    const { FaceMatches, UnmatchedFaces } = response;
    
    console.log("
Résultats de la comparaison de visages:");
    
    if (FaceMatches.length > 0) {
      console.log(`${FaceMatches.length} correspondance(s) trouvée(s):`);
      
      FaceMatches.forEach((match, index) => {
        console.log(`
Correspondance #${index + 1}:`);
        console.log(`- Similarité: ${match.Similarity.toFixed(2)}%`);
        
        // On peut également afficher la position du visage correspondant
        const face = match.Face;
        if (face.BoundingBox) {
          const box = face.BoundingBox;
          console.log(`- Position: x=${box.Left.toFixed(2)}, y=${box.Top.toFixed(2)}, largeur=${box.Width.toFixed(2)}, hauteur=${box.Height.toFixed(2)}`);
        }
      });
    } else {
      console.log("Aucune correspondance trouvée.");
    }
    
    console.log(`${UnmatchedFaces.length} visage(s) non correspondant(s) dans l'image cible.`);
    
    return { FaceMatches, UnmatchedFaces };
    
  } catch (error) {
    console.error("Erreur lors de la comparaison des visages:", error);
    throw error;
  }
}

// Exemple d'utilisation
async function performFacialAnalysis() {
  // Analyser un visage
  await analyzeFace("./profile_photo.jpg");
  
  // Comparer le visage d'une photo d'identité avec une photo de webcam
  await compareFaces("./id_photo.jpg", "./webcam_photo.jpg", 70);
}

performFacialAnalysis();

Analyse vidéo

Rekognition Video permet d'analyser des vidéos stockées dans S3 ou des flux en temps réel pour détecter des objets, suivre des personnes et reconnaître des activités spécifiques. Les résultats peuvent être traités par des fonctions Lambda et Step Functions.

Analyse vidéo avec NodeJs et AWS Rekognition

// Exemple d'analyse vidéo avec AWS Rekognition et Node.js
import { RekognitionClient, StartPersonTrackingCommand, GetPersonTrackingCommand } from "@aws-sdk/client-rekognition";

/**
 * Démarrer une analyse vidéo asynchrone pour détecter des personnes
 */
async function startVideoAnalysis(videoBucket, videoFilename) {
  // Initialiser le client Rekognition
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  console.log(`Lancement de l'analyse vidéo pour ${videoFilename}...`);
  
  // Configuration pour l'analyse vidéo
  const params = {
    Video: {
      S3Object: {
        Bucket: videoBucket,
        Name: videoFilename
      }
    },
    NotificationChannel: {
      SNSTopicArn: 'arn:aws:sns:eu-west-3:ACCOUNT_ID:RekognitionResults',  // Remplacer par votre ARN de SNS
      RoleArn: 'arn:aws:iam::ACCOUNT_ID:role/RekognitionSNSRole'           // Remplacer par votre ARN de rôle IAM
    }
  };
  
  try {
    // Démarrer l'analyse vidéo asynchrone
    const command = new StartPersonTrackingCommand(params);
    const response = await client.send(command);
    
    const jobId = response.JobId;
    console.log(`Job d'analyse démarré avec l'ID: ${jobId}`);
    
    return jobId;
  } catch (error) {
    console.error("Erreur lors du démarrage de l'analyse vidéo:", error);
    throw error;
  }
}

/**
 * Obtenir les résultats d'une analyse vidéo
 */
async function getVideoAnalysisResults(jobId) {
  // Initialiser le client Rekognition
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  // Vérifier l'état du job d'analyse
  console.log("Vérification de l'état du job d'analyse...");
  
  let finished = false;
  let status = '';
  let response;
  
  while (!finished) {
    const command = new GetPersonTrackingCommand({ JobId: jobId });
    response = await client.send(command);
    status = response.JobStatus;
    
    console.log(`Statut actuel: ${status}`);
    
    if (status === 'SUCCEEDED' || status === 'FAILED') {
      finished = true;
    } else {
      console.log("En cours de traitement, nouvelle tentative dans 5 secondes...");
      await new Promise(resolve => setTimeout(resolve, 5000));
    }
  }
  
  if (status === 'SUCCEEDED') {
    console.log("Analyse vidéo terminée avec succès.");
    
    // Récupérer les résultats avec tri par timestamp
    const command = new GetPersonTrackingCommand({
      JobId: jobId,
      SortBy: 'TIMESTAMP'
    });
    
    return await client.send(command);
  } else {
    const errorMessage = response?.StatusMessage || 'Raison inconnue';
    console.error(`L'analyse vidéo a échoué. Raison: ${errorMessage}`);
    return null;
  }
}

/**
 * Analyser les résultats du suivi de personnes dans une vidéo
 */
function analyzePersonTrackingResults(results) {
  if (!results || !results.Persons || results.Persons.length === 0) {
    console.log("Aucun résultat de suivi de personnes disponible.");
    return;
  }
  
  console.log(`
Analyse des résultats pour ${results.Persons.length} détections de personnes...`);
  
  // Organiser les personnes par ID unique
  const persons = {};
  
  for (const detection of results.Persons) {
    const personId = detection.Person?.Index || -1;
    
    if (!persons[personId]) {
      persons[personId] = [];
    }
    
    persons[personId].push({
      timestamp: detection.Timestamp,
      boundingBox: detection.Person?.BoundingBox || {},
      confidence: detection.Person?.Confidence || 0
    });
  }
  
  // Afficher les résultats par personne
  console.log(`
Nombre total de personnes détectées: ${Object.keys(persons).length}`);
  
  for (const [personId, detections] of Object.entries(persons)) {
    console.log(`
Personne #${personId}:`);
    console.log(`- Détectée dans ${detections.length} frames`);
    
    // Calculer la durée d'apparition (en secondes, basée sur les timestamps en millisecondes)
    if (detections.length > 1) {
      const firstAppearance = detections[0].timestamp;
      const lastAppearance = detections[detections.length - 1].timestamp;
      const durationSec = (lastAppearance - firstAppearance) / 1000;
      console.log(`- Durée d'apparition: ${durationSec.toFixed(2)} secondes`);
    }
    
    // Calculer la confiance moyenne
    const avgConfidence = detections.reduce((sum, d) => sum + d.confidence, 0) / detections.length;
    console.log(`- Confiance moyenne: ${avgConfidence.toFixed(2)}%`);
    
    // Visualiser le mouvement (exemple simplifié)
    if (detections.length > 1) {
      const firstPos = detections[0].boundingBox;
      const lastPos = detections[detections.length - 1].boundingBox;
      
      // Calculer le déplacement horizontal et vertical (approximatif)
      const movementX = ((lastPos.Left || 0) - (firstPos.Left || 0)) * 100;
      const movementY = ((lastPos.Top || 0) - (firstPos.Top || 0)) * 100;
      
      const direction = [];
      if (movementX > 5) {
        direction.push("droite");
      } else if (movementX < -5) {
        direction.push("gauche");
      }
      
      if (movementY > 5) {
        direction.push("bas");
      } else if (movementY < -5) {
        direction.push("haut");
      }
      
      if (direction.length > 0) {
        console.log(`- Mouvement général: vers la ${direction.join(' et le ')}`);
      } else {
        console.log(`- Mouvement général: stationnaire`);
      }
    }
  }
  
  return persons;
}

/**
 * Fonction principale pour analyser une vidéo avec Rekognition
 */
async function analyzeVideo() {
  try {
    // Démarrer l'analyse vidéo
    // Note: La vidéo doit être préalablement uploadée dans un bucket S3
    const videoBucket = "my-rekognition-videos";  // Remplacer par votre bucket réel
    const videoFilename = "mall_entrance.mp4";
    
    // Option 1: Utiliser SNS pour la notification asynchrone (configuration complète omise ici)
    const jobId = await startVideoAnalysis(videoBucket, videoFilename);
    
    // Option 2: Interroger périodiquement pour les résultats (pour cette démonstration)
    const results = await getVideoAnalysisResults(jobId);
    
    // Analyser les résultats
    if (results) {
      analyzePersonTrackingResults(results);
      
      // Générer un rapport synthétique
      console.log("
=== RAPPORT D'ANALYSE DE VIDÉO ===");
      console.log(`Vidéo analysée: ${videoFilename}`);
      console.log(`Durée de la vidéo: ${(results.VideoMetadata?.DurationMillis || 0) / 1000} secondes`);
      console.log(`Format: ${results.VideoMetadata?.Format || 'Non spécifié'}`);
      console.log(`Nombre de personnes détectées: ${results.Persons?.length || 0}`);
      
      // Personne entrée/sortie, comptage, etc.
    }
    
    return results;
  } catch (error) {
    console.error(`Erreur lors de l'analyse vidéo: ${error.message}`);
    throw error;
  }
}

// Exécuter l'exemple (dans un environnement Node.js)
// analyzeVideo().catch(console.error);

Modération de contenu

Cette fonctionnalité permet de détecter automatiquement le contenu inapproprié, explicite ou violent dans les images et vidéos, facilitant la mise en place de systèmes de modération avec S3 et DynamoDB pour le stockage des résultats.

Modération de contenu avec AWS Rekognition

// Exemple de modération de contenu avec AWS Rekognition
import { RekognitionClient, DetectModerationLabelsCommand } from "@aws-sdk/client-rekognition";
import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
import { readFileSync, writeFileSync } from "fs";
import { Readable } from "stream";
import { finished } from "stream/promises";

// Fonction pour lire un fichier depuis S3
async function getImageFromS3(bucket, key) {
  const s3Client = new S3Client({ region: "eu-west-3" });
  
  const command = new GetObjectCommand({
    Bucket: bucket,
    Key: key
  });
  
  const response = await s3Client.send(command);
  
  // Convertir le stream en buffer
  const chunks = [];
  const stream = response.Body;
  
  if (stream instanceof Readable) {
    for await (const chunk of stream) {
      chunks.push(chunk);
    }
  }
  
  return Buffer.concat(chunks);
}

// Fonction pour téléverser un fichier vers S3
async function putImageToS3(bucket, key, body, metadata = {}) {
  const s3Client = new S3Client({ region: "eu-west-3" });
  
  const command = new PutObjectCommand({
    Bucket: bucket,
    Key: key,
    Body: body,
    Metadata: metadata
  });
  
  return await s3Client.send(command);
}

// Fonction pour détecter du contenu inapproprié dans une image
async function moderateImage(imageData, minConfidence = 60) {
  const client = new RekognitionClient({ region: "eu-west-3" });
  
  const params = {
    Image: {
      Bytes: imageData
    },
    MinConfidence: minConfidence
  };

  try {
    const command = new DetectModerationLabelsCommand(params);
    const response = await client.send(command);
    
    return response.ModerationLabels || [];
  } catch (error) {
    console.error("Erreur lors de la modération de l'image:", error);
    throw error;
  }
}

// Fonction pour convertir les labels de modération en métadonnées et décision
function analyzeModerationResults(labels) {
  // Définir les catégories de contenu à forte restriction
  const severeCategories = [
    "Explicit Nudity", "Violence", "Visually Disturbing",
    "Hate Symbols", "Drugs & Tobacco", "Alcohol"
  ];
  
  // Définir les catégories à restriction moyenne
  const moderateCategories = [
    "Suggestive", "Female Swimwear Or Underwear", "Male Swimwear Or Underwear",
    "Partial Nudity", "Weapon Violence", "Weapon"
  ];
  
  let flaggedAsSevere = false;
  let flaggedAsModerate = false;
  const detectedLabels = [];
  
  // Analyser les labels détectés
  for (const label of labels) {
    detectedLabels.push({
      name: label.Name,
      confidence: label.Confidence.toFixed(2)
    });
    
    const parentName = label.ParentName || label.Name;
    
    // Vérifier si l'image contient du contenu à forte restriction
    if (severeCategories.some(category => parentName.includes(category))) {
      flaggedAsSevere = true;
    }
    
    // Vérifier si l'image contient du contenu à restriction moyenne
    if (moderateCategories.some(category => parentName.includes(category))) {
      flaggedAsModerate = true;
    }
  }
  
  // Définir le statut final de l'image
  let moderationStatus;
  
  if (flaggedAsSevere) {
    moderationStatus = "REJECTED";
  } else if (flaggedAsModerate) {
    moderationStatus = "NEEDS_REVIEW";
  } else {
    moderationStatus = "APPROVED";
  }
  
  return {
    status: moderationStatus,
    details: detectedLabels
  };
}

// Système de modération de contenu uploadé
async function processUserUpload(sourceBucket, sourceKey) {
  try {
    console.log(`Traitement de l'image: ${sourceKey}`);
    
    // 1. Récupérer l'image depuis S3
    const imageData = await getImageFromS3(sourceBucket, sourceKey);
    
    // 2. Détecter les labels de modération
    console.log("Lancement de la détection de contenu inapproprié...");
    const moderationLabels = await moderateImage(imageData);
    
    // 3. Analyser les résultats
    const moderationResults = analyzeModerationResults(moderationLabels);
    console.log(`Résultat de la modération: ${moderationResults.status}`);
    
    if (moderationLabels.length > 0) {
      console.log("Labels détectés:");
      moderationResults.details.forEach(label => {
        console.log(`- ${label.name} (confiance: ${label.confidence}%)`);
      });
    } else {
      console.log("Aucun contenu inapproprié détecté.");
    }
    
    // 4. Prendre des mesures basées sur les résultats
    let destinationBucket, destinationPrefix;
    
    switch (moderationResults.status) {
      case "APPROVED":
        // Déplacer vers le bucket de contenu approuvé
        destinationBucket = "approved-content";
        destinationPrefix = "images/";
        break;
      case "NEEDS_REVIEW":
        // Déplacer vers le bucket de contenu à réviser
        destinationBucket = "content-review";
        destinationPrefix = "images/";
        break;
      case "REJECTED":
        // Déplacer vers le bucket de contenu rejeté (pour audit)
        destinationBucket = "rejected-content";
        destinationPrefix = "images/";
        break;
    }
    
    // 5. Sauvegarder l'image dans le bucket de destination approprié
    const fileName = sourceKey.split("/").pop();
    const destinationKey = `${destinationPrefix}${fileName}`;
    
    // Ajouter les résultats de modération comme métadonnées
    const metadata = {
      "moderation-status": moderationResults.status,
      "moderation-labels": JSON.stringify(moderationResults.details)
    };
    
    console.log(`Déplacement de l'image vers ${destinationBucket}/${destinationKey}`);
    await putImageToS3(destinationBucket, destinationKey, imageData, metadata);
    
    // 6. Retourner les résultats pour traitement ultérieur
    return {
      sourceImage: { bucket: sourceBucket, key: sourceKey },
      destinationImage: { bucket: destinationBucket, key: destinationKey },
      moderationResults
    };
    
  } catch (error) {
    console.error("Erreur lors du traitement de l'upload:", error);
    throw error;
  }
}

// Fonction pour traiter un lot d'images uploadées
async function processImageBatch() {
  const uploadsToProcess = [
    { bucket: "user-uploads", key: "pending/image1.jpg" },
    { bucket: "user-uploads", key: "pending/image2.jpg" },
    { bucket: "user-uploads", key: "pending/image3.jpg" }
  ];
  
  console.log(`Traitement d'un lot de ${uploadsToProcess.length} images...`);
  
  const results = {
    approved: 0,
    needsReview: 0,
    rejected: 0,
    failed: 0
  };
  
  for (const image of uploadsToProcess) {
    try {
      const result = await processUserUpload(image.bucket, image.key);
      
      // Comptabiliser les résultats
      switch (result.moderationResults.status) {
        case "APPROVED":
          results.approved++;
          break;
        case "NEEDS_REVIEW":
          results.needsReview++;
          break;
        case "REJECTED":
          results.rejected++;
          break;
      }
      
    } catch (error) {
      console.error(`Échec du traitement de l'image ${image.key}:`, error);
      results.failed++;
    }
  }
  
  console.log("
Résumé du traitement par lot:");
  console.log(`- Images approuvées: ${results.approved}`);
  console.log(`- Images nécessitant une révision: ${results.needsReview}`);
  console.log(`- Images rejetées: ${results.rejected}`);
  console.log(`- Échecs de traitement: ${results.failed}`);
}

// Exécuter l'exemple
processImageBatch();

Autres fonctionnalités avancées

Reconnaissance de célébrités - Identification de célébrités connues dans les images et vidéos
Détection et reconnaissance de texte - Extraction de texte à partir d'images, y compris les panneaux, documents et autres contenus textuels
Recherche faciale - Création et recherche dans des collections de visages pour identifier des personnes spécifiques
Segmentation d'image - Identification des pixels qui appartiennent à chaque objet détecté dans une image
Détection d'équipements de protection individuelle - Identification des personnes portant des équipements de sécurité comme des masques, gants ou casques
Collections personnalisées - Possibilité de créer des collections spécifiques à votre cas d'usage pour la reconnaissance d'objets ou de logos

Considérations techniques

Limites de taille - Les images doivent être inférieures à 15 Mo pour les API synchrones et 5 MB pour l'API DetectText
Formats supportés - JPEG et PNG pour les images, et MOV, MP4, AVI pour les vidéos
Modes d'analyse - API synchrones pour des réponses immédiates sur des images individuelles, et API asynchrones pour le traitement par lots ou l'analyse vidéo
Intégration avec S3 - Traitement direct des images et vidéos stockées dans des buckets Amazon S3
Sécurité et conformité - Toutes les données sont chiffrées en transit et au repos, et Rekognition est conforme aux normes HIPAA, SOC, et PCI
Modèle de tarification - Basé sur le nombre d'images analysées ou la durée des vidéos traitées, avec des prix variables selon les fonctionnalités utilisées

Rekognition s'intègre parfaitement avec d'autres services AWS comme Lambda pour le traitement événementiel, Amazon Kinesis pour l'analyse en temps réel, S3 pour le stockage des images et vidéos, et même MediaConvert pour le traitement préalable des vidéos, permettant la création de solutions complètes d'analyse visuelle.

Applications concrètes

Cas d'usage

Sécurité et authentification

Systèmes de contrôle d'accès basés sur la reconnaissance faciale, vérification d'identité pour les services financiers, et détection de fraude par comparaison d'images.

Modération de contenu utilisateur

Filtrage automatique des images et vidéos inappropriées sur les plateformes sociales et les sites de partage de contenu, protégeant les utilisateurs et la réputation de la marque.

Amélioration des médias visuels

Catalogage automatique des bibliothèques d'images, recherche intelligente basée sur le contenu visuel, et organisation des collections de photos personnelles par sujet ou personne.

Commerce et retail

Recherche visuelle de produits, analyse des rayons en magasin pour le suivi des stocks, et recommandations de produits basées sur l'analyse des goûts visuels des clients.

Analyse des médias et publicité

Mesure du temps d'apparition des logos ou produits dans les vidéos, analyse de l'impact des campagnes publicitaires, et génération de métadonnées pour le contenu vidéo.

Automatisation documentaire

Extraction automatique de texte des documents scannés, traitement des formulaires, et digitalisation des archives papier en données structurées exploitables.