Información general sobre imágenes

  • Artículo

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 capacidades de creación de imágenes dentro de Microsoft Windows. Las capacidades de creación de imágenes, como mostrar un mapa de bits o usar una imagen en un control común, dependían anteriormente de la Interfaz de dispositivo gráfico de Microsoft Windows (GDI) o las bibliotecas de Microsoft Windows GDI+. Estas API proporcionan funcionalidades de creación de imágenes, pero carecen de algunas características, como la compatibilidad con la extensibilidad de códec y con imágenes de alta fidelidad. La creación de imágenes de WPF se ha diseñado para superar las limitaciones de GDI y GDI+ y proporcionar un nuevo conjunto de API para mostrar y usar imágenes en las aplicaciones.

Existen dos formas de obtener acceso a la API de creación de imágenes de WPF, 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 de propiedad.

  • Rendimiento y seguridad mejorados en formatos de imagen nativos, que incluyen el mapa de bits (BMP), el formato JPEG (Joint Photographic Experts Group), el formato PNG (Portable Network Graphics), el formato TIFF (Tagged Image File Format), Microsoft Windows Media Photo, el formato de intercambio de gráficos (GIF) e icon (.ico).

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

  • Escalado, recorte y giros de imágenes no destructivos.

  • Administración del color simplificada.

  • Compatibilidad con metadatos de propiedad integrados.

  • El componente administrado usa la infraestructura no administrada para proporcionar una integración de imágenes perfecta con otras características de WPF, tales 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ódec de creación de imágenes de Windows Presentation Foundation (WPF) que habilita el reconocimiento automático de nuevos formatos de imagen en aplicaciones de WPF.

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

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 relativa al componente de creación de imágenes de WPF no administrado.

Formatos de imagen de WPF

Un códec se usa para descodificar o codificar un formato de medios específico. La creación de imágenes de WPF incluye un códec para los formatos de imagen BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF e ICON. Cada uno de estos códecs permiten a las aplicaciones descodificar y, con la excepción de ICON, codificar sus formatos de imagen respectivos.

BitmapSource es una clase importante que se utiliza en la descodificación y codificación de imágenes. Es el bloque de creación básico de la canalización de creación de imágenes de WPF y representa un solo conjunto constante de píxeles con un tamaño y resolución determinados. Un BitmapSource puede ser un marco individual de una imagen de varios marcos, 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, tales como BitmapFrame.

Un BitmapFrame se utiliza para almacenar los datos del mapa de bits real de un formato de imagen. Muchos formatos de imagen solo admiten un único elemento BitmapFrame, aunque formatos tales como GIF y TIFF admiten varios marcos por imagen. Los descodificadores usan los marcos como datos de entrada y se pasan a los codificadores para crear archivos de imagen.

En el ejemplo siguiente se demuestra cómo se crea un BitmapFrame a partir de un BitmapSource y, a continuación, 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 formatos de imagen

La descodificación de imágenes es la traslación de un formato de imagen a datos de imagen que el sistema puede usar. Los datos de imagen pueden usarse entonces para mostrar, procesar o codificar en otro formato. 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 indique un descodificador específico. En los ejemplos de la sección Mostrar imágenes en WPF se muestra la descodificación automática. Los descodificadores de formato personalizado desarrollados con las interfaces de creación de imágenes de WPF no administradas y registrados con el sistema, participan automáticamente en la selección del descodificador. Esto permite que los formatos personalizados se muestren automáticamente en aplicaciones de WPF.

En el siguiente ejemplo se muestra el uso de un descodificador de mapa de bits para descodificar una imagen en 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 formatos de imagen

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

En el siguiente ejemplo 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 con un control Image, pintado en un objeto visual mediante un elemento ImageBrush, o dibujado mediante un elemento ImageDrawing.

Usar el 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 formas: sintaxis de atributo o sintaxis de propiedad. En el siguiente ejemplo se muestra cómo representar una imagen de 200 píxeles de ancho mediante la sintaxis de atributo y la sintaxis de etiquetas de propiedad. Para más información sobre la sintaxis de atributo y la sintaxis de propiedad, consulte Información general sobre 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>

En muchos de los ejemplos se usa un objeto BitmapImage para hacer referencia a un archivo de imagen. BitmapImage es un BitmapSource especializado que está optimizado para la carga del lenguaje XAML y es una manera fácil de mostrar imágenes como el Source de un control Image.

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

Nota

BitmapImage implementa la interfaz de ISupportInitialize para optimizar la inicialización en varias propiedades. Los cambios en la propiedad solo se pueden producir durante la inicialización del objeto. Llame a BeginInit para señalar que la inicialización ha empezado y a EndInit para señalar que la inicialización se ha completado. Una vez inicializado, se omiten los cambios en la propiedad.

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

Girar, convertir y recortar imágenes

WPF permite a los usuarios transformar imágenes mediante propiedades de BitmapImage o mediante objetos BitmapSource adicionales, como CroppedBitmap o FormatConvertedBitmap. Dichas transformaciones de imágenes 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 propiedad Rotation de BitmapImage. Estos solo pueden llevarse a cabo en incrementos de 90 grados. En el siguiente ejemplo, una imagen se gira 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 en un formato de píxel diferente, como una escala de grises, se realiza mediante FormatConvertedBitmap. En los ejemplos siguientes, se convierte una imagen a 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, puede usarse la propiedad Clip de Image o bien CroppedBitmap. Normalmente, si solo quiere mostrar parte de una imagen, debe usar Clip. Si necesita codificar y guardar una imagen recortada, debe usar CroppedBitmap. En el siguiente ejemplo, una imagen se recorta mediante la propiedad Clip usando un elemento 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

Ajustar imágenes

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

  • None: la imagen no se ajusta para rellenar el área de salida. Si la imagen es más grande que el área de salida, esta se dibujará en dicha área, recortando lo que no se ajuste.

  • Fill: la imagen se escala para ajustarse al área de salida. Como el alto y el ancho de las imágenes se escalan de forma independiente, podría no conservarse la relación de aspecto original de la imagen. En otras palabras, la imagen podría distorsionarse para rellenar por completo el contenedor de salida.

  • Uniform: la imagen se escala de modo que se ajuste completamente en el área de salida. Se conserva la relación de aspecto de la imagen.

  • UniformToFill: la imagen se escala para rellenar por completo el área de salida, al mismo tiempo que se conserva la relación de aspecto original de la imagen.

En el siguiente ejemplo se aplica cada una de las enumeraciones Stretch disponibles a un elemento Image.

En la siguiente imagen se muestra la salida del ejemplo y se demuestra el efecto que tienen los distintos valores de Stretch al aplicarse a una imagen.

Diferentes valores de Stretch para TileBrush
Diferentes valores de Stretch

<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 imagenes también se pueden mostrar en una aplicación pintando con un elemento Brush. Los pinceles permiten pintar objetos de UI con cualquier cosa, desde colores simples y sólidos hasta conjuntos complejos de patrones e imágenes. Para pintar con imágenes, use ImageBrush. Un ImageBrush es un tipo de TileBrush que define su contenido como una imagen de mapa de bits. Un elemento ImageBrush muestra una única imagen, que se especifica mediante su propiedad ImageSource. Puede controlar cómo se ajusta, alinea y coloca en mosaico la imagen, evitándose de este modo la distorsión y produciéndose patrones y otros efectos. En la siguiente ilustración se muestran algunos efectos que se pueden lograr con un elemento ImageBrush.

Ejemplos de salidas de ImageBrush
Los pinceles de imagen pueden rellenar formas, controles, texto, etc.

En el siguiente ejemplo se muestra cómo pintar el fondo de un botón con una imagen mediante un elemento 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, consulte Pintar con imágenes, dibujos y elementos 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 modelo de la cámara empleada para capturar la imagen. Cada formato de imagen controla los metadatos de forma diferente, pero la creación de imágenes de WPF 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 propiedad Metadata de un objeto BitmapSource. Metadata devuelve un objeto BitmapMetadata que incluye todos los metadatos que contiene la imagen. Estos datos pueden estar en un esquema de metadatos o una combinación de diferentes esquemas. La creación de imágenes WPF admite los esquemas de metadatos de imagen siguientes: 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 los metadatos, BitmapMetadata proporciona varias propiedades con nombre a las que se puede acceder fácilmente, como Author, Title y CameraModel. Muchas de estas propiedades con nombre también se pueden usar para escribir metadatos. El lector de consultas de metadatos proporciona soporte técnico adicional para leer metadatos. El método GetQuery 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 escritor de la consulta 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ódec

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

Para obtener un ejemplo de la API de extensibilidad, consulte Código de ejemplo Win32. En este ejemplo se muestra cómo crear un descodificador y un codificador para un formato de imagen personalizado.

Nota

El códec se debe firmar digitalmente para que el sistema lo reconozca.

Consulte también