Información general sobre imágenes

En este tema se proporciona una introducción al componente de creación de imágenes de Microsoft Windows Presentation Foundation. La creación de imágenes de WPF permite a los desarrolladores mostrar, transformar y dar formato a imágenes.

Componente de creación de imágenes de WPF

La creación de imágenes de WPF proporciona mejoras significativas en las funcionalidades de creación de imágenes dentro de Microsoft Windows. Las funcionalidades de creación de imágenes, como mostrar un mapa de bits o usar una imagen en un control común dependían previamente de las bibliotecas de Microsoft Windows Graphics Device Interface (GDI) o GDI+ de Microsoft Windows. Estas API proporcionan funcionalidad de creación de imágenes de línea base, pero carecen de características como la compatibilidad con la extensibilidad del códec y la compatibilidad con imágenes de alta fidelidad. WpF Imaging está diseñado para superar las deficiencias de GDI y GDI+ y proporcionar un nuevo conjunto de API para mostrar y usar imágenes dentro de las aplicaciones.

Hay dos maneras de acceder a wpF Imaging API, un componente administrado y un componente no administrado. El componente no administrado proporciona las siguientes características.

• Modelo de extensibilidad para formatos de imagen nuevos o propietarios.

• Se ha mejorado el rendimiento y la seguridad en formatos de imagen nativa, incluidos el mapa de bits (BMP), el grupo de expertos fotográficos conjuntos (JPEG), los gráficos de red portátiles (PNG), el formato de archivo de imagen etiquetado (TIFF), la foto de Microsoft Windows Media, el formato de intercambio de gráficos (GIF) y el icono (.ico).

• Conservación de datos de imágenes de alta profundidad de bits hasta 8 bits por canal (32 bits por píxel).

• Transformaciones de imágenes no destructivas: escalado, recorte y rotación.

• Administración simplificada de colores.

• Compatibilidad con metadatos propietarios en archivos.

• El componente administrado utiliza la infraestructura no administrada para proporcionar una integración sin problemas de imágenes con otras características de WPF, como la interfaz de usuario (UI), la animación y los gráficos. El componente administrado también se beneficia del modelo de extensibilidad de códecs de creación de imágenes de Windows Presentation Foundation (WPF), que permite el reconocimiento automático de nuevos formatos de imagen en aplicaciones WPF.

La mayoría de la API de imágenes de WPF administrada reside en el System.Windows.Media.Imaging espacio de nombres, aunque varios tipos importantes, como ImageBrush y ImageDrawing residen en el System.Windows.Media espacio de nombres y Image reside en el System.Windows.Controls espacio de nombres.

En este tema se proporciona información adicional sobre el componente administrado. Para obtener más información sobre la API no administrada, consulte la documentación del componente de creación de imágenes de WPF no administrada .

Formatos de imagen de WPF

Un códec se usa para descodificar o codificar un formato multimedia específico. WPF Imaging incluye un códec para formatos de imagen BMP, JPEG, PNG, TIFF, Foto de Windows Media, GIF e ICON. Cada uno de estos códecs permite a las aplicaciones descodificar y, a excepción de ICON, codificar sus respectivos formatos de imagen.

BitmapSource es una clase importante que se usa en la descodificación y codificación de imágenes. Es el bloque básico de construcción del proceso de imágenes de WPF y representa un conjunto único y constante de píxeles de un cierto tamaño y resolución. Un BitmapSource puede ser un marco individual de una imagen de varios fotogramas o puede ser el resultado de una transformación realizada en un BitmapSource. Es el elemento primario de muchas de las clases principales que se usan en la creación de imágenes de WPF, como BitmapFrame.

BitmapFrame Se usa para almacenar los datos de mapa de bits reales de un formato de imagen. Muchos formatos de imagen solo admiten un solo BitmapFrame, aunque los formatos como GIF y TIFF admiten varios fotogramas por imagen. Los descodificadores usan fotogramas como datos de entrada y se pasan a codificadores para crear archivos de imagen.

En el ejemplo siguiente se muestra cómo se crea un BitmapFrame a partir de un BitmapSource y posteriormente se agrega a una imagen TIFF.

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

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)

Descodificación de formato de imagen

La descodificación de imágenes es la traducción de un formato de imagen a los datos de imagen que el sistema puede usar. Los datos de imagen se pueden usar para mostrar, procesar o codificar en un formato diferente. La selección del descodificador se basa en el formato de imagen. La selección del códec es automática a menos que se especifique un descodificador específico. Los ejemplos de la sección Mostrar imágenes en WPF muestran la descodificación automática. Los descodificadores de formatos personalizados desarrollados mediante las interfaces de imágenes no administradas de WPF y registrados en el sistema participan automáticamente en la selección del descodificador. Esto permite que los formatos personalizados se muestren automáticamente en aplicaciones WPF.

En el ejemplo siguiente se muestra el uso de un descodificador de mapa de bits para descodificar una imagen de formato BMP.

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

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

Codificación de formato de imagen

La codificación de imágenes es la traducción de datos de imagen a un formato de imagen específico. Los datos de imagen codificados se pueden usar para crear nuevos archivos de imagen. WPF Imaging proporciona codificadores para cada uno de los formatos de imagen descritos anteriormente.

En el ejemplo siguiente se muestra el uso de un codificador para guardar una imagen de mapa de bits recién creada.

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

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

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)

Mostrar imágenes en WPF

Hay varias maneras de mostrar una imagen en una aplicación de Windows Presentation Foundation (WPF). Las imágenes se pueden mostrar mediante un Image control, pintado en un objeto visual mediante ImageBrush, o dibujado mediante ImageDrawing.

Uso del control de imagen

Image es un elemento de marco y la forma principal de mostrar imágenes en aplicaciones. En XAML, Image se puede usar de dos maneras; sintaxis de atributo o sintaxis de propiedad. En el ejemplo siguiente se muestra cómo representar una imagen de 200 píxeles de ancho mediante la sintaxis de atributo y la sintaxis de etiqueta de propiedad. Para obtener más información sobre la sintaxis de atributos y la sintaxis de propiedades, consulte Introducción a las propiedades de dependencia.

<!-- 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 than 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>

Muchos de los ejemplos usan un BitmapImage objeto para hacer referencia a un archivo de imagen. BitmapImage es un BitmapSource especializado que está optimizado para la carga de Lenguaje de Marcado Extensible de Aplicaciones (XAML) y ofrece una manera sencilla de mostrar imágenes como el Source de un control Image.

En el ejemplo siguiente se muestra cómo representar una imagen de 200 píxeles de ancho mediante código.

// 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 than 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
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 than 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

Rotación, conversión y recorte de imágenes

WPF permite a los usuarios transformar imágenes mediante propiedades de BitmapImage o mediante objetos adicionales BitmapSource como CroppedBitmap o FormatConvertedBitmap. Estas transformaciones de imagen pueden escalar o girar una imagen, cambiar el formato de píxel de una imagen o recortar una imagen.

Las rotaciones de imágenes se realizan mediante la Rotation propiedad de BitmapImage. Las rotaciones únicamente se pueden realizar en incrementos de 90 grados. En el ejemplo siguiente, se gira una imagen de 90 grados.

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

' 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

La conversión de una imagen a un formato de píxel diferente, como la escala de grises, se realiza mediante FormatConvertedBitmap. En los ejemplos siguientes, una imagen se convierte 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
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;

'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

Para recortar una imagen, se puede usar la Clip propiedad de Image o CroppedBitmap . Normalmente, si solo desea mostrar una parte de una imagen, Clip debe usarse. Si necesita codificar y guardar una imagen recortada, CroppedBitmap se debe usar . En el ejemplo siguiente, se recorta una imagen con la propiedad Clip utilizando un 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
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;

' 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

Estirar imágenes

La Stretch propiedad controla cómo se extiende una imagen para rellenar su contenedor. La Stretch propiedad acepta los siguientes valores, definidos por la Stretch enumeración :

• None: la imagen no se extiende para rellenar el área de salida. Si la imagen es mayor que el área de salida, la imagen se dibuja en el área de salida, recortando lo que no cabe.

• Fill: la imagen se escala para ajustarse al área de salida. Dado que el alto y el ancho de la imagen se escalan de forma independiente, es posible que no se conserve la relación de aspecto original de la imagen. Es decir, es posible que la imagen se deforme o ajuste para llenar por completo el contenedor de salida.

• Uniform: la imagen se escala para que se ajuste completamente dentro del área de salida. Se conserva la relación de aspecto de la imagen.

• UniformToFill: la imagen se escala para que rellene completamente el área de salida mientras conserva la relación de aspecto original de la imagen.

En el siguiente ejemplo se aplica cada una de las enumeraciones disponibles a un StretchImage.

En la imagen siguiente se muestra la salida del ejemplo y se muestra el efecto que tiene la configuración diferente Stretch cuando se aplica a una imagen.

Diferentes configuraciones de estiramiento

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://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>

Pintar con imágenes

Las imágenes también se pueden mostrar en una aplicación pintando con un Brush. Los pinceles permiten pintar objetos de interfaz de usuario con cualquier cosa, desde colores simples y sólidos hasta conjuntos complejos de patrones e imágenes. Para pintar con imágenes, use un ImageBrush. Es ImageBrush un tipo de TileBrush que define su contenido como una imagen de mapa de bits. Un ImageBrush muestra una sola imagen, que se especifica mediante su propiedad ImageSource. Puede controlar cómo la imagen está estirada, alineada y en mosaico, lo que le permite evitar la distorsión y producir patrones y otros efectos. En la ilustración siguiente se muestran algunos efectos que se pueden lograr con un ImageBrush.

Los pinceles de imagen pueden rellenar formas, controles, texto y mucho más

En el ejemplo siguiente se muestra cómo pintar el fondo de un botón con una imagen mediante .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>

Para obtener información adicional sobre ImageBrush y cómo pintar imágenes, vea Pintura con imágenes, dibujos y objetos visuales.

Metadatos de imagen

Algunos archivos de imagen contienen metadatos que describen el contenido o las características del archivo. Por ejemplo, la mayoría de las cámaras digitales crean imágenes que contienen metadatos sobre la marca y el modelo de la cámara usada para capturar la imagen. Cada formato de imagen controla los metadatos de forma diferente, pero WPF Imaging proporciona una manera uniforme de almacenar y recuperar metadatos para cada formato de imagen compatible.

El acceso a los metadatos se proporciona a través de la Metadata propiedad de un BitmapSource objeto . Metadata devuelve un BitmapMetadata objeto que incluye todos los metadatos contenidos en la imagen. Estos datos pueden estar en un esquema de metadatos o en una combinación de esquemas diferentes. WpF Imaging admite los siguientes esquemas de metadatos de imagen: Archivo de imagen intercambiable (Exif), tEXt (datos textuales PNG), directorio de archivos de imagen (IFD), International Press Telecommunications Council (IPTC) y Extensible Metadata Platform (XMP).

Para simplificar el proceso de lectura de metadatos, BitmapMetadata proporciona varias propiedades con nombre a las que se puede acceder fácilmente, como Author, Titley CameraModel. Muchas de estas propiedades con nombre también se pueden usar para escribir metadatos. El lector de consultas de metadatos proporciona compatibilidad adicional para leer metadatos. El GetQuery método se usa para recuperar un lector de consultas de metadatos proporcionando una consulta de cadena como "/app1/exif/". En el ejemplo siguiente, GetQuery se usa para obtener el texto almacenado en la ubicación "/Text/Description ".

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

// 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.
Dim myTextBlock As New TextBlock()
myTextBlock.Text = "The Description metadata of this image is: " + pngInplace.GetQuery("/Text/Description").ToString()

Para escribir metadatos, se usa un escritor de consultas de metadatos. SetQuery obtiene el generador de consultas y establece el valor deseado. En el ejemplo siguiente, SetQuery se usa para escribir el texto almacenado en la ubicación "/Text/Description".

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

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

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

Extensibilidad de códecs

Una característica principal de la creación de imágenes de WPF es el modelo de extensibilidad para los nuevos códecs de imagen. Estas interfaces no administradas permiten a los desarrolladores de códecs integrar códecs con WPF para que las aplicaciones WPF puedan usar automáticamente nuevos formatos de imagen.

Para obtener un ejemplo de la API de extensibilidad, consulta el códec de ejemplo win32. En este ejemplo se muestra cómo crear un descodificador y un codificador para un formato de imagen personalizado.

Consulte también

• BitmapSource
• BitmapImage
• Image
• BitmapMetadata
• Imágenes y gráficos 2D
• Códec de ejemplo win32