Implémenter la détection de visages dans les applications vidéo .NET¶

VideoCapture1.Face_Tracking = new FaceTrackingSettings
{
    // Le mode couleur détermine comment les couleurs sont traitées pour la détection
    ColorMode = CamshiftMode.RGB,

    // Mettre en évidence les visages détectés dans l'aperçu
    Highlight = true,

    // Taille minimale (en pixels) du visage à détecter
    MinimumWindowSize = 25,

    // Approche de balayage — comment l'algorithme parcourt les échelles de l'image
    ScalingMode = ObjectDetectorScalingMode.GreaterToSmaller,

    // Détection unique ou multiple de visages
    SearchMode = ObjectDetectorSearchMode.Single,

    // Facteur d'échelle utilisé pour parcourir la pyramide (1.0 < facteur <= 2.0)
    ScaleFactor = 1.2f
};

// OnFaceDetected est un EventHandler<AFFaceDetectionEventArgs> standard.
// e.FaceRectangles est un Rectangle[] — utilisez .Length, pas .Count.
private void OnFaceDetectedHandler(object sender, AFFaceDetectionEventArgs e)
{
    // Effacer le texte précédent
    edFaceTrackingFaces.Text = string.Empty;

    // Traiter chaque visage détecté
    foreach (var faceRectangle in e.FaceRectangles)
    {
        // Afficher les coordonnées et dimensions du visage
        edFaceTrackingFaces.Text +=
            $"Position: ({faceRectangle.Left}, {faceRectangle.Top}), " +
            $"Size: ({faceRectangle.Width}, {faceRectangle.Height}){Environment.NewLine}";

        // Vous pouvez aussi calculer le point central
        int centerX = faceRectangle.Left + (faceRectangle.Width / 2);
        int centerY = faceRectangle.Top + (faceRectangle.Height / 2);
        edFaceTrackingFaces.Text += $"Center: ({centerX}, {centerY}){Environment.NewLine}";

        // Optionnel : ajouter un horodatage pour le suivi
        edFaceTrackingFaces.Text += $"Time: {DateTime.Now:HH:mm:ss.fff}{Environment.NewLine}{Environment.NewLine}";
    }

    // Mettre à jour le nombre de visages (Rectangle[] — Length, pas Count)
    lblFaceCount.Text = $"Faces detected: {e.FaceRectangles.Length}";
}

// Enregistrer le gestionnaire d'événements
VideoCapture1.OnFaceDetected += OnFaceDetectedHandler;

// Visualisation personnalisée — dessiner des rectangles de visage sur une superposition
private void DrawFacesOnOverlay(Rectangle[] faceRectangles, PictureBox overlay)
{
    // Créer un bitmap pour la superposition
    Bitmap overlayBitmap = new Bitmap(overlay.Width, overlay.Height);

    using (Graphics g = Graphics.FromImage(overlayBitmap))
    {
        g.Clear(Color.Transparent);

        // Dessiner chaque visage
        foreach (var face in faceRectangles)
        {
            // Dessiner le rectangle
            g.DrawRectangle(new Pen(Color.GreenYellow, 2), face);

            // Optionnel : dessiner un viseur au centre
            int centerX = face.Left + (face.Width / 2);
            int centerY = face.Top + (face.Height / 2);
            g.DrawLine(new Pen(Color.Red, 1), centerX - 10, centerY, centerX + 10, centerY);
            g.DrawLine(new Pen(Color.Red, 1), centerX, centerY - 10, centerX, centerY + 10);
        }
    }

    // Mettre à jour la superposition
    overlay.Image = overlayBitmap;
}

private Dictionary<int, TrackedFace> trackedFaces = new Dictionary<int, TrackedFace>();
private int nextFaceId = 1;

private void TrackFaces(List<Rectangle> currentFaces)
{
    // Faire correspondre les visages actuels avec les visages précédemment suivis
    List<int> matchedIds = new List<int>();
    List<Rectangle> unmatchedFaces = new List<Rectangle>(currentFaces);

    foreach (var trackedFace in trackedFaces.Values.ToList())
    {
        bool foundMatch = false;

        for (int i = unmatchedFaces.Count - 1; i >= 0; i--)
        {
            if (IsLikelyMatch(trackedFace.LastLocation, unmatchedFaces[i]))
            {
                // Mettre à jour le visage suivi existant
                trackedFace.UpdateLocation(unmatchedFaces[i]);
                matchedIds.Add(trackedFace.Id);
                unmatchedFaces.RemoveAt(i);
                foundMatch = true;
                break;
            }
        }

        // Supprimer les visages qui ont disparu
        if (!foundMatch)
        {
            trackedFaces.Remove(trackedFace.Id);
        }
    }

    // Ajouter les nouveaux visages
    foreach (var newFace in unmatchedFaces)
    {
        trackedFaces.Add(nextFaceId, new TrackedFace(nextFaceId, newFace));
        nextFaceId++;
    }
}

private bool IsLikelyMatch(Rectangle previous, Rectangle current)
{
    // Calculer les points centraux
    Point prevCenter = new Point(
        previous.Left + previous.Width / 2,
        previous.Top + previous.Height / 2);

    Point currCenter = new Point(
        current.Left + current.Width / 2,
        current.Top + current.Height / 2);

    // Calculer la distance entre les centres
    double distance = Math.Sqrt(
        Math.Pow(prevCenter.X - currCenter.X, 2) + 
        Math.Pow(prevCenter.Y - currCenter.Y, 2));

    // Si les centres sont suffisamment proches, considérer qu'il s'agit du même visage
    return distance < Math.Max(previous.Width, current.Width) * 0.5;
}

// Classe simple pour suivre les données de visage
private class TrackedFace
{
    public int Id { get; private set; }
    public Rectangle LastLocation { get; private set; }
    public DateTime FirstSeen { get; private set; }
    public DateTime LastSeen { get; private set; }

    public TrackedFace(int id, Rectangle location)
    {
        Id = id;
        LastLocation = location;
        FirstSeen = DateTime.Now;
        LastSeen = DateTime.Now;
    }

    public void UpdateLocation(Rectangle newLocation)
    {
        LastLocation = newLocation;
        LastSeen = DateTime.Now;
    }
}

// Démarrer la capture vidéo de manière asynchrone
await VideoCapture1.StartAsync();

// Arrêter la capture vidéo
await VideoCapture1.StopAsync();