Partager via

Vue d'ensemble de la création d'images

  • Article

Cette rubrique fournit une introduction au Microsoft Windows Presentation Foundation Imaging Component. La WPF Imaging 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 WPF Imaging 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 Microsoft Windows Graphics Device Interface (GDI) ou Microsoft Windows GDI+. Ces API proposent des fonctionnalités de base pour la création d'images, mais sont dépourvues de fonctionnalités telles que la prise en charge de l'extensibilité de codec et des images haute fidélité. WPF Imaging est conçu de manière à résoudre les points faibles de GDI et GDI+ et à fournir un nouveau jeu d'API pour afficher et utiliser des images dans vos applications.

Il existe deux moyens d'accéder à l'API de WPF Imaging : 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, notamment bitmap (BMP), Joint Photographics Experts Group (JPEG), Portable Network Graphics (PNG), Tagged Image File Format (TIFF), Microsoft Windows Media Photo, Graphics Interchange Format (GIF) et les icônes (.ico).

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

  • 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'user interface (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 WPF Imaging 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 est utilisé pour décoder ou encoder un format de média spécifique. WPF Imaging comprend un codec pour les formats d'image BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF et ICON. 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 WPF Imaging. 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 WPF Imaging 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);


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

// Draw the Image
Image^ myImage2 = gcnew Image();
myImage2->Source = bitmapSource2;
myImage2->Stretch = Stretch::None;
myImage2->Margin = System::Windows::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 ensuite être utilisées pour créer des fichiers image. WPF Imaging fournit des encodeurs pour chacun des formats d'image décrits ci-dessus.

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);

FileStream^ stream = gcnew FileStream("new.bmp", FileMode::Create);
BmpBitmapEncoder^ encoder = gcnew BmpBitmapEncoder();
TextBlock^ myTextBlock = gcnew 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 Extensible Application Markup Language (XAML) qui permet d'afficher facilement des images comme la Source d'un contrôle Image.

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

RemarqueRemarque

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>

' 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 UI 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 WPF Imaging 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 s'effectue via 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 figurer dans un schéma de métadonnées ou dans une combinaison de différents schémas. WPF Imaging prend en charge les schémas de métadonnées d'image suivants : Exchangeable image file (Exif), tEXt (PNG Textual Data), image file directory (IFD), 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();


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

Pour écrire les métadonnées, un writer de requête de métadonnées est utilisé. SetQuery obtient le writer de requête 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();

Stream^ pngStream = gcnew FileStream("smiley.png", FileMode::Open, FileAccess::ReadWrite, FileShare::ReadWrite);
PngBitmapDecoder^ pngDecoder = gcnew 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 WPF Imaging 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 à WPF afin que de nouveaux formats d'image puissent être utilisés automatiquement par les applications WPF.

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

RemarqueRemarque

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

Voir aussi

Référence

BitmapSource

BitmapImage

Image

BitmapMetadata

Concepts

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

Autres ressources

Exemple de codec Win32 (page éventuellement en anglais)