Freigeben über

Übersicht über die Bildverarbeitung

  • Artikel

Dieses Thema bietet eine Einführung in Microsoft Windows Presentation Foundation Imaging Component. WPF Imaging ermöglicht Entwicklern, Bilder anzuzeigen, zu transformieren und zu formatieren.

Dieses Thema enthält folgende Abschnitte.

  • WPF Imaging-Komponente
  • WPF-Bildformate
  • Anzeigen von Bildern in WPF
  • Metadaten von Bildern
  • Erweiterbarkeit der Codecs
  • Verwandte Abschnitte

WPF Imaging-Komponente

WPF Imaging stellt erheblich erweiterte Bildverarbeitungsfunktionen in Microsoft Windows bereit. Bildverarbeitungsfunktionen, wie z. B. die Anzeige einer Bitmap oder die Verwendung eines Bilds in einem allgemeinen Steuerelement, basierten in der Vergangenheit auf der Microsoft Windows Graphics Device Interface (GDI) oder auf Microsoft Windows GDI+-Bibliotheken. Diese APIs stellen Baseline-Bildverarbeitungsfunktionen bereit, verfügen jedoch nicht über Features wie die Unterstützung von Codec-Erweiterbarkeit und hochwertigen Bildern. WPF Imaging wurde entworfen, um die Nachteile von GDI und GDI+ zu beheben und einen neuen Satz von APIs bereitzustellen, um Bilder in den Anwendungen anzuzeigen und zu verwenden.

Für den Zugriff auf die WPF Imaging API stehen zwei Möglichkeiten zur Verfügung: eine verwaltete Komponente und eine nicht verwaltete Komponente. Die nicht verwaltete Komponente stellt die folgenden Features bereit.

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

  • Leistungsverbesserung und erhöhte Sicherheit für systemeigene Bildformate, 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 Symbol (.ico).

  • Erhaltung von Bilddaten mit einer hohen Bittiefe von bis zu 8 Bits pro Kanal (32 Bits pro Pixel).

  • Nicht destruktives Bildskalieren, Zuschneiden und Drehungen.

  • Vereinfachte Farbverwaltung.

  • Unterstützung für in der Datei enthaltene proprietäre Metadaten.

  • Die verwaltete Komponente nutzt die nicht verwaltete Infrastruktur, um eine nahtlose Integration von Bildern mit anderen WPF-Funktionen, z. B. user interface (UI), Animation und Grafiken, bereitzustellen. Die verwaltete Komponente profitiert außerdem vom Codec-Erweiterbarkeitsmodell der Bildverarbeitung in Windows Presentation Foundation (WPF), was eine automatische Erkennung von neuen Bildformaten in WPF-Anwendungen ermöglicht.

Der Großteil der verwalteten WPF Imaging API befindet sich im System.Windows.Media.Imaging-Namespace, auch wenn einige wichtigen Typen, z. B. ImageBrush und ImageDrawing, im System.Windows.Media-Namespace enthalten sind und Image sich im System.Windows.Controls-Namespace befindet.

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

WPF-Bildformate

Ein Codec wird zum Decodieren und Codieren eines bestimmten Medienformats verwendet. WPF Imaging enthält einen Codec für die Bildformate BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF und ICON. Anhand eines jeden einzelnen Codecs können Anwendungen das entsprechende Bildformat decodieren und (mit Ausnahme von ICON) codieren.

BitmapSource ist für das Decodieren und Codieren von Bildern eine wichtige Klasse. Sie 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. Eine BitmapSource kann ein einzelner Rahmen eines Bilds mit mehreren Rahmen oder das Ergebnis einer Transformation sein, die auf eine BitmapSource ausgeführt wurde. Sie stellt die übergeordnete Klasse für viele der primären Klassen dar, die in der Bildverarbeitung von WPF verwendet werden, z. B. BitmapFrame.

Ein BitmapFrame wird verwendet, um die tatsächlichen Bitmapdaten eines Bildformats zu speichern. Viele Bildformate unterstützen lediglich einen einzelnen BitmapFrame, wenngleich Formate wie GIF und TIFF mehrere Rahmen pro Bild unterstützen. Rahmen werden von Decodern als Eingabedaten verwendet und zur Erstellung der Bilddateien an die Encoder übergeben.

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

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

Decodieren von Bildformaten

Beim Decodieren von Bildern wird das Bildformat in Bilddaten übersetzt, 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. Der Codec wird automatisch ausgewählt, wenn kein bestimmter Decoder angegeben wird. Die Beispiele im Abschnitt Anzeigen von Bildern in WPF veranschaulichen die automatische Decodierung. Decoder für benutzerdefinierte Formate, die mithilfe der nicht verwalteten WPF Imaging-Schnittstellen entwickelt wurden und im System registriert sind, werden automatisch in die Decoderauswahl eingebunden. Auf diese Weise können benutzerdefinierte Formate automatisch in WPF-Anwendungen angezeigt werden.

Im folgenden Beispiel wird die Verwendung eines Bitmapdecoders veranschaulicht, um ein Bild im BMP-Format zu decodieren.

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

Codieren von Bildformaten

Bei der Bildcodierung werden Bilddaten in ein bestimmtes Bildformat übersetzt. Die codierten Bilddaten können dann zur Erstellung neuer Bilddateien verwendet werden. WPF Imaging stellt Encoder für jedes der oben beschriebenen Bildformate bereit.

Im folgenden Beispiel wird die Verwendung eines Encoders veranschaulicht, um ein neu erstelltes Bitmapbild zu speichern.

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

Anzeigen von Bildern in WPF

Es gibt mehrere Möglichkeiten, um in einer Windows Presentation Foundation (WPF)-Anwendung ein Bild anzuzeigen. Bilder können mit einem Image-Steuerelement angezeigt, mit einem ImageBrush auf ein visuelles Element gemalt oder mit ImageDrawing gezeichnet werden.

Verwenden des Image-Steuerelements

Image ist ein Frameworkelement und das Hauptverfahren zur Anzeige von Bildern in Anwendungen. In XAML kann Image auf zwei Arten verwendet werden, mit Attributsyntax oder Eigenschaftensyntax. Das folgende Beispiel zeigt, wie ein Bild auf eine Breite von 200 Pixel gerendert wird. Dabei wird sowohl die Attribut- als auch die Eigenschaftensyntax verwendet. 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 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>

Viele der Beispiele verwenden ein BitmapImage-Objekt, um auf eine Bilddatei zu verweisen. BitmapImage ist eine spezielle BitmapSource, die für das Laden von Extensible Application Markup Language (XAML) optimiert wurde und eine einfache Möglichkeit bietet, Bilder als Source eines Image-Steuerelements anzuzeigen.

Das folgende Beispiel zeigt, wie ein Bild auf eine Breite von 200 Pixel mithilfe von Code gerendert wird.

HinweisHinweis

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

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

Drehen, Konvertieren und Zuschneiden von Bildern

WPF ermöglicht es den Benutzern, Bilder mithilfe der Eigenschaften von BitmapImage oder durch die Verwendung zusätzlicher BitmapSource-Objekte, z. B. CroppedBitmap oder FormatConvertedBitmap, zu transformieren. Diese Bildtransformationen skalieren und drehen Bilder, ändern das Pixelformat von Bildern oder schneiden ein Bild zu.

Das Drehen von Bildern wird mithilfe der Rotation-Eigenschaft von BitmapImage ausgeführt. Drehungen können nur in 90-Grad-Schritten vorgenommen werden. 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.
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;

Die Bildkonvertierung in ein anderes Pixelformat, z. B. in eine Graustufe, erfolgt mit FormatConvertedBitmap. In den folgenden Beispielen wird ein Bild in die Graustufe Gray4 konvertiert.

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

Um ein Bild zuzuschneiden, kann entweder die Clip-Eigenschaft von Image oder CroppedBitmap verwendet werden. Wenn Sie nur einen Bildbereich anzeigen möchten, sollte in der Regel Clip verwendet werden. Wenn Sie ein zugeschnittenes Bild codieren und speichern müssen, sollte CroppedBitmap verwendet werden. Im folgenden Beispiel wird mithilfe der Clip-Eigenschaft und einer EllipseGeometry ein Bild 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
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;

Dehnen von Bildern

Die Stretch-Eigenschaft steuert, wie ein Bild auf den Füllbereich seines Containers ausgedehnt wird. Die Stretch-Eigenschaft akzeptiert die folgenden Werte, die von der Stretch-Enumeration definiert werden:

  • None: Das Bild wird nicht auf den möglichen Füllbereich des Ausgabebereichs ausgedehnt. Wenn das Bild größer als der Ausgabebereich ist, wird es in den Ausgabebereich gezogen, und alle überstehenden Bereiche werden abgeschnitten.

  • Fill: Das Bild wird auf die Größe des Ausgabebereichs skaliert. Da die Bildhöhe und -breite unabhängig voneinander skaliert werden, wird das ursprüngliche Seitenverhältnis des Bilds möglicherweise nicht beibehalten. Dies bedeutet, dass das Bild möglicherweise verzerrt wird, um den Ausgabecontainer vollständig auszufüllen.

  • Uniform: Das Bild wird so skaliert, dass es im Ausgabebereich komplett angezeigt werden kann. Das Seitenverhältnis des Bilds wird beibehalten.

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

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

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

Unterschiedliche Stretch-Einstellungen

Unterschiedliche TileBrush-Dehneinstellungen

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

Zeichnen mit Bildern

Bilder können auch in einer Anwendung angezeigt werden, indem man sie mit einem Brush zeichnet. Mithilfe von Pinseln können Sie UI-Objekte, angefangen von einfachen Objekten, über Objekte in Volltonfarbe bis hin zu Objekten mit komplexen Mustern und Bildern, zeichnen. Um mit Bildern zu zeichnen, verwenden Sie einen ImageBrush. Ein ImageBrush ist ein TileBrush-Typ, der seinen Inhalt als Bitmapbild definiert. Mit ImageBrush wird ein einzelnes Bild angezeigt, das über die ImageSource-Eigenschaft angegeben wird. Sie können steuern, wie das Bild gedehnt, angeordnet und gekachelt wird. Auf diese Weise können Sie Zerrungen verhindern und Muster sowie andere Effekte herstellen. Die folgende Illustration zeigt einige Effekte, die mit einem ImageBrush erreicht werden können.

Bildpinsel können u. a. Formen, Steuerelemente und Text ausfüllen

ImageBrush-Ausgabebeispiele

Im folgenden Beispiel wird gezeigt, wie mit einem ImageBrush ein Bild als Hintergrund einer Schaltfläche 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 über ImageBrush und das Zeichnen von Bildern finden Sie unter Zeichnen mit Bildern, Zeichnungen und visuellen Elementen.

Metadaten von Bildern

Einige Bilddateien enthalten Metadaten, die den Inhalt oder die Eigenschaften der Datei beschreiben. Beispielsweise erstellen die meisten digitalen Kameras Bilder, die Metadaten zum Fabrikat und zum Modell der Kamera enthalten, mit der das Bild aufgenommen wurde. Jedes Bildformat behandelt Metadaten auf eine andere Weise. WPF Imaging bietet hingegen eine einheitliche Möglichkeit, um Metadaten für jedes unterstützte Bildformat zu speichern und abzurufen.

Der Zugriff auf Metadaten wird durch die Metadata-Eigenschaft eines BitmapSource-Objekts bereitgestellt. Metadata gibt ein BitmapMetadata-Objekt zurück, das alle im Bild enthaltenen Metadaten enthält. Diese Daten können in einem Metadatenschema oder in einer Kombination aus unterschiedlichen Schemas vorliegen. WPF Imaging unterstützt die folgenden Schemas für Bildmetadaten: Exchangeable image file (Exif), tEXt (PNG-Textdaten), image file directory (IFD), International Press Telecommunications Council (IPTC) und Extensible Metadata Platform (XMP).

Um den Vorgang zum Lesen von Metadaten zu vereinfachen, stellt BitmapMetadata mehrere benannte und einfach abzurufende Eigenschaften bereit, dazu gehören Author, Title und CameraModel. Viele dieser benannten Eigenschaften können auch zum Schreiben von Metadaten verwendet werden. Zusätzliche Unterstützung zum Lesen von Metadaten bietet der Metadaten-Abfragereader. Die GetQuery-Methode wird zum Aufrufen eines Metadaten-Abfragereaders verwendet, indem eine Zeichenfolgenabfrage, z. B. "/app1/exif/" bereitgestellt wird. Im folgenden Beispiel wird GetQuery verwendet, um den unter "/Text/Description" gespeicherten Text abzufragen.

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

Zum Schreiben von Metadaten wird ein Metadaten-Abfragewriter verwendet. SetQuery ruft den Abfragewriter ab und legt den gewünschten Wert fest. Im folgenden Beispiel wird SetQuery verwendet, um den unter "/Text/Description" gespeicherten Text zu schreiben.

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

Erweiterbarkeit der Codecs

Ein Kernfeature von WPF Imaging ist das Erweiterbarkeitsmodell für neue Bildcodecs. Mit diesen nicht verwalteten Schnittstellen können Codec-Entwickler den Codec in WPF integrieren, sodass neue Bildformate von WPF-Anwendungen automatisch verwendet werden können.

Ein Beispiel für die Erweiterbarkeits-API finden Sie unter Win32-Beispielcodec. In diesem Beispiel wird veranschaulicht, wie ein Decoder und ein Encoder für ein benutzerdefiniertes Bildformat erstellt werden.

HinweisHinweis

Der Codec muss digital signiert werden, damit das System ihn erkennt.

Siehe auch

Referenz

BitmapSource

BitmapImage

Image

BitmapMetadata

Konzepte

Optimieren der Leistung: 2D-Grafiken und Bildverarbeitung

Weitere Ressourcen

Win32-Beispielcodec