Delen via

Overzicht van beeldvorming

  • Artikel

Dit onderwerp bevat een inleiding tot het Microsoft Windows Presentation Foundation Imaging-onderdeel. MET WPF Imaging kunnen ontwikkelaars afbeeldingen weergeven, transformeren en opmaken.

WPF Beeldverwerkingscomponent

WPF Imaging biedt aanzienlijke verbeteringen in de mogelijkheden voor imaging in Microsoft Windows. Imaging-mogelijkheden, zoals het weergeven van een bitmap of het gebruik van een afbeelding op een gemeenschappelijk besturingselement, waren eerder afhankelijk van de Microsoft Windows Graphics Device Interface (GDI) of Microsoft Windows GDI+-bibliotheken. Deze API biedt basislijnafbeeldingsfunctionaliteit, maar ontbreekt aan functies zoals ondersteuning voor codec-uitbreidbaarheid en ondersteuning voor afbeeldingen met hoge kwaliteit. WPF Imaging is ontworpen om de tekortkomingen van GDI en GDI+ te overwinnen en een nieuwe set API te bieden voor het weergeven en gebruiken van afbeeldingen in uw toepassingen.

Er zijn twee manieren om toegang te krijgen tot de WPF Imaging-API, een beheerd onderdeel en een niet-beheerd onderdeel. Het niet-beheerde onderdeel biedt de volgende functies.

  • Uitbreidbaarheidsmodel voor nieuwe of bedrijfseigen afbeeldingsindelingen.

  • Verbeterde prestaties en beveiliging van systeemeigen afbeeldingsindelingen, waaronder bitmap (BMP), Joint Photographics Experts Group (JPEG), Portable Network Graphics (PNG), Tiff (Tagged Image File Format), Microsoft Windows Media Photo, Graphics Interchange Format (GIF) en pictogram (.ico).

  • Behoud van afbeeldingsgegevens met een hoge bitdiepte tot 8 bits per kanaal (32 bits per pixel).

  • Niet-destructieve schaalaanpassing van afbeeldingen, bijsnijding en rotaties.

  • Vereenvoudigd kleurenbeheer.

  • Ondersteuning voor in-file, eigen metagegevens.

  • Het beheerde onderdeel maakt gebruik van de onbeheerde infrastructuur om naadloze integratie van afbeeldingen te bieden met andere WPF-functies, zoals gebruikersinterfaces, animatie en afbeeldingen. Het beheerde onderdeel profiteert ook van het WPF-model (Windows Presentation Foundation) voor het uitbreidbaar maken van codecs, waardoor automatische herkenning van nieuwe afbeeldingsindelingen in WPF-toepassingen mogelijk is.

Het merendeel van de beheerde WPF Imaging-API bevindt zich in de System.Windows.Media.Imaging naamruimte, hoewel verschillende belangrijke typen, zoals ImageBrush en ImageDrawing zich in de System.Windows.Media naamruimte bevinden en Image zich in de System.Windows.Controls naamruimte bevindt.

Dit onderwerp bevat aanvullende informatie over het beheerde onderdeel. Zie de documentatie Unmanaged WPF Imaging Component voor meer informatie over de niet-beheerde API.

WPF-afbeeldingsindelingen

Een codec wordt gebruikt om een specifieke media-indeling te decoderen of te coderen. WPF Imaging bevat een codec voor afbeeldingsindelingen BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF en ICON. Elk van deze codecs stelt toepassingen in staat om te decoderen en, met uitzondering van ICON, hun respectieve afbeeldingsindelingen te coderen.

BitmapSource is een belangrijke klasse die wordt gebruikt bij het decoderen en coderen van afbeeldingen. Het is de basisbouwsteen van de WPF Imaging-pijplijn en vertegenwoordigt één, constante set pixels op een bepaalde grootte en resolutie. Een BitmapSource kan een afzonderlijk frame van een afbeelding met meerdere frames zijn, of het kan het resultaat zijn van een transformatie die wordt uitgevoerd op een BitmapSource. Het is de ouder van veel van de primaire klassen die worden gebruikt in WPF-imaging zoals BitmapFrame.

Een BitmapFrame wordt gebruikt om de werkelijke bitmapgegevens van een afbeeldingsformaat op te slaan. Veel afbeeldingsindelingen ondersteunen slechts één BitmapFrame, hoewel indelingen zoals GIF en TIFF meerdere frames per afbeelding ondersteunen. Frames worden door decoders gebruikt als invoergegevens en worden doorgegeven aan encoders om afbeeldingsbestanden te maken.

In het volgende voorbeeld ziet u hoe een BitmapFrame wordt gemaakt op basis van een BitmapSource en vervolgens wordt toegevoegd aan een TIFF-afbeelding.

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)

Decoderen van afbeeldingsopmaak

Afbeeldingscodering is de vertaling van een afbeeldingsindeling naar afbeeldingsgegevens die door het systeem kunnen worden gebruikt. De afbeeldingsgegevens kunnen vervolgens worden gebruikt om weer te geven, verwerken of te coderen naar een ander formaat. Decoderselectie is gebaseerd op de afbeeldingsindeling. Codecselectie is automatisch, tenzij er een specifieke decoder is opgegeven. In de voorbeelden in de sectie Afbeeldingen weergeven in WPF wordt automatisch decoderen gedemonstreerd. Decoders voor aangepaste indelingen die zijn ontwikkeld met behulp van de niet-beheerde WPF Imaging-interfaces en die zijn geregistreerd bij het systeem, nemen automatisch deel aan decoderselectie. Hierdoor kunnen aangepaste indelingen automatisch worden weergegeven in WPF-toepassingen.

In het volgende voorbeeld ziet u hoe u een bitmapdecoder gebruikt om een BMP-indelingsafbeelding te decoderen.


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

Afbeeldingsformaatcodering

Codering van afbeeldingen is de omzetting van afbeeldingsgegevens naar een specifiek afbeeldingsformaat. De gecodeerde afbeeldingsgegevens kunnen vervolgens worden gebruikt om nieuwe afbeeldingsbestanden te maken. WPF Imaging biedt coderingsprogramma's voor elk van de hierboven beschreven afbeeldingsindelingen.

In het volgende voorbeeld ziet u hoe u een encoder gebruikt om een zojuist gemaakte bitmapafbeelding op te slaan.

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)

Afbeeldingen weergeven in WPF

Er zijn verschillende manieren om een afbeelding weer te geven in een WPF-toepassing (Windows Presentation Foundation). Afbeeldingen kunnen worden weergegeven met behulp van een Image controle, geschilderd op een visual met behulp van een ImageBrush, of getekend met behulp van een ImageDrawing.

Het gebruik van de afbeeldingcontrole

Image is een frameworkelement en de primaire manier om afbeeldingen weer te geven in toepassingen. In XAML kan Image op twee manieren worden gebruikt; syntaxis van kenmerk of syntaxis van eigenschap. In het volgende voorbeeld ziet u hoe u een afbeelding van 200 pixels breed weergeeft met zowel de syntaxis van kenmerken als de syntaxis van de eigenschapstag. Zie Overzicht van afhankelijkheidseigenschappenvoor meer informatie over de syntaxis van kenmerken en de syntaxis van de eigenschap.

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

Veel van de voorbeelden gebruiken een BitmapImage-object om te verwijzen naar een afbeeldingsbestand. BitmapImage is een gespecialiseerde BitmapSource die is geoptimaliseerd voor het laden van Extensible Application Markup Language (XAML) en biedt een eenvoudige manier om afbeeldingen weer te geven als de Source van een Image besturingselement.

In het volgende voorbeeld ziet u hoe u een afbeelding van 200 pixels breed weergeeft met behulp van code.

Notitie

BitmapImage implementeert de ISupportInitialize interface om initialisatie op meerdere eigenschappen te optimaliseren. Wijzigingen in eigenschappen kunnen alleen optreden tijdens het initialiseren van objecten. Roep BeginInit aan om aan te geven dat initialisatie is gestart en EndInit om aan te geven dat initialisatie is voltooid. Nadat de eigenschap is geïnitialiseerd, worden eigenschapswijzigingen genegeerd.

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

Afbeeldingen draaien, converteren en bijsnijden

MET WPF kunnen gebruikers afbeeldingen transformeren met behulp van eigenschappen van BitmapImage of met behulp van extra BitmapSource objecten zoals CroppedBitmap of FormatConvertedBitmap. Met deze afbeeldingstransformaties kunt u een afbeelding schalen of draaien, de pixelindeling van een afbeelding wijzigen of een afbeelding bijsnijden.

Afbeeldingsrotaties worden uitgevoerd met behulp van de eigenschap Rotation van BitmapImage. Rotaties kunnen alleen in stappen van 90 graden worden uitgevoerd. In het volgende voorbeeld wordt een afbeelding 90 graden gedraaid.

<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

Het converteren van een afbeelding naar een andere pixelindeling, zoals grijswaarden, wordt uitgevoerd met behulp van FormatConvertedBitmap. In de volgende voorbeelden wordt een afbeelding geconverteerd naar 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

Als u een afbeelding wilt bijsnijden, kunt u de eigenschap Clip van Image of CroppedBitmap gebruiken. Als u alleen een deel van een afbeelding wilt weergeven, moet Clip worden gebruikt. Als u een bijgesneden afbeelding moet coderen en opslaan, moet de CroppedBitmap worden gebruikt. In het volgende voorbeeld wordt een afbeelding bijgesneden met behulp van de Clip-eigenschap met een 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

Afbeeldingen uitrekken

De eigenschap Stretch bepaalt hoe een afbeelding wordt uitgerekt om de container te vullen. De eigenschap Stretch accepteert de volgende waarden, gedefinieerd door de opsomming Stretch:

  • None: De afbeelding wordt niet uitgerekt om het uitvoergebied te vullen. Als de afbeelding groter is dan het uitvoergebied, wordt de afbeelding binnen het uitvoergebied geplaatst en worden de delen die niet passen afgesneden.

  • Fill: de afbeelding wordt geschaald zodat deze past bij het uitvoergebied. Omdat de hoogte en breedte van de afbeelding onafhankelijk van elkaar worden geschaald, blijft de oorspronkelijke hoogte-breedteverhouding van de afbeelding mogelijk niet behouden. Dat wil zeggen dat het beeld vervormd kan worden om de uitvoercontainer volledig te vullen.

  • Uniform: de afbeelding wordt geschaald zodat deze volledig binnen het uitvoergebied past. De hoogte-breedteverhouding van de afbeelding blijft behouden.

  • UniformToFill: de afbeelding wordt geschaald, zodat het uitvoergebied volledig wordt gevuld met behoud van de oorspronkelijke hoogte-breedteverhouding van de afbeelding.

In het volgende voorbeeld wordt elk van de beschikbare Stretch opsommingen toegepast op een Image.

In de volgende afbeelding ziet u de uitvoer uit het voorbeeld en ziet u de invloed die de verschillende Stretch instellingen hebben wanneer deze worden toegepast op een afbeelding.

Verschillende TileBrush Stretch-instellingen
Verschillende stretch-instellingen

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

Schilderen met afbeeldingen

Afbeeldingen kunnen ook worden weergegeven in een toepassing door te schilderen met een Brush. Met penselen kunt u UI-objecten schilderen met alles van eenvoudige, effen kleuren tot complexe sets patronen en afbeeldingen. Als u met afbeeldingen wilt schilderen, gebruikt u een ImageBrush. Een ImageBrush is een type TileBrush dat de inhoud definieert als bitmapafbeelding. Een ImageBrush één afbeelding weergeeft, die is opgegeven door de eigenschap ImageSource. U kunt bepalen hoe de afbeelding wordt uitgerekt, uitgelijnd en betegeld, zodat u vervorming kunt voorkomen en patronen en andere effecten kunt produceren. In de volgende afbeelding ziet u enkele effecten die kunnen worden bereikt met een ImageBrush.

ImageBrush-uitvoervoorbeelden
Afbeeldingsborstels kunnen vormen, besturingselementen, tekst en meer vullen

In het volgende voorbeeld ziet u hoe u de achtergrond van een knop kunt schilderen met een afbeelding met behulp van een 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>

Zie Schilderij met afbeeldingen, tekeningen en visualsvoor meer informatie over ImageBrush en schilderijafbeeldingen.

Metagegevens van afbeelding

Sommige afbeeldingsbestanden bevatten metagegevens die de inhoud of de kenmerken van het bestand beschrijven. De meeste digitale camera's maken bijvoorbeeld afbeeldingen die metagegevens bevatten over het merk en model van de camera die wordt gebruikt om de afbeelding vast te leggen. Elke afbeeldingsindeling verwerkt metagegevens anders, maar WPF Imaging biedt een uniforme manier om metagegevens op te slaan en op te halen voor elke ondersteunde afbeeldingsindeling.

Toegang tot metagegevens wordt geboden via de eigenschap Metadata van een BitmapSource-object. Metadata retourneert een BitmapMetadata-object dat alle metagegevens bevat die zijn opgenomen in de afbeelding. Deze gegevens kunnen zich in één metagegevensschema of een combinatie van verschillende schema's bevinden. WPF Imaging ondersteunt de volgende schema's voor metagegevens van afbeeldingen: Exchangeable image file (Exif), tEXt (PNG Textual Data), image file directory (IFD), International Press Telecommunications Council (IPTC) en Extensible Metadata Platform (XMP).

Om het leesproces van metagegevens te vereenvoudigen, biedt BitmapMetadata verschillende benoemde eigenschappen die gemakkelijk toegankelijk zijn, zoals Author, Titleen CameraModel. Veel van deze benoemde eigenschappen kunnen ook worden gebruikt om metagegevens te schrijven. Aanvullende ondersteuning voor het lezen van metagegevens wordt geleverd door de metagegevensquerylezer. De methode GetQuery wordt gebruikt om een metagegevensquerylezer op te halen door een tekenreeksquery op te geven, zoals '/app1/exif/'-. In het volgende voorbeeld wordt GetQuery gebruikt om de tekst op te halen die is opgeslagen in de '/Tekst/beschrijving' locatie.


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

Voor het schrijven van metagegevens wordt een schrijver voor metagegevensquery's gebruikt. SetQuery verkrijgt de querygenerator en stelt de gewenste waarde in. In het volgende voorbeeld wordt SetQuery gebruikt om de tekst te schrijven die is opgeslagen in de '/Tekst/beschrijving' locatie.

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

Een kernfunctie van WPF Imaging is het uitbreidbaarheidsmodel voor nieuwe afbeeldingscodecs. Met deze niet-beheerde interfaces kunnen codecontwikkelaars codecs integreren met WPF, zodat nieuwe afbeeldingsindelingen automatisch kunnen worden gebruikt door WPF-toepassingen.

Zie de Win32 Sample Codecvoor een voorbeeld van de uitbreidbaarheids-API. Dit voorbeeld laat zien hoe u een decoder en encoder kunt maken voor een aangepaste afbeeldingsindeling.

Notitie

De codec moet digitaal worden ondertekend om het systeem te kunnen herkennen.

Zie ook