Vue d'ensemble de l'acquisition d'images

  • Article

Mise à jour : novembre 2007

Cette rubrique fournit une introduction au composant d'image Microsoft Windows Presentation Foundation (WPF). La création d'images WPF permet aux développeurs d'afficher, de transformer et de formater des images.

Cette rubrique comprend les sections suivantes.

  • Composant de création d'images WPF
  • Formats d'image WPF
  • Affichage d'images dans WPF
  • Métadonnées d'image
  • Extensibilité codec
  • Rubriques connexes

Composant de création d'images WPF

La création d'images WPF apporte d'importantes améliorations aux fonctionnalités de création d'images dans Microsoft Windows. Les fonctionnalités de création d'images, comme l'affichage d'une bitmap ou l'utilisation d'une image sur un contrôle ordinaire dépendaient auparavant des bibliothèques interface graphique GDI (Graphics Device Interface) Microsoft Windows ou Microsoft Windows GDI+. Ces API offrent une fonctionnalité de création d'images de base, mais ne disposent pas de fonctionnalités comme la prise en charge de l'extensibilité codec et des images haute définition. La création d'images WPF est conçue pour pallier les défauts de GDI et GDI+ et fournit un nouveau jeu d'API pour afficher et utiliser les images dans vos applications.

Il existe deux moyens d'accéder à l'API de création d'images WPF : un composant managé et un composant non managé. Le composant non propose les fonctionnalités suivantes.

  • Modèle d'extensibilité pour les formats d'image nouveaux ou propriétaires.

  • Performance et sécurité améliorées sur les formats d'image natifs comprenant BMP (Bitmap), JPEG (Joint Photographic Experts Group), PNG (Portable Network Graphics), TIFF (Tagged Image File Format), Microsoft Windows Media Photo, GIF (Graphics Interchange Format) et icône (.ico).

  • Préservation de la profondeur de couleur élevée des données image jusqu'à 32 bits par canal.

  • Mise à l'échelle, rognage et rotation d'image non destructives.

  • Gestion des couleurs simplifiées.

  • Prise en charge des métadonnées dans les fichiers propriétaires.

  • Le composant managé utilise l'infrastructure non managée pour fournir une intégration transparente d'images avec d'autres fonctionnalités WPF telles que l'interface utilisateur (UI), l'animation et les graphiques. Le composant managé bénéficie également du modèle d'extensibilité codec de création d'images Windows Presentation Foundation (WPF) qui permet la reconnaissance automatique des nouveaux formats d'image dans les applications WPF.

La plupart des API de création d'images WPF se trouvent dans l'espace de noms System.Windows.Media.Imaging, bien que plusieurs types importants, tels que ImageBrush et ImageDrawing se trouvent dans l'espace de noms System.Windows.Media et que Image se trouve dans l'espace de noms System.Windows.Controls.

Cette rubrique fournit des informations supplémentaires sur le composant managé. Pour plus d'informations sur l'API non managée, consultez Composant de création d'images WPF non managé.

Formats d'image WPF

Un codec sert à décoder et à encoder un format multimédia spécifique. La création d'images WPF comprend un codec pour les formats BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF et les formats d'image d'icônes. Chacun de ces codecs permet aux applications de décoder et, sauf pour les icônes, d'encoder leurs formats d'image respectifs.

BitmapSource est une classe importante utilisée dans le décodage et l'encodage d'images. Il s'agit du bloc de construction de base du pipeline de création d'images WPF. Il représente un seul jeu constant de pixels à une certaine taille et à une certaine résolution. Un BitmapSource peut être une frame individuelle d'une image à plusieurs frames, ou peut être le résultat d'une transformation effectuée sur un BitmapSource. C'est le parent de nombreuses classes principales utilisées dans la création d'images WPF comme BitmapFrame.

Un BitmapFrame sert à stocker les données bitmap actuelles d'un format d'image. De nombreux formats d'image prennent seulement en charge un BitmapFrame unique, bien que les formats tels que GIF et TIFF prennent en charge plusieurs frames par image. Les frames sont utilisées par les décodeurs comme données d'entrée et passées à des encodeurs pour créer les fichiers image.

L'exemple suivant montre comment est créé un BitmapFrame à partir d'un BitmapSource, puis ajouté à une image TIFF.

Dim image5 As BitmapSource = System.Windows.Media.Imaging.BitmapSource.Create(width, height, 96, 96, PixelFormats.Indexed1, BitmapPalettes.WebPalette, pixels, stride)

Dim stream5 As New FileStream("palette.tif", FileMode.Create)
Dim encoder5 As New TiffBitmapEncoder()
encoder5.Frames.Add(BitmapFrame.Create(image5))
encoder5.Save(stream5)

BitmapSource image5 = BitmapSource.Create(
    width,
    height,
    96,
    96,
    PixelFormats.Indexed1,
    BitmapPalettes.WebPalette,
    pixels,
    stride);

FileStream stream5 = new FileStream("palette.tif", FileMode.Create);
TiffBitmapEncoder encoder5 = new TiffBitmapEncoder();
encoder5.Frames.Add(BitmapFrame.Create(image5));
encoder5.Save(stream5);

Décodage du format d'image

Le décodage d'une image est la traduction d'un format d'image en données d'image pouvant être utilisées par le système. Les données d'image peuvent être utilisées pour afficher, traiter ou encoder dans un format différent. La sélection du décodeur est basée sur le format de l'image. La sélection du codec est automatique à moins qu'un décodeur spécifique ne soit indiqué. Les exemples de la section Affichage d'images dans WPF illustrent le décodage automatique. Les décodeurs de formats personnalisés, développés à l'aide des interfaces de création d'images WPF non managées, et inscrits automatiquement dans le système participent à la sélection du décodeur. Cela permet d'afficher automatiquement les formats personnalisés dans les applications WPF.

L'exemple suivant montre comment utiliser un décodeur de bitmap pour décoder une image au format BMP.

' Open a Uri and decode a BMP image
Dim myUri As New Uri("tulipfarm.bmp", UriKind.RelativeOrAbsolute)
Dim decoder2 As New BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default)
Dim bitmapSource2 As BitmapSource = decoder2.Frames(0)

' Draw the Image
Dim myImage2 As New Image()
myImage2.Source = bitmapSource2
myImage2.Stretch = Stretch.None
myImage2.Margin = New Thickness(20)

// Open a Uri and decode a BMP image
Uri myUri = new Uri("tulipfarm.bmp", UriKind.RelativeOrAbsolute);
BmpBitmapDecoder decoder2 = new BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource bitmapSource2 = decoder2.Frames[0];

// Draw the Image
Image myImage2 = new Image();
myImage2.Source = bitmapSource2;
myImage2.Stretch = Stretch.None;
myImage2.Margin = new Thickness(20);

Encodage du format d'image

L'encodage d'une image est la traduction de données d'image en un format d'image spécifique. Les données d'image encodées peuvent être utilisées pour créer de nouveaux fichiers image. La création d'images WPF fournit des encodeurs pour chacun des formats d'image décrits ci-dessous.

L'exemple suivant montre comment utiliser un encodeur pour enregistrer une image bitmap nouvellement créée.

Dim stream As New FileStream("new.bmp", FileMode.Create)
Dim encoder As New BmpBitmapEncoder()
Dim myTextBlock As New TextBlock()
myTextBlock.Text = "Codec Author is: " + encoder.CodecInfo.Author.ToString()
encoder.Frames.Add(BitmapFrame.Create(image))
encoder.Save(stream)

FileStream stream = new FileStream("new.bmp", FileMode.Create);
BmpBitmapEncoder encoder = new BmpBitmapEncoder();
TextBlock myTextBlock = new TextBlock();
myTextBlock.Text = "Codec Author is: " + encoder.CodecInfo.Author.ToString();
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(stream);

Affichage d'images dans WPF

Il existe plusieurs manières d'afficher une image dans une application Windows Presentation Foundation (WPF). Les images peuvent être affichées en utilisant un contrôle Image, peint sur un visuel à l'aide d'un ImageBrush, ou dessiné à l'aide d'un ImageDrawing.

Utilisation du contrôle d'image

Image est un élément d'infrastructure et le principal moyen d'afficher des images dans les applications. En XAML, Image peut être utilisé de deux façons ; syntaxe d'attribut ou syntaxe de propriété. Les exemples suivants montrent comment restituer une image de 200 pixels de large à l'aide des syntaxes d'attribut et de balise de propriété. Pour plus d'informations sur la syntaxe d'attribut et la syntaxe de propriété, consultez Vue d'ensemble des propriétés de dépendance.

<!-- Simple image rendering. However, rendering an image this way may not
     result in the best use of application memory. See markup below which
     creates the same end result but using less memory. -->
<Image Width="200" 
Source="C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\Water Lilies.jpg"/>

<Image Width="200">
  <Image.Source>
    <!-- To save significant application memory, set the DecodePixelWidth or  
     DecodePixelHeight of the BitmapImage value of the image source to the desired 
     height and width of the rendered image. If you don't do this, the application will 
     cache the image as though it were rendered as its normal size rather then just 
     the size that is displayed. -->
    <!-- Note: In order to preserve aspect ratio, only set either DecodePixelWidth
         or DecodePixelHeight but not both. -->
    <BitmapImage DecodePixelWidth="200"  
     UriSource="C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\Water Lilies.jpg" />
  </Image.Source>
</Image>

La plupart des exemples utilisent un objet BitmapImage pour référencer un fichier image. BitmapImage est un BitmapSource spécialisé optimisé pour le chargement XAML (Extensible Application Markup Language) et s'avère être un moyen simple d'afficher des images comme Source d'un contrôle Image.

L'exemple suivant montre comment restituer une image de 200 pixels de large à l'aide de code.

Remarque :

BitmapImage implémente l'interface ISupportInitialize pour optimiser l'initialisation de plusieurs propriétés. Les modifications de propriété ne peuvent se produire que lors de l'initialisation de l'objet. Appelez BeginInit pour signaler que l'initialisation a démarré et EndInit pour signaler que l'initialisation est terminée. Une fois initialisées, les modifications de propriété sont ignorées.

 
' Create Image Element
Dim myImage As New Image()
myImage.Width = 200

' Create source
Dim myBitmapImage As New BitmapImage()

' BitmapImage.UriSource must be in a BeginInit/EndInit block
myBitmapImage.BeginInit()
myBitmapImage.UriSource = New Uri("C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\Water Lilies.jpg")

' To save significant application memory, set the DecodePixelWidth or  
' DecodePixelHeight of the BitmapImage value of the image source to the desired 
' height or width of the rendered image. If you don't do this, the application will 
' cache the image as though it were rendered as its normal size rather then just 
' the size that is displayed.
' Note: In order to preserve aspect ratio, set DecodePixelWidth
' or DecodePixelHeight but not both.
myBitmapImage.DecodePixelWidth = 200
myBitmapImage.EndInit()
'set image source
myImage.Source = myBitmapImage

// Create Image Element
Image myImage = new Image();
myImage.Width = 200;

// Create source
BitmapImage myBitmapImage = new BitmapImage();

// BitmapImage.UriSource must be in a BeginInit/EndInit block
myBitmapImage.BeginInit();
myBitmapImage.UriSource = new Uri(@"C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\Water Lilies.jpg");

// To save significant application memory, set the DecodePixelWidth or  
// DecodePixelHeight of the BitmapImage value of the image source to the desired 
// height or width of the rendered image. If you don't do this, the application will 
// cache the image as though it were rendered as its normal size rather then just 
// the size that is displayed.
// Note: In order to preserve aspect ratio, set DecodePixelWidth
// or DecodePixelHeight but not both.
myBitmapImage.DecodePixelWidth = 200;
myBitmapImage.EndInit();
//set image source
myImage.Source = myBitmapImage;

Rotation, conversion et rognage d'images

WPF permet aux utilisateurs de transformer des images en utilisant des propriétés de BitmapImage ou des objets BitmapSource supplémentaires tels que CroppedBitmap ou FormatConvertedBitmap. Ces transformations d'image peuvent mettre à l'échelle ou faire pivoter une image, modifier le format de pixel d'une image ou rogner une image.

Les rotations d'image s'effectuent en utilisant la propriété Rotation de BitmapImage. Les rotations s'effectuent uniquement par incréments de 90 degrés. Dans l'exemple suivant, une image est pivotée de 90 degrés.

<Image Width="150" Margin="5" Grid.Column="0" Grid.Row="1">
  <Image.Source>
    <TransformedBitmap Source="/sampleImages/watermelon.jpg" >
      <TransformedBitmap.Transform>
        <RotateTransform Angle="90"/>
      </TransformedBitmap.Transform>
    </TransformedBitmap>
  </Image.Source>
</Image>

<Image Width="150" Margin="5" Grid.Column="0" Grid.Row="1">
  <Image.Source>
    <TransformedBitmap Source="/sampleImages/watermelon.jpg" >
      <TransformedBitmap.Transform>
        <RotateTransform Angle="90"/>
      </TransformedBitmap.Transform>
    </TransformedBitmap>
  </Image.Source>
</Image>

' Create Image element.
Dim rotated90 As New Image()
rotated90.Width = 150

' Create the TransformedBitmap to use as the Image source.
Dim tb As New TransformedBitmap()

' Create the source to use as the tb source.
Dim bi As New BitmapImage()
bi.BeginInit()
bi.UriSource = New Uri("sampleImages/watermelon.jpg", UriKind.RelativeOrAbsolute)
bi.EndInit()

' Properties must be set between BeginInit and EndInit calls.
tb.BeginInit()
tb.Source = bi
' Set image rotation.
Dim transform As New RotateTransform(90)
tb.Transform = transform
tb.EndInit()
' Set the Image source.
rotated90.Source = tb

// Create Image element.
Image rotated90 = new Image();
rotated90.Width = 150;

// Create the TransformedBitmap to use as the Image source.
TransformedBitmap tb = new TransformedBitmap();

// Create the source to use as the tb source.
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = new Uri(@"sampleImages/watermelon.jpg", UriKind.RelativeOrAbsolute);
bi.EndInit();

// Properties must be set between BeginInit and EndInit calls.
tb.BeginInit();
tb.Source = bi;
// Set image rotation.
RotateTransform transform = new RotateTransform(90);
tb.Transform = transform;
tb.EndInit();
// Set the Image source.
rotated90.Source = tb;

La conversion d'une image dans un format de pixel différent comme les nuances de gris s'effectue en utilisant FormatConvertedBitmap. Dans les exemples suivants, une image est convertie en Gray4.

<!-- Grayscale XAML Image -->
<Image Width="200" Grid.Column="0" Grid.Row="1">
   <Image.Source>
      <FormatConvertedBitmap Source="/sampleImages/rocks.jpg"  DestinationFormat="Gray4" />
   </Image.Source>
</Image>

'Create Image Element
Dim grayImage As New Image()
grayImage.Width = 200
grayImage.Margin = New Thickness(5)

'Create source using xaml defined resource.
Dim fcb As New FormatConvertedBitmap(CType(Me.Resources("masterImage"), BitmapImage), PixelFormats.Gray4, Nothing, 0)
'set image source
grayImage.Source = fcb

//Create Image Element
Image grayImage = new Image();
grayImage.Width = 200;
grayImage.Margin = new Thickness(5);

//Create source using xaml defined resource.
FormatConvertedBitmap fcb = new FormatConvertedBitmap(
   (BitmapImage)this.Resources["masterImage"],PixelFormats.Gray4,null,0);
//set image source
grayImage.Source = fcb;

Pour rogner une image, utilisez la propriété Clip de Image ou CroppedBitmap. En général, si vous souhaitez afficher une portion d'une image, Clip doit être utilisé. Si vous avez besoin d'encoder et d'enregistrer une image rognée, CroppedBitmap doit être utilisé. Dans l'exemple suivant, une image est rognée à l'aide de la propriété Clip en utilisant EllipseGeometry.

<!-- Cropping an Image using Clip -->
<Image Width="200" Grid.Column="0" Grid.Row="5" Margin="5"
   Source="/sampleImages/gecko.jpg">
  <Image.Clip>
    <EllipseGeometry Center="75,50" RadiusX="50" RadiusY="25" />
  </Image.Clip>
</Image>

' Create the image for clipping
Dim clipImage As New Image()
clipImage.Width = 200
clipImage.Margin = New Thickness(5)

'Create & Set source
Dim bi As New BitmapImage()
' BitmapImage properties must be in a BeginInit/EndInit block
bi.BeginInit()
bi.UriSource = New Uri("pack://application:,,/sampleImages/gecko.jpg")
bi.EndInit()
clipImage.Source = bi

' Clip the using an EllipseGeometry
Dim clipGeometry As New EllipseGeometry(New System.Windows.Point(75, 50), 50, 25)
clipImage.Clip = clipGeometry

//Create the image for clipping
Image clipImage = new Image();
clipImage.Width = 200;
clipImage.Margin = new Thickness(5);

//Create & Set source
BitmapImage bi = new BitmapImage();
//BitmapImage.UriSource must be in a BeginInit/EndInit block
bi.BeginInit();
bi.UriSource = new Uri("pack://application:,,/sampleImages/gecko.jpg");
bi.EndInit();
clipImage.Source = bi;

//Clip the using an EllipseGeometry
EllipseGeometry clipGeometry = new EllipseGeometry(new Point(75, 50), 50, 25);
clipImage.Clip = clipGeometry;

Étirement d'images

La propriété Stretch contrôle la manière dont une image est étirée pour remplir son conteneur. La propriété Stretch accepte les valeurs suivantes, qui sont définies par l'énumération Stretch :

  • None : l'image n'est pas étirée pour remplir la zone de sortie. Si l'image est plus grande que la zone de sortie, elle est dessinée sur la zone de sortie, en découpant ce qui ne s'ajuste pas.

  • Fill : l'image n'est pas mise à l'échelle pour s'ajuster à la zone de sortie. Comme la hauteur et la largeur d'image sont mises à l'échelle indépendamment, les proportions d'origine de l'image ne sont pas nécessairement conservées. Autrement dit, l'image peut être retracée pour remplir complètement le conteneur de sortie.

  • Uniform : l'image est mise à l'échelle de manière à s'ajuster complètement à la zone de sortie. Les proportions de l'image sont conservées.

  • UniformToFill : l'image est mise à l'échelle de manière à remplir complètement la zone de sortie tout en conservant ses proportions d'origine.

L'exemple suivant applique chacune des énumérations Stretch disponibles sur une Image.

L'image suivante montre le résultat de l'exemple et montre les effets obtenus par les différents paramètres Stretch lorsqu'ils sont appliqués à une image.

Paramètres d'étirement différents

Différents paramètres d'étirement TileBrush

<Page xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" >
  <DockPanel>

    <Border DockPanel.Dock="Top" Background="Black">
      <TextBlock Foreground="White" HorizontalAlignment="Stretch" FontSize="20">
        Stretching an Image
      </TextBlock>
    </Border>

    <Grid Name="simpleGrid" Background="{StaticResource CheckeredBrushResource}" 
       Margin="10" 
       ShowGridLines="True"
       VerticalAlignment="Center"
       HorizontalAlignment="Center">
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="175" />
        <ColumnDefinition Width="175" />
        <ColumnDefinition Width="175" />
        <ColumnDefinition Width="175" />
      </Grid.ColumnDefinitions>
      <Grid.RowDefinitions>
        <RowDefinition />
        <RowDefinition Height="200"/>
      </Grid.RowDefinitions>
      <!-- Labels -->
      <TextBlock Style="{StaticResource Header1}" 
        Grid.Column="0" Grid.Row="0">None</TextBlock>
      <TextBlock Style="{StaticResource Header1}" 
        Grid.Column="1" Grid.Row="0">Uniform</TextBlock>
      <TextBlock Style="{StaticResource Header1}" 
        Grid.Column="2" Grid.Row="0">UniformToFill</TextBlock>
      <TextBlock Style="{StaticResource Header1}"
        Grid.Column="3" Grid.Row="0">Fill</TextBlock>
      <Border Grid.Column="0" Grid.Row="1" BorderThickness="1" BorderBrush="Black">
        <!-- None: Image is not scaled. If image is larger than the
             output area, the image will be cropped to the size of the output area.-->
        <Image
          Source="sampleImages/gecko.jpg" 
          Stretch="None" />
      </Border>
      <Border Grid.Column="1" Grid.Row="1" BorderThickness="1" BorderBrush="Black">
        <!-- Uniform: Scale to fit output area.
             Aspect ratio is preserved.-->
        <Image
          Source="sampleImages/gecko.jpg" 
          Stretch="Uniform" />
      </Border>
      <Border Grid.Column="2" Grid.Row="1" BorderThickness="1" BorderBrush="Black">
        <!-- UniformToFill: Scale to completely fill output area.
             Aspect ratio is preserved. Cropping may occur.-->
        <Image  
          Source="sampleImages/gecko.jpg" 
        Stretch="UniformToFill" />
      </Border>
      <Border Grid.Column="3" Grid.Row="1" BorderThickness="1" BorderBrush="Black">
      <!-- Fill: Scale to completely fill output area.
             Aspect ratio may not be preserved.-->
      <Image 
        Source="sampleImages/gecko.jpg" 
        Stretch="Fill" />
      </Border>
    </Grid>
  </DockPanel>
</Page>

Peinture avec des images

Les images peuvent également être affichées dans une application en peignant avec un Brush. Les pinceaux vous permettent de peindre des objets interface utilisateur avec n'importe quoi, des couleurs simples et soldes aux ensembles complexes de modèles et d'images. Pour peindre avec des images, utilisez un ImageBrush. Un ImageBrush est un type de TileBrush qui définit son contenu comme une image bitmap. Un ImageBrush affiche une seule image qui est spécifiée par sa propriété ImageSource. Vous pouvez contrôler la manière dont l'image est étirée, alignée et mise en mosaïque, ce qui vous permet d'éviter la distorsion et de produire des modèles et autres effets. L'illustration suivante indique divers effets pouvant être accomplis avec un ImageBrush.

Les pinceaux d'image peuvent remplir des formes, des contrôles, du texte, etc.

Exemples de sortie ImageBrush

L'exemple suivant montre comment peindre l'arrière-plan d'un bouton avec une image à l'aide d'un ImageBrush.

<!-- Sets the button's Background property with an ImageBrush. The resulting
     button has an image as its background. -->
<Button Grid.Row="3" Grid.Column="2" 
 Height="75" Width="100" Foreground="White" FontWeight="Bold"
 HorizontalAlignment="Left">
  A Button
  <Button.Background>
    <ImageBrush ImageSource="sampleImages\blueberries.jpg" />
  </Button.Background>
</Button>

Pour plus d'informations sur ImageBrush et la peinture d'images, consultez Peinture avec des objets d'image, de dessin et visuels.

Métadonnées d'image

Certains fichiers image contiennent des métadonnées qui décrivent le contenu ou les caractéristiques du fichier. Par exemple, la plupart des appareils photo numériques créent des images contenant des métadonnées sur la marque et le modèle de l'appareil photo utilisé pour capturer l'image. Chaque format d'image gère les métadonnées différemment, mais la création d'images WPF offre un moyen uniforme de stocker et de récupérer les métadonnées pour chaque format d'image pris en charge.

L'accès aux métadonnées est fourni par le biais de la propriété Metadata d'un objet BitmapSource. Metadata retourne un objet BitmapMetadata qui inclut toutes les métadonnées contenues par l'image. Ces données peuvent se trouver dans un seul schéma de métadonnées ou dans une combinaison de plusieurs schémas. La création d'images WPF prend en charge les schémas de métadonnées d'image suivants : fichier image au format Exif (Exchangeable Image File), tEXt (données textuelles PNG), répertoire des fichiers image (IFD, Image File Directory), International Press Telecommunications Council (IPTC) et eXtensible Metadata Platform (XMP).

Afin de simplifier le processus de lecture des métadonnées, BitmapMetadata fournit plusieurs propriétés nommées facilement accessibles telles que Author, Title et CameraModel. La plupart de ces propriétés nommées peuvent également être utilisées pour écrire des métadonnées. Une prise en charge de lecture des métadonnées supplémentaire est fournie par le lecteur de requêtes de métadonnées. La méthode GetQuery sert à récupérer un lecteur de requêtes de métadonnées en fournissant une requête de chaîne telle que "/app1/exif/". Dans l'exemple suivant, GetQuery est utilisé pour obtenir le texte stocké dans l'emplacement "/Texte/Description".

' Add the metadata of the bitmap image to the text block.
Dim myTextBlock As New TextBlock()
myTextBlock.Text = "The Description metadata of this image is: " + pngInplace.GetQuery("/Text/Description").ToString()

// Add the metadata of the bitmap image to the text block.
TextBlock myTextBlock = new TextBlock();
myTextBlock.Text = "The Description metadata of this image is: " + pngInplace.GetQuery("/Text/Description").ToString();

Pour écrire des métadonnées, un enregistreur de requêtes de métadonnées est utilisé. SetQuery obtient l'enregistreur de requêtes et définit la valeur souhaitée. Dans l'exemple suivant, SetQuery est utilisé pour enregistrer le texte stocké dans l'emplacement "/Texte/Description".

Dim pngStream As New System.IO.FileStream("smiley.png", FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite)
Dim pngDecoder As New PngBitmapDecoder(pngStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default)
Dim pngFrame As BitmapFrame = pngDecoder.Frames(0)
Dim pngInplace As InPlaceBitmapMetadataWriter = pngFrame.CreateInPlaceBitmapMetadataWriter()
If pngInplace.TrySave() = True Then
    pngInplace.SetQuery("/Text/Description", "Have a nice day.")
End If
pngStream.Close()

Stream pngStream = new System.IO.FileStream("smiley.png", FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
PngBitmapDecoder pngDecoder = new PngBitmapDecoder(pngStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapFrame pngFrame = pngDecoder.Frames[0];
InPlaceBitmapMetadataWriter pngInplace = pngFrame.CreateInPlaceBitmapMetadataWriter();
if (pngInplace.TrySave() == true)
{ pngInplace.SetQuery("/Text/Description", "Have a nice day."); }
pngStream.Close();

Extensibilité codec

Une fonctionnalité principale de la création d'images WPF est le modèle d'extensibilité pour les nouveaux codecs d'image. Ces interfaces non managées permettent aux développeurs de codec d'intégrer des codecs avec WPF afin que de nouveaux formats d'image puissent être utilisés automatiquement par les applications WPF. Pour plus d'informations sur la création d'images WPF non managée, consultez Composant de création d'images WPF non managé.

Pour obtenir un exemple de l'API d'extensibilité, consultez Codec Wind32, exemple. L'exemple montre comment créer un décodeur et un encodeur pour un format d'image personnalisé.

Remarque :

Le codec doit être signé numériquement pour que le système le reconnaisse.

Voir aussi

Tâches

Codec Wind32, exemple

Photo Store, démonstration

Concepts

Optimisation des performances : graphiques 2D et acquisition d'images

Référence

Composant de création d'images WPF non managé

BitmapSource

BitmapImage

Image

BitmapMetadata