Freigeben über

Übersicht über die Bildverarbeitung

  • Artikel

Dieses Thema enthält eine Einführung in die Imaging-Komponente der Microsoft Windows Presentation Foundation. Mit WPF Imaging können Entwickler Bilder anzeigen, transformieren und formatieren.

WPF-Bildverarbeitungskomponente

WPF Imaging bietet signifikante Verbesserungen bei den Bildbearbeitungsfunktionen in Microsoft Windows. Bildgebungsfunktionen, wie das Anzeigen einer Bitmap oder die Verwendung eines Bildes auf einem gemeinsamen Steuerelement, waren zuvor auf die Microsoft Windows Graphics Device Interface (GDI) oder die Microsoft Windows GDI+-Bibliotheken angewiesen. Diese APIs stellen grundlegende Bildverarbeitungsfunktionen bereit, verfügen aber nicht über Features wie die Unterstützung für Codec-Erweiterbarkeit und hochauflösende Bilder. WPF Imaging wurde entwickelt, um die Mängel von GDI und GDI+ zu überwinden und eine neue API bereitzustellen, um Bilder in Ihren Anwendungen anzuzeigen und zu verwenden.

Es gibt zwei Möglichkeiten, auf die WPF-Imaging-API, eine verwaltete Komponente und eine nicht verwaltete Komponente zuzugreifen. Die nicht verwaltete Komponente stellt die folgenden Features bereit.

  • Erweiterbarkeitsmodell für neue oder proprietäre Bildformate.

  • Verbesserte Leistung und Sicherheit bei nativen Bildformaten, einschließlich Bitmap (BMP), Joint Photographics Experts Group (JPEG), Portable Network Graphics (PNG), Tagged Image File Format (TIFF), Microsoft Windows Media Photo, Graphics Interchange Format (GIF) und Symbolen (ICO).

  • Bewahrung von Bilddaten mit hoher Bittiefe bei bis zu 8 Bit pro Kanal (32 Bit pro Pixel).

  • Nichtdestruktives Skalieren, Zuschneiden und Drehen von Bildern

  • Vereinfachte Farbverwaltung.

  • Unterstützung für proprietäre Metadaten in Dateien.

  • Die verwaltete Komponente nutzt die nicht verwaltete Infrastruktur, um eine nahtlose Integration von Bildern mit anderen WPF-Features wie Benutzeroberfläche, Animation und Grafiken zu ermöglichen. Die verwaltete Komponente profitiert auch vom Erweiterbarkeitsmodell der Imaging-Codecs der Windows Presentation Foundation (WPF), das die automatische Erkennung neuer Bildformate in WPF-Anwendungen ermöglicht.

Der Großteil der verwalteten WPF-Imaging-API befindet sich im System.Windows.Media.Imaging Namespace, obwohl mehrere wichtige Typen wie ImageBrush und ImageDrawing sich im System.Windows.Media Namespace befinden und Image sich im System.Windows.Controls-Namespace befinden.

Dieses Thema enthält zusätzliche Informationen zur verwalteten Komponente. Weitere Informationen über die nicht verwaltete API finden Sie in der Dokumentation Nicht verwaltete WPF Bildverarbeitungskomponente.

WPF-Bildformate

Ein Codec wird verwendet, um ein bestimmtes Medienformat zu dekodieren oder zu enkodieren. WPF Imaging enthält einen Codec für BMP-, JPEG-, PNG-, TIFF-, Windows Media-Foto-, GIF- und ICON-Bildformate. Jeder dieser Codecs ermöglicht es Anwendungen, ihre jeweiligen Bildformate zu decodieren und mit Ausnahme von ICON zu enkodieren.

BitmapSource ist eine wichtige Klasse, die beim Decodieren und Codieren von Bildern verwendet wird. Es ist der grundlegende Baustein der WPF Imaging-Pipeline und stellt einen einzelnen, konstanten Satz von Pixeln mit einer bestimmten Größe und Auflösung dar. Ein BitmapSource kann ein einzelner Frame eines Bilds mit mehreren Frames sein, oder das Ergebnis einer an einer BitmapSourceausgeführten Transformation sein. Sie ist das übergeordnete Element vieler der primären Klassen, die in der WPF-Bildverarbeitung verwendet werden, etwa BitmapFrame.

Ein BitmapFrame wird verwendet, um die tatsächlichen Bitmap-Daten eines Bildformats zu speichern. Viele Bildformate unterstützen nur eine einzelne BitmapFrame, obwohl Formate wie GIF und TIFF mehrere Frames pro Bild unterstützen. Frames werden von Decodern als Eingabedaten verwendet und an Encoder übergeben, um Bilddateien zu erstellen.

Im folgenden Beispiel wird veranschaulicht, wie ein BitmapFrame aus einem BitmapSource erstellt und dann einem TIFF-Bild hinzugefügt wird.

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)

Decodieren von Bildformaten

Die Bilddecodierung ist die Übersetzung eines Bildformats in Bilddaten, die vom System verwendet werden können. Die Bilddaten können dann verwendet werden, um das Bild anzuzeigen und zu verarbeiten oder um es in ein anderes Format zu codieren. Die Decoderauswahl basiert auf dem Bildformat. Die Codecauswahl erfolgt automatisch, es sei denn, ein bestimmter Decoder ist angegeben. Die Beispiele im Abschnitt Anzeigen von Bildern in WPF veranschaulichen die automatische Decodierung. Decoder für benutzerdefinierte Formate, die mithilfe der nicht verwalteten WPF-Bildverarbeitungsschnittstellen entwickelt und im System registriert sind, werden automatisch in die Decoderauswahl eingebunden. Dadurch können benutzerdefinierte Formate automatisch in WPF-Anwendungen angezeigt werden.

Das folgende Beispiel veranschaulicht die Verwendung eines Bitmap-Decoders zum Decodieren eines BMP-Formatbilds.


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

Codieren von Bildformaten

Die Bildcodierung ist die Übersetzung von Bilddaten in ein bestimmtes Bildformat. Die codierten Bilddaten können dann zum Erstellen neuer Bilddateien verwendet werden. WPF Imaging stellt Encoder für jedes der oben beschriebenen Bildformate bereit.

Im folgenden Beispiel wird die Verwendung eines Encoders zum Speichern eines neu erstellten Bitmapbilds veranschaulicht.

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)

Anzeigen von Bildern in WPF

Es gibt verschiedene Möglichkeiten zum Anzeigen eines Bilds in einer Windows Presentation Foundation (WPF)-Anwendung. Bilder können mithilfe eines Image-Steuerelements angezeigt, mithilfe eines ImageBrush-Objekts in ein Visual gemalt oder mithilfe eines ImageDrawing-Objekts gezeichnet werden.

Verwenden der Bildsteuerung

Image ist ein Frameworkelement und die primäre Möglichkeit zum Anzeigen von Bildern in Anwendungen. In XAML kann Image auf zwei Arten verwendet werden: entweder als Attributsyntax oder als Eigenschaftssyntax. Das folgende Beispiel zeigt, wie sie ein Bild mit einer Breite von 200 Pixeln mithilfe der Attributsyntax und der Eigenschaftentagssyntax rendern. Weitere Informationen über Attributsyntax und Eigenschaftensyntax finden Sie unter Übersicht über Abhängigkeitseigenschaften.

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

In vielen Beispielen wird ein BitmapImage-Objekt verwendet, um auf eine Bilddatei zu verweisen. BitmapImage ist ein spezialisiertes BitmapSource-Element, das für das Laden von XAML (Extensible Application Markup Language) optimiert ist. Es stellt eine einfache Möglichkeit zum Anzeigen von Bildern als das Source-Objekt eines Image-Steuerelements dar.

Das folgende Beispiel zeigt, wie ein Bild mit Code 200 Pixel breit gerendert wird.

Anmerkung

BitmapImage implementiert die ISupportInitialize-Schnittstelle, um die Initialisierung für mehrere Eigenschaften zu optimieren. Eigenschaftsänderungen können nur während der Objektinitialisierung auftreten. Rufen Sie BeginInit auf, um zu signalisieren, dass die Initialisierung begonnen hat, und EndInit, um zu signalisieren, dass die Initialisierung abgeschlossen ist. Nach der Initialisierung werden Eigenschaftenänderungen ignoriert.

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

Drehen, Konvertieren und Zuschneiden von Bildern

Mit WPF können Benutzer Bilder mithilfe von Eigenschaften von BitmapImage oder mithilfe zusätzlicher BitmapSource Objekte wie CroppedBitmap oder FormatConvertedBitmaptransformieren. Diese Bildtransformationen können ein Bild skalieren oder drehen, das Pixelformat eines Bilds ändern oder ein Bild zuschneiden.

Bilddrehungen werden mithilfe der Rotation-Eigenschaft von BitmapImage ausgeführt. Drehungen können nur in 90-Grad-Schritten erfolgen. Im folgenden Beispiel wird ein Bild um 90 Grad gedreht.

<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

Die Konvertierung eines Bilds in ein anderes Pixelformat, so z. B. Graustufen, erfolgt mithilfe von FormatConvertedBitmap. In den folgenden Beispielen wird ein Bild in Gray4konvertiert.

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

Um ein Bild zuzuschneiden, kann entweder die Clip-Eigenschaft von Image oder CroppedBitmap verwendet werden. Typischerweise sollte Clip verwendet werden, wenn Sie nur einen Teil eines Bildes anzeigen möchten. Wenn Sie ein zugeschnittenes Bild codieren und speichern müssen, verwenden Sie CroppedBitmap. Im folgenden Beispiel wird ein Bild mithilfe der Clip-Eigenschaft über ein EllipseGeometry-Objekt zugeschnitten.

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

Dehnen von Bildern

Die Stretch-Eigenschaft steuert, wie ein Bild gedehnt wird, um seinen Container auszufüllen. Die Stretch-Eigenschaft akzeptiert die folgenden Werte, die durch die Stretch-Aufzählung definiert werden:

  • None: Das Bild wird nicht gedehnt, um den Ausgabebereich zu füllen. Wenn das Bild größer als der Ausgabebereich ist, wird das Bild in den Ausgabebereich gezeichnet, und alle überstehenden Bereiche werden abgeschnitten.

  • Fill: Das Bild wird skaliert, sodass es in den Ausgabebereich passt. Da die Bildhöhe und -breite unabhängig skaliert werden, bleibt das ursprüngliche Seitenverhältnis des Bilds möglicherweise nicht erhalten. Dies bedeutet, dass das Bild möglicherweise verzerrt wird, um den Ausgabecontainer vollständig auszufüllen.

  • Uniform: Das Bild wird skaliert, sodass es vollständig in den Ausgabebereich passt. Das Seitenverhältnis des Bilds wird beibehalten.

  • UniformToFill: Das Bild wird so skaliert, dass es den Ausgabebereich vollständig ausfüllt, und das ursprüngliche Seitenverhältnis des Bildes wird beibehalten.

Im folgenden Beispiel wird jede der verfügbaren Stretch-Enumerationen auf ein Image-Objekt angewendet.

Das folgende Bild zeigt die Ausgabe des Beispiels und veranschaulicht, wie sich die verschiedenen Stretch-Einstellungen auswirken, wenn sie auf ein Bild angewendet werden.

Unterschiedliche TileBrush-Dehneinstellungen
Unterschiedliche Dehneinstellungen

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

Malen mit Bildern

Bilder können auch in einer Anwendung angezeigt werden, indem sie mit einem Brush-Objekt gemalt werden. Pinsel ermöglichen es Ihnen, UI-Objekte mit allem von einfachen, einfarbigen Tönen bis hin zu komplexen Mustern und Bildern zu malen. Um mit Bildern zu malen, verwenden Sie ein ImageBrush-Objekt. Ein ImageBrush ist eine Art von TileBrush, die den Inhalt als Bitmapbild definiert. Ein ImageBrush-Objekt zeigt ein einzelnes Bild an, das durch seine ImageSource-Eigenschaft angegeben ist. Sie können steuern, wie das Bild gedehnt, angeordnet und gekachelt wird. Auf diese Weise können Sie Zerrungen verhindern und Muster und andere Effekte herstellen. Die folgende Illustration zeigt einige Effekte, die mit einem ImageBrush-Objekt erreicht werden können.

ImageBrush-Ausgabebeispiele
Bildpinsel können Formen, Steuerelemente, Text und vieles mehr ausfüllen.

Im folgenden Beispiel wird veranschaulicht, wie ein Bild als Hintergrund einer Schaltfläche mit einem ImageBrush-Objekt gezeichnet wird.

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

Weitere Informationen zu ImageBrush und Malbildern finden Sie unter Malerei mit Bildern, Zeichnungen und visuellen Elementen.

Bildmetadaten

Einige Bilddateien enthalten Metadaten, die den Inhalt oder die Merkmale der Datei beschreiben. Beispielsweise erstellen die meisten Digitalkameras Bilder, die Metadaten über die Marke und das Modell der Kamera enthalten, mit der das Bild aufgenommen wurde. Jedes Bildformat verarbeitet Metadaten unterschiedlich, aber WPF Imaging bietet eine einheitliche Möglichkeit zum Speichern und Abrufen von Metadaten für jedes unterstützte Bildformat.

Der Zugriff auf Metadaten wird über die Metadata-Eigenschaft eines BitmapSource-Objekts bereitgestellt. Metadata gibt ein BitmapMetadata-Objekt zurück, das alle Metadaten enthält, die im Bild enthalten sind. Diese Daten können sich in einem Metadatenschema oder in einer Kombination verschiedener Schemas befinden. WPF Imaging unterstützt die folgenden Bildmetadatenschemas: Exchangeable Image File (Exif), tEXt (PNG Textual Data), Image File Directory (IFD), International Press Telecommunications Council (IPTC) und Extensible Metadata Platform (XMP).

Um das Lesen von Metadaten zu vereinfachen, stellt BitmapMetadata mehrere benannte Eigenschaften bereit, auf die problemlos zugegriffen werden kann, z. B. Author, Titleund CameraModel. Viele dieser benannten Eigenschaften können auch zum Schreiben von Metadaten verwendet werden. Zusätzliche Unterstützung für das Lesen von Metadaten wird vom Metadatenabfrageleser bereitgestellt. Die GetQuery-Methode wird verwendet, um einen Metadatenabfrageleser abzurufen, indem eine Zeichenfolgenabfrage wie "/app1/exif/"bereitgestellt wird. Im folgenden Beispiel wird GetQuery verwendet, um den Text abzurufen, der unter "/Text/Description" gespeichert ist.


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

Zum Schreiben von Metadaten wird ein Metadatenabfrage-Writer verwendet. SetQuery ruft den Abfragewriter ab und legt den gewünschten Wert fest. Im folgenden Beispiel wird SetQuery verwendet, um den Text zu schreiben, der im Speicherort "/Text/Beschreibung" gespeichert ist.

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

Codec-Erweiterbarkeit

Ein Kernfeature von WPF Imaging ist das Erweiterbarkeitsmodell für neue Bildcodecs. Diese nicht verwalteten Schnittstellen ermöglichen Codecentwicklern die Integration von Codecs in WPF, damit neue Bildformate automatisch von WPF-Anwendungen verwendet werden können.

Ein Beispiel für die Erweiterbarkeits-API finden Sie im Win32 Sample Codec. In diesem Beispiel wird veranschaulicht, wie Sie einen Decoder und Encoder für ein benutzerdefiniertes Bildformat erstellen.

Anmerkung

Der Codec muss digital signiert sein, damit es erkannt wird.

Weitere Informationen