Numériser depuis votre application

Cette rubrique explique comment numériser du contenu à partir de votre application à l’aide d’un scanner à plat, d’un chargeur ou d’une source de numérisation configurée automatiquement.

Obtenir un appareil de scanneur

Pour analyser à partir de votre application, vous devez d’abord obtenir un scanneur disponible attaché à l’ordinateur. Seuls les scanneurs installés localement avec Windows pilotes WIA sont répertoriés et disponibles pour votre application.

Pour obtenir un scanneur attaché, vous pouvez utiliser l’interface utilisateur du système DevicePicker ou utiliser d’autres Windows. API Devices.Enumeration comme indiqué dans Enumerate devices. Dans les deux cas, vous pouvez utiliser la valeur DeviceClass.ImageScanner comme filtre afin que DevicePicker ou DeviceWatcher affiche uniquement les appareils de scanneur d’images.

Les API d’énumération d’appareil vous donnent un objet DeviceInformation qui représente un appareil attaché à l’ordinateur. Une fois que vous avez l’objet DeviceInformation pour un scanneur, vous pouvez l’utiliser pour créer un objet ImageScanner . ImageScanner représente le scanneur dans le code de votre application et vous donne accès aux propriétés et méthodes que vous utiliserez pour l’analyse.

Choisir un scanneur disponible

Dans cet exemple, vous utilisez le système DevicePicker pour permettre à l’utilisateur de choisir un scanneur attaché.

DeviceInformation scannerDeviceInfo;
ImageScanner selectedScannerDevice;

private async Task InitializeScannerDevice()
{
    scannerDeviceInfo = await PickScannerDevice();
    if (scannerDeviceInfo is not null)
    {
        selectedScannerDevice = await ImageScanner.FromIdAsync(scannerDeviceInfo.Id);
        StatusBar.Message = $"Scanner selected: {scannerDeviceInfo.Name}.";
    }
    else
    {
        // Either no scanner is attached, or the user cancelled the device picker.
        StatusBar.Message = $"No scanner is selected.";
    }
}

private async Task<DeviceInformation> PickScannerDevice()
{
    var hWnd = WinRT.Interop.WindowNative.GetWindowHandle(App.MainWindow);
    DevicePicker devicePicker = new();
    // Initialize the device picker with the window handle (HWND).
    WinRT.Interop.InitializeWithWindow.Initialize(devicePicker, hWnd);

    // Filter to show only image scanner devices in the picker.
    devicePicker.Filter.SupportedDeviceClasses.Add(DeviceClass.ImageScanner);

    scannerDeviceInfo = await devicePicker.PickSingleDeviceAsync(new Rect());
    return scannerDeviceInfo;
}

Énumérer les scanneurs disponibles

Dans cet exemple, l’énumération de l’appareil scanneur est effectuée à l’aide de la classe DeviceWatcher à partir de la classe Windows. Devices.Enumeration espace de noms. Pour plus d’informations, consultez Énumérer les appareils.

1. Tout d’abord, ajoutez ces directives d'utilisation dans votre fichier de définition de classe.

    using Windows.Devices.Enumeration;
    using Windows.Devices.Scanners;

1. Ensuite, implémentez un observateur d’appareil pour démarrer l’énumération des scanneurs.

ObservableCollection<DeviceInformation> scannerDeviceList = new();

private async void WatchScanners()
{
    scannerDeviceList.Clear();
    deviceWatcher = DeviceInformation.CreateWatcher(DeviceClass.ImageScanner);

    deviceWatcher.Added += DeviceWatcher_Added;
    deviceWatcher.Removed += DeviceWatcher_Removed;
    deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;

    if (deviceWatcher.Status == DeviceWatcherStatus.Created)
    {
        deviceWatcher.Start();
    }
}

1. Créez un gestionnaire d’événements pour le moment où l’énumération de l’appareil est terminée.

private void DeviceWatcher_EnumerationCompleted(DeviceWatcher sender, object args)
{
    DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Normal, () =>
    {
        if (scannerDeviceList.Count == 0)
        {
            StatusBar.Message = "No scanners found. Please make sure that your scanner is on and properly connected.";
        }
        else
        {
            StatusBar.Message = "Enumeration of scanners is complete.";
        }
    });
}

1. Créez des gestionnaires d’événements pour le moment où un scanneur est ajouté ou supprimé.

private void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
{
    DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Normal, () =>
    {
        scannerDeviceList.Remove(scannerDeviceList.Where(x => x.Id == args.Id).FirstOrDefault());
        StatusBar.Message = $"Scanner removed: {args.Id}";
    });
}

private void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
{
    DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Normal, () =>
    {
        scannerDeviceList.Add(args);
        StatusBar.Message = $"Scanner added: {args.Name}";
    });
}

Numériser

Vous utilisez des API de l’espace de noms Windows.Devices.Scanners pour configurer un scanner et numériser des documents. L’objet ImageScanner représente le scanneur dans le code de votre application et vous donne accès aux propriétés et méthodes que vous utiliserez pour l’analyse.

Comme indiqué dans la section précédente, vous créez une instance d’ImageScanner en appelant ImageScanner.FromIdAsync et en passant le DeviceInformation.Id du scanneur que vous souhaitez utiliser.

ImageScanner selectedScannerDevice;
selectedScannerDevice = await ImageScanner.FromIdAsync(scannerDeviceInfo.Id);

Pour effectuer une analyse, appelez ImageScanner.ScanFileToFolderAsync et spécifiez la source d’analyse et le dossier de destination. Ici, un dossier appelé Scans est créé dans la bibliothèque Images en tant que destination pour les résultats de l’analyse.  

StorageFolder folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("Scans", CreationCollisionOption.OpenIfExists);
                
ImageScannerScanResult result = await selectedScannerDevice.ScanFilesToFolderAsync(ImageScannerScanSource.Default,
        folder);

Analyser les sources

Un scanneur peut être équipé d'un plateau, d'un chargeur automatique ou des deux comme source de numérisation. Certains scanneurs prennent également en charge l’analyse configurée automatiquement. Ces sources d’analyse sont identifiées par l’énumération ImageScannerScanSource et représentées par ces classes :

• ImageScannerFlatbedConfiguration (propriété ImageScanner.FlatbedConfiguration )
• ImageScannerFeederConfiguration (propriété ImageScanner.FeederConfiguration )
• ImageScannerAutoConfiguration (propriété ImageScanner.AutoConfiguration )

Vous pouvez utiliser l’objet source d’analyse pour :

• Vérifiez si la source d’analyse est prise en charge par le scanneur.

  selectedScannerDevice.IsScanSourceSupported(ImageScannerScanSource.AutoConfigured);
  

• Vérifiez si la source d’analyse prend en charge les analyses d’aperçu.

  selectedScannerDevice.IsPreviewSupported(ImageScannerScanSource.Feeder);
  

• Spécifiez la source à partir de laquelle effectuer l’analyse.

  selectedScannerDevice.ScanFilesToFolderAsync(ImageScannerScanSource.Flatbed, folder);
  

Vous pouvez également utiliser les objets ImageScannerFlatbedConfiguration et ImageScannerFeederConfiguration pour lire et définir de nombreuses propriétés de la source d’analyse correspondante.

Source d’analyse par défaut

Pour obtenir la source d’analyse par défaut d’un scanneur, utilisez la propriété ImageScanner.DefaultScanSource . Vous pouvez également utiliser la valeur d’énumération ImageScannerScanSource.Default pour spécifier que la source d’analyse par défaut doit être utilisée.

Par exemple, ces deux appels sont équivalents :

selectedScannerDevice.ScanFilesToFolderAsync(ImageScannerScanSource.Default, folder);
selectedScannerDevice.ScanFilesToFolderAsync(selectedScannerDevice.DefaultScanSource, folder);

Analyse configurée automatiquement

Pour utiliser les paramètres configurés automatiquement, le scanneur doit être activé pour la configuration automatique et ne doit pas être équipé à la fois d’un scanneur à plat et d’un scanneur d’alimentation. Pour plus d’informations, consultez Analyse à configuration automatique.

Votre application peut utiliser la numérisation à configuration automatique de l’appareil pour numériser avec les paramètres de numérisation les plus adaptés. Avec cette option, l’appareil lui-même peut déterminer les meilleurs paramètres d’analyse, tels que le mode de couleur et la résolution d’analyse, en fonction du contenu analysé. L’appareil sélectionne les paramètres d’analyse au moment de l’exécution pour chaque nouvelle tâche d’analyse.

Dans cet exemple, vous vérifiez d’abord si le scanner prend en charge la configuration automatique et n’effectuez l’analyse que dans ce cas.

if (selectedScannerDevice.IsScanSourceSupported(ImageScannerScanSource.AutoConfigured))
{
    // Scan API call to start scanning with Auto-Configured settings.
    ImageScannerScanResult result = await selectedScannerDevice.ScanFilesToFolderAsync(
        ImageScannerScanSource.AutoConfigured, folder);
}

Afficher un aperçu de l’analyse

Si le scanner le prend en charge, vous permettez à l’utilisateur de prévisualiser la numérisation avant de numériser vers un dossier. Dans cet exemple, l’application vérifie si la source d’analyse Feeder prend en charge l’aperçu, puis prévisualise l’analyse si c’est le cas.

if (selectedScannerDevice.IsPreviewSupported(ImageScannerScanSource.Feeder))
{
    IRandomAccessStream stream = new InMemoryRandomAccessStream();
    // Scan API call to get preview from the Feeder.
    ImageScannerScanResult result = 
        await selectedScannerDevice.ScanPreviewToStreamAsync(ImageScannerScanSource.Feeder, stream);
    if (result.Succeeded)
    {
        // ScanPreviewImage is a XAML Image control (not shown).
        SetImageSourceFromStream(stream, ScanPreviewImage);
        StatusBar.Message = "Preview scan is complete.";
    }
    else
    {
        StatusBar.Message = $"Failed to preview from Feeder.";
    }
}
else
{
    StatusBar.Message = $"The selected scanner does not support preview from Feeder.";
}

Cette méthode montre comment afficher l’aperçu dans l’interface utilisateur de votre application.

static async public void SetImageSourceFromStream(IRandomAccessStream stream, Image img)
{
    BitmapImage bitmap = await GetImageFromFile(stream);

    if ((bitmap.PixelHeight > img.Height) || (bitmap.PixelWidth > img.Width))
    {
        img.Stretch = Stretch.Uniform;
    }
    else
    {
        img.Stretch = Stretch.None;
    }
    img.Source = bitmap;
}

Numérisation vers la bibliothèque d’images

Les utilisateurs peuvent effectuer une analyse dynamique sur n’importe quel dossier à l’aide de la classe FolderPicker, mais vous devez déclarer la fonctionnalité Pictures Library dans le manifeste pour permettre aux utilisateurs d’analyser ce dossier. Pour plus d’informations sur les fonctionnalités d’application, consultez les déclarations de fonctionnalités d’application.