Implementación de Detección de Rostros en Aplicaciones de Video .NET¶

VideoCapture1.Face_Tracking = new FaceTrackingSettings
{
    // Color mode determines how colors are processed for detection
    ColorMode = CamshiftMode.RGB,

    // Highlight detected faces in the preview
    Highlight = true,

    // Minimum size (in pixels) of face to detect
    MinimumWindowSize = 25,

    // Scanning approach - how the algorithm scales through the image
    ScalingMode = ObjectDetectorScalingMode.GreaterToSmaller,

    // Single or multiple face detection
    SearchMode = ObjectDetectorSearchMode.Single,

    // Factor de escala para recorrer la pirámide (1.0 < factor <= 2.0)
    ScaleFactor = 1.2f
};

// OnFaceDetected es un EventHandler<AFFaceDetectionEventArgs> estándar.
// e.FaceRectangles es un Rectangle[] — use .Length, no .Count.
private void OnFaceDetectedHandler(object sender, AFFaceDetectionEventArgs e)
{
    // Limpiar texto previo
    edFaceTrackingFaces.Text = string.Empty;

    // Procesar cada rostro detectado
    foreach (var faceRectangle in e.FaceRectangles)
    {
        // Mostrar coordenadas y dimensiones del rostro
        edFaceTrackingFaces.Text +=
            $"Position: ({faceRectangle.Left}, {faceRectangle.Top}), " +
            $"Size: ({faceRectangle.Width}, {faceRectangle.Height}){Environment.NewLine}";

        // También puede calcular el punto central
        int centerX = faceRectangle.Left + (faceRectangle.Width / 2);
        int centerY = faceRectangle.Top + (faceRectangle.Height / 2);
        edFaceTrackingFaces.Text += $"Center: ({centerX}, {centerY}){Environment.NewLine}";

        // Opcional: añadir marca de tiempo para seguimiento
        edFaceTrackingFaces.Text += $"Time: {DateTime.Now:HH:mm:ss.fff}{Environment.NewLine}{Environment.NewLine}";
    }

    // Actualizar conteo de rostros (Rectangle[] — Length, no Count)
    lblFaceCount.Text = $"Faces detected: {e.FaceRectangles.Length}";
}

// Registrar el manejador de eventos
VideoCapture1.OnFaceDetected += OnFaceDetectedHandler;

// Custom visualization - draw face rectangles on an overlay
private void DrawFacesOnOverlay(Rectangle[] faceRectangles, PictureBox overlay)
{
    // Create bitmap for overlay
    Bitmap overlayBitmap = new Bitmap(overlay.Width, overlay.Height);

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

        // Draw each face
        foreach (var face in faceRectangles)
        {
            // Draw rectangle
            g.DrawRectangle(new Pen(Color.GreenYellow, 2), face);

            // Optional: Draw crosshair at center
            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);
        }
    }

    // Update overlay
    overlay.Image = overlayBitmap;
}

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

private void TrackFaces(List<Rectangle> currentFaces)
{
    // Match current faces with previously tracked faces
    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]))
            {
                // Update existing tracked face
                trackedFace.UpdateLocation(unmatchedFaces[i]);
                matchedIds.Add(trackedFace.Id);
                unmatchedFaces.RemoveAt(i);
                foundMatch = true;
                break;
            }
        }

        // Remove faces that disappeared
        if (!foundMatch)
        {
            trackedFaces.Remove(trackedFace.Id);
        }
    }

    // Add new faces
    foreach (var newFace in unmatchedFaces)
    {
        trackedFaces.Add(nextFaceId, new TrackedFace(nextFaceId, newFace));
        nextFaceId++;
    }
}

private bool IsLikelyMatch(Rectangle previous, Rectangle current)
{
    // Calculate center points
    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);

    // Calculate distance between centers
    double distance = Math.Sqrt(
        Math.Pow(prevCenter.X - currCenter.X, 2) + 
        Math.Pow(prevCenter.Y - currCenter.Y, 2));

    // If centers are close enough, consider it the same face
    return distance < Math.Max(previous.Width, current.Width) * 0.5;
}

// Simple class to track face data
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;
    }
}

// Start video capture asynchronously
await VideoCapture1.StartAsync();

// Stop video capture
await VideoCapture1.StopAsync();