Intégration de caméras USB3 Vision, GigE et GenICam¶

using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.Threading.Tasks;

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

// Découvrir les caméras GenICam disponibles
GenICamCameraManager.UpdateDeviceList();
var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();

Console.WriteLine($"Found {devices.Length} GenICam devices");

foreach (var device in devices)
{
    Console.WriteLine($"Camera: {device.CameraName}");
    Console.WriteLine($"Device ID: {device.DeviceId}");
    Console.WriteLine($"Address: {device.Address}");
    Console.WriteLine();
}

// Obtenir des informations détaillées sur une caméra spécifique
if (devices.Length > 0)
{
    var cameraDeviceId = devices[0].DeviceId;
    var camera = GenICamCameraManager.GetCamera(cameraDeviceId);

    if (camera != null && GenICamCameraManager.OpenCamera(cameraDeviceId))
    {
        camera.ReadInfo();

        Console.WriteLine($"Connected to: {camera.VendorName} {camera.ModelName}");
        Console.WriteLine($"Serial Number: {camera.SerialNumber}");
        Console.WriteLine($"Protocol: {camera.Protocol}");
        Console.WriteLine($"Sensor Size: {camera.SensorSize.Width}x{camera.SensorSize.Height}");
        Console.WriteLine($"Available Pixel Formats: {string.Join(", ", camera.AvailablePixelFormats)}");

        GenICamCameraManager.CloseCamera(cameraDeviceId);
    }
}

using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.Threading.Tasks;

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

// Créer une instance VideoCaptureCoreX (en supposant que vous disposez d'un contrôle de vue vidéo)
var videoCapture = new VideoCaptureCoreX(videoView: yourVideoViewControl);

try
{
    // Découvrir les caméras
    var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();
    if (devices.Length == 0)
    {
        Console.WriteLine("No GenICam cameras found!");
        return;
    }

    var selectedDevice = devices[0]; // Utiliser la première caméra
    Console.WriteLine($"Using camera: {selectedDevice.CameraName}");

    // Configurer la caméra avant de démarrer la capture
    var camera = GenICamCameraManager.GetCamera(selectedDevice.DeviceId);
    if (camera != null && GenICamCameraManager.OpenCamera(selectedDevice.DeviceId))
    {
        camera.ReadInfo();

        // Configurer les paramètres de la caméra
        if (camera.ExposureTimeAvailable)
        {
            camera.SetExposureTime(10000); // Exposition de 10 ms
        }

        if (camera.GainAvailable)
        {
            camera.SetGain(0.0); // Gain minimum
        }

        // Obtenir la résolution et la fréquence d'images de la caméra
        var sensorSize = camera.GetSensorSize();
        var frameRate = camera.GetFrameRate();

        // Créer la source GenICam
        var sourceSettings = new GenICamSourceSettings(
            selectedDevice.DeviceId,
            new VisioForge.Core.Types.Rect(0, 0, sensorSize.Width, sensorSize.Height),
            frameRate,
            GenICamPixelFormat.Default
        );

        videoCapture.Video_Source = sourceSettings;

        // Démarrer l'aperçu
        await videoCapture.StartAsync();

        Console.WriteLine("Live preview started. Press any key to stop...");
        Console.ReadKey();

        await videoCapture.StopAsync();
        GenICamCameraManager.CloseCamera(selectedDevice.DeviceId);
    }
}
finally
{
    await videoCapture.DisposeAsync();
}

using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.IO;
using System.Threading.Tasks;

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

// Créer une instance VideoCaptureCoreX
var videoCapture = new VideoCaptureCoreX(videoView: yourVideoViewControl);

try
{
    // Configurer le mode débogage
    videoCapture.Debug_Mode = true;
    videoCapture.Debug_Dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "VisioForge");

    // Découvrir et sélectionner la caméra
    var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();
    if (devices.Length == 0)
    {
        Console.WriteLine("No GenICam cameras found!");
        return;
    }

    var selectedDevice = devices[0];
    Console.WriteLine($"Recording from camera: {selectedDevice.CameraName}");

    // Configurer les paramètres de la caméra
    var camera = GenICamCameraManager.GetCamera(selectedDevice.DeviceId);
    if (camera != null && GenICamCameraManager.OpenCamera(selectedDevice.DeviceId))
    {
        camera.ReadInfo();

        // Définir les paramètres de la caméra
        if (camera.ExposureTimeAvailable)
        {
            camera.SetExposureTime(5000); // Exposition de 5 ms
        }

        if (camera.FrameRateAvailable)
        {
            var targetFps = Math.Min(30.0, camera.FrameRateBounds.Max);
            camera.SetFrameRate(new VideoFrameRate(targetFps));
        }

        // Obtenir la résolution et la fréquence d'images de la caméra
        var sensorSize = camera.GetSensorSize();
        var frameRate = camera.GetFrameRate();

        // Créer la source GenICam
        var sourceSettings = new GenICamSourceSettings(
            selectedDevice.DeviceId,
            new VisioForge.Core.Types.Rect(0, 0, sensorSize.Width, sensorSize.Height),
            frameRate,
            GenICamPixelFormat.Default
        );

        videoCapture.Video_Source = sourceSettings;

        // Configurer la sortie MP4
        string outputFilename = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "genicam_capture.mp4");
        var mp4Output = new MP4Output(outputFilename, H264EncoderBlock.GetDefaultSettings(), null);
        videoCapture.Outputs_Add(mp4Output);

        // Démarrer l'enregistrement
        await videoCapture.StartAsync();

        Console.WriteLine($"Recording started to: {outputFilename}");
        Console.WriteLine("Press any key to stop recording...");
        Console.ReadKey();

        // Arrêter l'enregistrement
        await videoCapture.StopAsync();
        Console.WriteLine($"Recording saved to: {outputFilename}");

        GenICamCameraManager.CloseCamera(selectedDevice.DeviceId);
    }
}
finally
{
    await videoCapture.DisposeAsync();
}

using VisioForge.Core.GenICam;
using VisioForge.Core.Types;
using System;
using System.Linq;
using System.Threading;

// Découvrir et se connecter à la caméra
var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();
if (devices.Length == 0) return;

var camera = GenICamCameraManager.GetCamera(devices[0].DeviceId);

if (camera != null && GenICamCameraManager.OpenCamera(devices[0].DeviceId))
{
    camera.ReadInfo();

    // Afficher les capacités de la caméra
    Console.WriteLine($"Camera: {camera}");
    Console.WriteLine($"Available pixel formats: {string.Join(", ", camera.AvailablePixelFormats)}");

    // Configurer le format de pixel
    if (camera.AvailablePixelFormats.Contains("Mono8"))
    {
        camera.SetPixelFormat("Mono8");
        Console.WriteLine("Set pixel format to Mono8");
    }

    // Configurer l'exposition avec le mode auto
    if (camera.IsExposureAutoAvailable)
    {
        // Essayer d'abord l'exposition automatique
        camera.SetExposureAuto(GenICamAuto.Once);
        Thread.Sleep(1000); // Attendre la fin de l'exposition automatique

        // Puis passer en manuel et lire la valeur auto-calculée
        camera.SetExposureAuto(GenICamAuto.Off);
        var autoExposure = camera.GetExposureTime();
        Console.WriteLine($"Auto exposure calculated: {autoExposure:F2} μs");

        // Affiner manuellement si nécessaire
        camera.SetExposureTime(autoExposure * 1.2); // Exposition 20 % plus longue
    }

    // Configurer le gain
    if (camera.IsGainAutoAvailable)
    {
        camera.SetGainAuto(GenICamAuto.Continuous);
        Console.WriteLine("Enabled continuous auto gain");
    }

    // Configurer le binning pour des fréquences d'images plus élevées
    if (camera.BinningAvailable)
    {
        camera.SetBinning(2, 2); // Binning 2x2
        Console.WriteLine("Set 2x2 binning for higher sensitivity and frame rate");
    }

    // Configurer le déclenchement logiciel
    if (camera.SoftwareTriggerSupported)
    {
        camera.SetStringFeature("TriggerMode", "On");
        camera.SetStringFeature("TriggerSource", "Software");
        camera.SetAcquisitionMode(GenICamAcquisitionMode.Continuous);

        Console.WriteLine("Configured for software triggering");

        // Remarque : avec VideoCaptureCoreX, le déclenchement logiciel serait
        // intégré au pipeline de capture plutôt qu'appelé directement
    }

    // Lire et afficher les fonctionnalités avancées
    camera.ReadAvailableFeatures();
    Console.WriteLine($"Camera has {camera.AvailableStringFeatures.Length + camera.AvailableIntegerFeatures.Length + camera.AvailableFloatFeatures.Length + camera.AvailableBooleanFeatures.Length} features");
    Console.WriteLine($"Advanced features available: {camera.HasAdvancedFeatures}");

    GenICamCameraManager.CloseCamera(devices[0].DeviceId);
}

using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.IO;
using System.Threading.Tasks;

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

// Créer le pipeline Media Blocks
var pipeline = new MediaBlocksPipeline();

try
{
    // Configurer le mode débogage
    pipeline.Debug_Mode = true;
    pipeline.Debug_Dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "VisioForge");

    // Découvrir les caméras
    var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();
    if (devices.Length == 0)
    {
        Console.WriteLine("No GenICam cameras found!");
        return;
    }

    var selectedDevice = devices[0];
    string cameraDeviceId = selectedDevice.DeviceId;

    // Configurer la caméra
    if (GenICamCameraManager.OpenCamera(cameraDeviceId))
    {
        var camera = GenICamCameraManager.GetCamera(cameraDeviceId);
        camera?.ReadInfo();

        // Créer le bloc source GenICam
        var sourceSettings = new GenICamSourceSettings(cameraDeviceId);
        var sourceBlock = new GenICamSourceBlock(sourceSettings);

        // Créer le moteur de rendu vidéo pour l'aperçu
        var videoRenderer = new VideoRendererBlock(pipeline, yourVideoViewControl) { IsSync = false };

        // Créer un bloc tee pour séparer le flux
        var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);

        // Créer le bloc de sortie MP4
        string outputFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "genicam_capture.mp4");
        var mp4Output = new MP4OutputBlock(new MP4SinkSettings(outputFile), H264EncoderBlock.GetDefaultSettings(), aacSettings: null);

        // Connecter le pipeline
        pipeline.Connect(sourceBlock.Output, videoTee.Input);
        pipeline.Connect(videoTee.Outputs[0], videoRenderer.Input);

        var videoInput = mp4Output.CreateNewInput(MediaBlockPadMediaType.Video);
        pipeline.Connect(videoTee.Outputs[1], videoInput);

        // Démarrer le pipeline
        await pipeline.StartAsync();

        Console.WriteLine($"Recording to: {outputFile}");
        Console.WriteLine("Press any key to stop...");
        Console.ReadKey();

        // Arrêter le pipeline
        await pipeline.StopAsync();
        Console.WriteLine($"Recording saved to: {outputFile}");

        // Nettoyage
        mp4Output.Dispose();
        GenICamCameraManager.CloseCamera(cameraDeviceId);
    }
}
finally
{
    await pipeline.DisposeAsync();
}

using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.Threading;
using System.Threading.Tasks;

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

string cameraDeviceId = null;
VideoCaptureCoreX videoCapture = null;

try
{
    // Découvrir les caméras avec logique de retry
    int maxDiscoveryRetries = 3;
    var devices = Array.Empty<GenICamCamera>();

    for (int attempt = 1; attempt <= maxDiscoveryRetries; attempt++)
    {
        try
        {
            GenICamCameraManager.UpdateDeviceList();
            devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();

            if (devices.Length > 0)
            {
                Console.WriteLine($"Found {devices.Length} cameras on attempt {attempt}");
                break;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Discovery attempt {attempt} failed: {ex.Message}");
            if (attempt < maxDiscoveryRetries)
            {
                Thread.Sleep(2000); // Attendre avant de réessayer
            }
        }
    }

    if (devices.Length == 0)
    {
        Console.WriteLine("No cameras found after all attempts");
        return;
    }

    cameraDeviceId = devices[0].DeviceId;

    // Connexion à la caméra avec logique de retry
    int maxRetries = 3;
    bool connected = false;

    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            connected = GenICamCameraManager.OpenCamera(cameraDeviceId);
            if (connected)
            {
                Console.WriteLine($"Connected to camera on attempt {attempt}");
                break;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Connection attempt {attempt} failed: {ex.Message}");
            if (attempt < maxRetries)
            {
                Thread.Sleep(2000); // Attendre avant de réessayer
            }
        }
    }

    if (!connected)
    {
        Console.WriteLine("Failed to connect after all attempts");
        return;
    }

    // Configurer la caméra
    var camera = GenICamCameraManager.GetCamera(cameraDeviceId);
    camera?.ReadInfo();

    // Créer VideoCaptureCoreX avec gestion d'erreurs
    videoCapture = new VideoCaptureCoreX(videoView: yourVideoViewControl);

    // Configurer le gestionnaire d'événements d'erreur
    videoCapture.OnError += (sender, e) =>
    {
        Console.WriteLine($"Capture error: {e.Message}");
    };

    // Configurer la source
    var sourceSettings = new GenICamSourceSettings(
        cameraDeviceId,
        new VisioForge.Core.Types.Rect(0, 0, camera.SensorSize.Width, camera.SensorSize.Height),
        camera.GetFrameRate(),
        GenICamPixelFormat.Default
    );

    videoCapture.Video_Source = sourceSettings;

    // Démarrer la capture avec surveillance
    await videoCapture.StartAsync();

    Console.WriteLine("Capture started. Monitoring for errors...");

    // Surveiller pendant 30 secondes
    var startTime = DateTime.Now;
    while ((DateTime.Now - startTime).TotalSeconds < 30)
    {
        Thread.Sleep(1000);

        // Vérifier l'état de la capture
        if (videoCapture.State != VisioForge.Core.Types.PlaybackState.Play)
        {
            Console.WriteLine("Capture stopped unexpectedly. Attempting restart...");

            try
            {
                await videoCapture.StopAsync();
                await Task.Delay(1000);
                await videoCapture.StartAsync();
                Console.WriteLine("Capture restarted successfully");
            }
            catch (Exception restartEx)
            {
                Console.WriteLine($"Failed to restart capture: {restartEx.Message}");
                break;
            }
        }
    }

    await videoCapture.StopAsync();
    Console.WriteLine("Capture monitoring completed");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}
finally
{
    // Nettoyer
    if (videoCapture != null)
    {
        await videoCapture.DisposeAsync();
    }

    if (!string.IsNullOrEmpty(cameraDeviceId))
    {
        GenICamCameraManager.CloseCamera(cameraDeviceId);
    }

    Console.WriteLine("Resources cleaned up");
}

using VisioForge.Core.VideoCaptureX;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.GenICam;
using VisioForge.Core;
using System;
using System.Threading.Tasks;

// Pour les caméras GenTL, assurez-vous que la variable d'environnement est définie
// GENICAM_GENTL64_PATH doit pointer vers la bibliothèque du producteur GenTL

// Exemple : définir au démarrage de l'application ou dans l'environnement
Environment.SetEnvironmentVariable("GENICAM_GENTL64_PATH", @"C:\Program Files\Basler\pylon 7\Runtime\x64");

// Initialiser le SDK
await VisioForgeX.InitSDKAsync();

// Découvrir les caméras GenTL (elles apparaîtront aux côtés des autres périphériques GenICam)
GenICamCameraManager.UpdateDeviceList();
var devices = await DeviceEnumerator.Shared.GenICamSourcesAsync();

foreach (var device in devices)
{
    // Vérifier les informations de la caméra
    var camera = GenICamCameraManager.GetCamera(device.DeviceId);
    if (camera != null && GenICamCameraManager.OpenCamera(device.DeviceId))
    {
        camera.ReadInfo();

        // Vérifier s'il s'agit d'un périphérique GenTL
        if (camera.Protocol == "GenTL")
        {
            Console.WriteLine($"Found GenTL camera: {camera}");

            try
            {
                // Configurer les fonctionnalités spécifiques à GenTL pour des performances maximales
                if (camera.IsFeatureAvailable("StreamBufferCountMode"))
                {
                    camera.SetStringFeature("StreamBufferCountMode", "Manual");
                }

                if (camera.IsFeatureAvailable("StreamBufferCountManual"))
                {
                    camera.SetIntegerFeature("StreamBufferCountManual", 20); // Plus de tampons
                }

                // Définir les paramètres d'acquisition
                if (camera.ExposureTimeAvailable)
                {
                    camera.SetExposureTime(1000); // Exposition de 1 ms
                }

                // Utiliser avec VideoCaptureCoreX
                var videoCapture = new VideoCaptureCoreX(videoView: yourVideoViewControl);

                try
                {
                    var sourceSettings = new GenICamSourceSettings(
                        device.DeviceId,
                        new VisioForge.Core.Types.Rect(0, 0, camera.SensorSize.Width, camera.SensorSize.Height),
                        camera.GetFrameRate(),
                        GenICamPixelFormat.Default
                    );

                    videoCapture.Video_Source = sourceSettings;

                    // Démarrer l'aperçu
                    await videoCapture.StartAsync();
                    Console.WriteLine($"GenTL camera preview started: {camera.SensorSize.Width}x{camera.SensorSize.Height}");

                    // Laisser tourner quelques secondes
                    await Task.Delay(3000);

                    await videoCapture.StopAsync();
                    Console.WriteLine("GenTL camera preview stopped");
                }
                finally
                {
                    await videoCapture.DisposeAsync();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error using GenTL camera: {ex.Message}");
            }
        }

        GenICamCameraManager.CloseCamera(device.DeviceId);
    }
}