Primeros pasos con Video Fingerprinting SDK¶

using VisioForge.Core.VideoFingerPrinting;

// Al inicio de la aplicación
public static void InitializeSDK()
{
    // Para evaluación de prueba - no hacer nada

    // Para licencia comercial
    VFPAnalyzer.SetLicenseKey("YOUR-LICENSE-KEY-HERE");    
}

// Verificar el estado de la licencia
public static bool ValidateLicense()
{
    try
    {
        // Intentar una operación simple para verificar la licencia
        var testSource = new VFPFingerprintSource("test.mp4");
        testSource.StopTime = TimeSpan.FromSeconds(1);

        // Esto fallará si la licencia es inválida
        var fp = VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(testSource).Result;

        return fp != null;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Validación de licencia fallida: {ex.Message}");
        return false;
    }
}

using System;
using System.IO;
using System.Threading.Tasks;
using VisioForge.Core.VideoFingerPrinting;
using VisioForge.Core.Types; // para Size / Rect

namespace VideoFingerprintingDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Inicializar el SDK con su licencia
            VFPAnalyzer.SetLicenseKey("TRIAL");

            // Especificar el archivo de video a procesar
            string videoPath = @"C:\Videos\sample.mp4";

            if (!File.Exists(videoPath))
            {
                Console.WriteLine($"Error: Archivo de video no encontrado en {videoPath}");
                return;
            }

            try
            {
                // Generar la huella digital
                await GenerateFingerprint(videoPath);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }

        static async Task GenerateFingerprint(string videoPath)
        {
            Console.WriteLine($"Procesando: {Path.GetFileName(videoPath)}");
            Console.WriteLine("----------------------------------------");

            // Crear configuración de fuente
            var source = new VFPFingerprintSource(videoPath);

            // Opcional: Procesar solo los primeros 30 segundos para pruebas
            source.StopTime = TimeSpan.FromSeconds(30);

            // Opcional: Reducir resolución para procesamiento más rápido
            source.CustomResolution = new VisioForge.Core.Types.Size(640, 480);

            // Generar huella digital con seguimiento de progreso
            var fingerprint = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
                source,
                errorDelegate: (error) => {
                    Console.WriteLine($"Error: {error}");
                },
                progressDelegate: (progress) => {
                    Console.Write($"\rProgreso: {progress}%");
                }
            );

            Console.WriteLine(); // Nueva línea después del progreso

            if (fingerprint != null)
            {
                // Mostrar información de la huella digital
                Console.WriteLine("\n¡Huella Digital Generada Exitosamente!");
                Console.WriteLine($"  Duración: {fingerprint.Duration}");
                Console.WriteLine($"  Resolución: {fingerprint.Width}x{fingerprint.Height}");
                Console.WriteLine($"  Tasa de Cuadros: {fingerprint.FrameRate:F2} fps");
                Console.WriteLine($"  Tamaño de Datos: {fingerprint.Data?.Length ?? 0} bytes");

                // Guardar huella digital en archivo
                string outputPath = Path.ChangeExtension(videoPath, ".vfp");
                fingerprint.Save(outputPath);

                Console.WriteLine($"\nHuella digital guardada en: {outputPath}");
                Console.WriteLine($"Tamaño del archivo: {new FileInfo(outputPath).Length / 1024} KB");
            }
            else
            {
                Console.WriteLine("Falló al generar la huella digital.");
            }
        }
    }
}

using System;
using System.Threading.Tasks;
using VisioForge.Core.VideoFingerPrinting;
using VisioForge.Core.Types; // para Size / Rect

class VideoComparisonDemo
{
    static async Task Main(string[] args)
    {
        VFPAnalyzer.SetLicenseKey("TRIAL");

        string video1 = @"C:\Videos\original.mp4";
        string video2 = @"C:\Videos\copy.mp4";

        await CompareVideos(video1, video2);
    }

    static async Task CompareVideos(string path1, string path2)
    {
        Console.WriteLine("Comparando videos...");
        Console.WriteLine($"Video 1: {Path.GetFileName(path1)}");
        Console.WriteLine($"Video 2: {Path.GetFileName(path2)}");
        Console.WriteLine("----------------------------------------");

        // Crear fuentes con límites de tiempo para comparación rápida
        var source1 = new VFPFingerprintSource(path1)
        {
            StopTime = TimeSpan.FromSeconds(30),
            CustomResolution = new VisioForge.Core.Types.Size(640, 480)
        };

        var source2 = new VFPFingerprintSource(path2)
        {
            StopTime = TimeSpan.FromSeconds(30),
            CustomResolution = new VisioForge.Core.Types.Size(640, 480)
        };

        // Generar huellas digitales
        Console.Write("Generando huella digital 1...");
        var fp1 = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source1);
        Console.WriteLine(" Hecho");

        Console.Write("Generando huella digital 2...");
        var fp2 = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source2);
        Console.WriteLine(" Hecho");

        if (fp1 != null && fp2 != null)
        {
            // Comparar huellas digitales
            int difference = VFPAnalyzer.Compare(
                fp1, 
                fp2, 
                TimeSpan.FromMilliseconds(500)
            );

            Console.WriteLine($"\nResultados de Comparación:");
            Console.WriteLine($"  Puntaje de Diferencia: {difference}");

            // Interpretar los resultados
            string interpretation = GetInterpretation(difference);
            Console.WriteLine($"  Interpretación: {interpretation}");

            // Proporcionar análisis detallado
            if (difference < 100)
            {
                double similarity = Math.Max(0, 100 - (difference / 3.0));
                Console.WriteLine($"  Similitud: {similarity:F1}%");
            }
        }
        else
        {
            Console.WriteLine("Error: Falló al generar una o ambas huellas digitales");
        }
    }

    static string GetInterpretation(int difference)
    {
        if (difference < 5)
            return "IDÉNTICOS - Mismo video, posiblemente diferente codificación";
        else if (difference < 15)
            return "CASI IDÉNTICOS - Mismo video con diferencias menores de calidad";
        else if (difference < 30)
            return "MUY SIMILARES - Mismo contenido con modificaciones leves";
        else if (difference < 50)
            return "SIMILARES - Mismo contenido con cambios notables (marca de agua, logo, etc.)";
        else if (difference < 100)
            return "RELACIONADOS - Similitudes significativas, probablemente mismo material fuente";
        else if (difference < 300)
            return "ALGO RELACIONADOS - Algunas escenas o contenido común";
        else
            return "DIFERENTES - Videos completamente diferentes";
    }
}

// Solución 1: Usar proceso de 64 bits y aumentar memoria
// Agregar a .csproj:
<PropertyGroup>
  <PlatformTarget>x64</PlatformTarget>
  <LargeAddressAware>true</LargeAddressAware>
</PropertyGroup>

// Solución 2: Reducir resolución de video. VFPFingerprintSource no expone una
// propiedad FrameRate — para reducir los FPS analizados, transcodificar la fuente
// previamente o re-muestrear upstream. Knobs disponibles: CustomResolution,
// CustomCropSize, IgnoredAreas, StartTime / StopTime.
var source = new VFPFingerprintSource(videoPath)
{
    CustomResolution = new VisioForge.Core.Types.Size(320, 240) // Resolución muy baja
};

// Solución 1: Usar procesamiento paralelo para múltiples videos
static async Task ProcessMultipleVideos(string[] videoPaths)
{
    var tasks = videoPaths.Select(path => Task.Run(async () =>
    {
        var source = new VFPFingerprintSource(path)
        {
            CustomResolution = new VisioForge.Core.Types.Size(640, 480)
        };

        return await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source);
    }));

    var fingerprints = await Task.WhenAll(tasks);
}

// Solución 3: Cachear huellas digitales
class FingerprintCache
{
    private static Dictionary<string, VFPFingerPrint> cache = new();

    public static async Task<VFPFingerPrint> GetOrGenerate(string videoPath)
    {
        string cacheKey = GetCacheKey(videoPath);

        if (cache.ContainsKey(cacheKey))
            return cache[cacheKey];

        string cachePath = $"{videoPath}.vfp";

        if (File.Exists(cachePath))
        {
            var fp = VFPFingerPrint.Load(cachePath);
            cache[cacheKey] = fp;
            return fp;
        }

        // Generar nueva huella digital
        var source = new VFPFingerprintSource(videoPath);
        var fingerprint = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source);

        if (fingerprint != null)
        {
            fingerprint.Save(cachePath);
            cache[cacheKey] = fingerprint;
        }

        return fingerprint;
    }

    private static string GetCacheKey(string path)
    {
        var info = new FileInfo(path);
        return $"{path}_{info.Length}_{info.LastWriteTimeUtc.Ticks}";
    }
}

// Solución 1: Ajustar parámetros de comparación
static int CompareWithTolerance(VFPFingerPrint fp1, VFPFingerPrint fp2)
{
    // Probar diferentes desplazamientos de tiempo
    int[] shifts = { 100, 500, 1000, 2000 }; // milisegundos
    int minDifference = int.MaxValue;

    foreach (int shift in shifts)
    {
        int diff = VFPAnalyzer.Compare(fp1, fp2, TimeSpan.FromMilliseconds(shift));
        minDifference = Math.Min(minDifference, diff);
    }

    return minDifference;
}

// Solución 2: Manejar videos con diferentes relaciones de aspecto.
// El constructor de Rect es (left, top, right, bottom) — NO width/height.
var source = new VFPFingerprintSource(videoFilePath);
{
    // Ignorar áreas letterbox/pillarbox (banda 1920x140 arriba + abajo en frame 1920x1080)
    source.IgnoredAreas.AddRange(new[]
    {
        new Rect(0, 0,    1920, 140),    // Letterbox superior: y en [0, 140)
        new Rect(0, 940,  1920, 1080)    // Letterbox inferior: y en [940, 1080)
    });
};

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using VisioForge.Core.VideoFingerPrinting;
using VisioForge.Core.Types; // para Size / Rect

namespace VideoFingerprintingDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Inicializar SDK
            VFPAnalyzer.SetLicenseKey("TRIAL");

            // Configurar rutas
            string videosDir = @"C:\Videos";
            string dbDir = @"C:\FingerprintDB";
            Directory.CreateDirectory(dbDir);

            var app = new FingerprintingApp(videosDir, dbDir);

            while (true)
            {
                Console.WriteLine("\n=== Demo de Huella Digital de Video ===");
                Console.WriteLine("1. Generar huella digital para un video");
                Console.WriteLine("2. Comparar dos videos");
                Console.WriteLine("3. Encontrar fragmento en video");
                Console.WriteLine("4. Construir base de datos de huellas digitales");
                Console.WriteLine("5. Buscar en base de datos videos similares");
                Console.WriteLine("0. Salir");
                Console.Write("\nSelecciona opción: ");

                var choice = Console.ReadLine();
                Console.WriteLine();

                try
                {
                    switch (choice)
                    {
                        case "1":
                            await app.GenerateFingerprint();
                            break;
                        case "2":
                            await app.CompareTwoVideos();
                            break;
                        case "3":
                            await app.FindFragment();
                            break;
                        case "4":
                            await app.BuildDatabase();
                            break;
                        case "5":
                            await app.SearchDatabase();
                            break;
                        case "0":
                            return;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error: {ex.Message}");
                }

                Console.WriteLine("\nPresiona cualquier tecla para continuar...");
                Console.ReadKey();
            }
        }
    }

    class FingerprintingApp
    {
        private string videosDir;
        private string dbDir;
        private Dictionary<string, VFPFingerPrint> database = new Dictionary<string, VFPFingerPrint>();

        public FingerprintingApp(string videosDir, string dbDir)
        {
            this.videosDir = videosDir;
            this.dbDir = dbDir;
            LoadDatabase();
        }

        public async Task GenerateFingerprint()
        {
            Console.Write("Ingresa nombre de archivo de video: ");
            string filename = Console.ReadLine();
            string videoPath = Path.Combine(videosDir, filename);

            if (!File.Exists(videoPath))
            {
                Console.WriteLine("¡Archivo no encontrado!");
                return;
            }

            var source = new VFPFingerprintSource(videoPath);

            Console.Write("¿Procesar video completo? (y/n): ");
            if (Console.ReadLine().ToLower() != "y")
            {
                Console.Write("Ingresa duración en segundos: ");
                if (int.TryParse(Console.ReadLine(), out int seconds))
                {
                    source.StopTime = TimeSpan.FromSeconds(seconds);
                }
            }

            Console.WriteLine("Generando huella digital...");
            var fp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
                source,
                errorDelegate: (msg) => Console.WriteLine($"Error: {msg}"),
                progressDelegate: (p) => Console.Write($"\rProgreso: {p}%")
            );

            if (fp != null)
            {
                string outputPath = Path.ChangeExtension(videoPath, ".vfp");
                fp.Save(outputPath);
                Console.WriteLine($"\n✓ Huella digital guardada en: {outputPath}");
                Console.WriteLine($"  Duración: {fp.Duration}");
                Console.WriteLine($"  Resolución: {fp.Width}x{fp.Height}");
                Console.WriteLine($"  Tasa de Cuadros: {fp.FrameRate:F2} fps");
            }
        }

        public async Task CompareTwoVideos()
        {
            Console.Write("Ingresa nombre de archivo del primer video: ");
            string file1 = Path.Combine(videosDir, Console.ReadLine());

            Console.Write("Ingresa nombre de archivo del segundo video: ");
            string file2 = Path.Combine(videosDir, Console.ReadLine());

            if (!File.Exists(file1) || !File.Exists(file2))
            {
                Console.WriteLine("¡Uno o ambos archivos no encontrados!");
                return;
            }

            Console.WriteLine("Generando huellas digitales...");

            var source1 = new VFPFingerprintSource(file1);
            source1.StopTime = TimeSpan.FromSeconds(30); // Comparación rápida

            var source2 = new VFPFingerprintSource(file2);
            source2.StopTime = TimeSpan.FromSeconds(30);

            var fp1 = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source1);
            var fp2 = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source2);

            if (fp1 != null && fp2 != null)
            {
                int difference = VFPAnalyzer.Compare(fp1, fp2, TimeSpan.FromMilliseconds(500));

                Console.WriteLine($"\nPuntaje de Diferencia: {difference}");

                if (difference < 5)
                    Console.WriteLine("✓ Videos son IDÉNTICOS");
                else if (difference < 30)
                    Console.WriteLine("✓ Videos son MUY SIMILARES");
                else if (difference < 100)
                    Console.WriteLine("✓ Videos son SIMILARES");
                else if (difference < 300)
                    Console.WriteLine("⚠ Videos tienen ALGUNAS SIMILITUDES");
                else
                    Console.WriteLine("✗ Videos son DIFERENTES");
            }
        }

        public async Task FindFragment()
        {
            Console.Write("Ingresa nombre de archivo de video de fragmento: ");
            string fragmentFile = Path.Combine(videosDir, Console.ReadLine());

            Console.Write("Ingresa nombre de archivo de video completo: ");
            string fullFile = Path.Combine(videosDir, Console.ReadLine());

            if (!File.Exists(fragmentFile) || !File.Exists(fullFile))
            {
                Console.WriteLine("¡Uno o ambos archivos no encontrados!");
                return;
            }

            Console.WriteLine("Procesando fragmento...");
            var fragmentFp = await VFPAnalyzer.GetSearchFingerprintForVideoFileAsync(
                new VFPFingerprintSource(fragmentFile),
                progressDelegate: (p) => Console.Write($"\rFragmento: {p}%")
            );

            Console.WriteLine("\nProcesando video completo...");
            var fullFp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
                new VFPFingerprintSource(fullFile),
                progressDelegate: (p) => Console.Write($"\rVideo completo: {p}%")
            );

            if (fragmentFp != null && fullFp != null)
            {
                Console.WriteLine("\n\nBuscando...");
                var positions = await VFPAnalyzer.SearchAsync(
                    fragmentFp, fullFp, fragmentFp.Duration, 50, true
                );

                if (positions.Count > 0)
                {
                    Console.WriteLine($"✓ Encontradas {positions.Count} ocurrencia(s):");
                    foreach (var pos in positions)
                    {
                        Console.WriteLine($"  - En {pos:hh\\:mm\\:ss}");
                    }
                }
                else
                {
                    Console.WriteLine("✗ Fragmento no encontrado");
                }
            }
        }

        public async Task BuildDatabase()
        {
            var videoFiles = Directory.GetFiles(videosDir, "*.mp4")
                .Concat(Directory.GetFiles(videosDir, "*.avi"))
                .Concat(Directory.GetFiles(videosDir, "*.mkv"))
                .ToList();

            Console.WriteLine($"Encontrados {videoFiles.Count} archivos de video");

            int processed = 0;
            foreach (var videoFile in videoFiles)
            {
                string id = Path.GetFileNameWithoutExtension(videoFile);
                string fpPath = Path.Combine(dbDir, $"{id}.vfp");

                if (File.Exists(fpPath))
                {
                    Console.WriteLine($"Saltando {id} (ya existe)");
                    continue;
                }

                Console.WriteLine($"Procesando {id}...");

                var source = new VFPFingerprintSource(videoFile);
                source.StopTime = TimeSpan.FromSeconds(60); // Solo primer minuto

                var fp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
                    source,
                    progressDelegate: (p) => Console.Write($"\r  Progreso: {p}%")
                );

                if (fp != null)
                {
                    fp.ID = Guid.NewGuid();
                    fp.OriginalFilename = Path.GetFileName(videoFile);
                    fp.Save(fpPath);
                    processed++;
                    Console.WriteLine($"\r  ✓ Huella digital guardada para {id}");
                }
            }

            Console.WriteLine($"\n✓ Procesados {processed} videos");
            LoadDatabase();
        }

        public async Task SearchDatabase()
        {
            Console.Write("Ingresa nombre de archivo de video de consulta: ");
            string queryFile = Path.Combine(videosDir, Console.ReadLine());

            if (!File.Exists(queryFile))
            {
                Console.WriteLine("¡Archivo no encontrado!");
                return;
            }

            Console.Write("Ingresa umbral de similitud (predeterminado 30): ");
            if (!int.TryParse(Console.ReadLine(), out int threshold))
                threshold = 30;

            Console.WriteLine("Generando huella digital de consulta...");
            var queryFp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
                new VFPFingerprintSource(queryFile) { StopTime = TimeSpan.FromSeconds(60) }
            );

            if (queryFp == null) return;

            Console.WriteLine($"Buscando {database.Count} huellas digitales...");

            var matches = new List<(string id, int score)>();

            foreach (var entry in database)
            {
                int score = VFPAnalyzer.Compare(queryFp, entry.Value, TimeSpan.FromMilliseconds(500));
                if (score < threshold)
                {
                    matches.Add((entry.Key, score));
                }
            }

            if (matches.Count > 0)
            {
                Console.WriteLine($"\n✓ Encontrados {matches.Count} video(s) similar(es):");
                foreach (var match in matches.OrderBy(m => m.score))
                {
                    var fp = database[match.id];
                    Console.WriteLine($"  - {fp.OriginalFilename} (puntaje: {match.score})");
                }
            }
            else
            {
                Console.WriteLine("\n✗ No se encontraron videos similares");
            }
        }

        private void LoadDatabase()
        {
            database.Clear();

            if (!Directory.Exists(dbDir))
                return;

            var files = Directory.GetFiles(dbDir, "*.vfp");
            foreach (var file in files)
            {
                try
                {
                    var fp = VFPFingerPrint.Load(file);
                    string id = Path.GetFileNameWithoutExtension(file);
                    database[id] = fp;
                }
                catch { }
            }

            Console.WriteLine($"Cargadas {database.Count} huellas digitales de la base de datos");
        }
    }
}