Cenni preliminari sulla creazione dell'immagine

Articolo
08/11/2011

In questo argomento viene presentata un'introduzione a Microsoft Windows Presentation Foundation Imaging Component. WPF Imaging consente agli sviluppatori di visualizzare, trasformare e formattare le immagini.

Nel presente argomento sono contenute le seguenti sezioni.

WPF Imaging Component
Formati immagine WPF
Visualizzazione delle immagini in WPF
Metadati delle immagini
Estensibilità dei codec
Argomenti correlati

WPF Imaging Component

WPF Imaging offre miglioramenti significativi nelle funzionalità di creazione dell'immagine in Microsoft Windows. Le funzionalità di creazione dell'immagine, ad esempio la visualizzazione di un'immagine bitmap o l'utilizzo di un'immagine in un controllo comune, si basavano in precedenza sulle librerie Microsoft Windows Graphics Device Interface (GDI) o Microsoft Windows GDI+. Queste API forniscono la funzionalità di creazione dell'immagine di base, ma sono prive di funzioni quali il supporto per l'estensibilità dei codec e per immagini di elevata fedeltà. WPF Imaging è progettato per risolvere i difetti delle interfacce GDI e GDI+ e per fornire un nuovo set di API al fine di visualizzare e utilizzare immagini nelle applicazioni.

Sono disponibili due modi per accedere all'API di WPF Imaging, un componente gestito e un componente non gestito. Il componente non gestito offre le seguenti funzionalità.

Modello di estensibilità per formati immagine nuovi o proprietari.
Prestazioni e sicurezza migliorate per i formati immagine nativi, compresi bitmap (BMP), Joint Photographics Experts Group (JPEG), Portable Network Graphics (PNG), Tagged Image File Format (TIFF), Microsoft Windows Media Photo, Graphics Interchange Format (GIF) e icone (ICO).
Conservazione di dati immagine con elevata profondità in bit fino a 8 bit per canale (32 bit per pixel).
Operazioni di ridimensionamento, ritaglio e rotazione delle immagini non distruttive.
Gestione dei colori semplificata.
Supporto per metadati proprietari nei file.
Il componente gestito utilizza l'infrastruttura non gestita per garantire l'integrazione omogenea delle immagini con altre funzionalità WPF, ad esempio user interface (UI), animazione e grafica. Il componente gestito sfrutta inoltre il modello di estensibilità dei codec per la creazione dell'immagine di Windows Presentation Foundation (WPF) che consente il riconoscimento automatico di nuovi formati immagine nelle applicazioni WPF.

La maggior parte delle API WPF Imaging gestite risiedono nello spazio dei nomi System.Windows.Media.Imaging, anche se numerosi tipi importanti, come ImageBrush e ImageDrawing, risiedono nello spazio dei nomi System.Windows.Media e Image risiede nello spazio dei nomi System.Windows.Controls.

In questo argomento vengono fornite informazioni aggiuntive sul componente gestito. Per ulteriori informazioni sull'API non gestita, vedere la documentazione Unmanaged WPF Imaging Component.

Formati immagine WPF

Un codec viene utilizzato per codificare o decodificare un formato multimediale specifico. WPF Imaging include un codec per i formati immagine BMP, JPEG, PNG, TIFF, Windows Media Photo, GIF e ICON. Ciascuno di questi codec consente alle applicazioni di decodificare e, a eccezione di ICON, codificare i rispettivi formati immagine.

BitmapSource è una classe importante utilizzata nella codifica e decodifica delle immagini. È il blocco predefinito di base della pipeline di WPF Imaging e rappresenta un insieme unico e costante di pixel a determinate dimensione e risoluzione. Un oggetto BitmapSource può essere costituito da un singolo frame di un'immagine a più frame oppure può essere il risultato di una trasformazione eseguita su un oggetto BitmapSource. È l'elemento padre di molte delle classi principali utilizzate nella creazione dell'immagine di WPF, ad esempio BitmapFrame.

BitmapFrame viene utilizzato per archiviare i dati bitmap effettivi di un formato immagine. Molti formati immagine supportano un solo BitmapFrame, anche se formati come GIF e TIFF supportano più frame per immagine. I frame vengono utilizzati dai decodificatori come dati di input e passati ai codificatori per creare file di immagine.

Nell'esempio riportato di seguito un oggetto BitmapFrame viene creato da un oggetto BitmapSource e successivamente aggiunto a un'immagine TIFF.

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

Decodifica dei formati immagine

La decodifica delle immagini è la conversione di un formato immagine in dati immagine che possono essere utilizzati dal sistema. I dati immagine possono quindi essere utilizzati per visualizzare, elaborare o codificare un formato diverso. La selezione del decodificatore si basa sul formato immagine. La selezione del codec è automatica, a meno che non venga specificato un decodificatore specifico. Negli esempi della sezione Visualizzazione delle immagini in WPF viene illustrata la decodifica automatica. I decodificatori di formati personalizzati sviluppati tramite interfacce WPF Imaging non gestite e registrati con il sistema partecipano automaticamente alla selezione del decodificatore. In questo modo è possibile visualizzare automaticamente formati personalizzati nelle applicazioni WPF.

Nell'esempio riportato di seguito viene illustrato l'utilizzo di un decodificatore bitmap per decodificare un'immagine BMP.

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

Codifica dei formati immagine

La codifica delle immagini è la conversione dei dati immagine in un formato immagine specifico. I dati immagine codificati possono quindi essere utilizzati per creare nuovi file di immagine. In WPF Imaging sono disponibili codificatori per ognuno dei formati immagine descritti in precedenza.

Nell'esempio riportato di seguito viene illustrato l'utilizzo di un codificatore per salvare un'immagine bitmap appena creata.

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

Visualizzazione delle immagini in WPF

Esistono diversi modi per visualizzare un'immagine in un'applicazione Windows Presentation Foundation (WPF). Le immagini possono essere visualizzate tramite un controllo Image, disegnate su un elemento visivo tramite un oggetto ImageBrush o disegnate utilizzando ImageDrawing.

Utilizzo del controllo Image

Image è un elemento del framework e rappresenta la principale modalità per visualizzare le immagini nelle applicazioni. In XAML, Image può essere utilizzato in due modi: sintassi degli attributi o sintassi delle proprietà. Nell'esempio riportato di seguito viene illustrato come eseguire il rendering di un'immagine con una larghezza di 200 pixel utilizzando sia la sintassi degli attributi sia la sintassi dei tag delle proprietà. Per ulteriori informazioni sulla sintassi degli attributi e sulla sintassi delle proprietà, vedere Cenni preliminari sulle proprietà di dipendenza.

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

In molti esempi viene utilizzato un oggetto BitmapImage per fare riferimento a un file di immagine. BitmapImage è un oggetto BitmapSource specializzato ottimizzato per il caricamento di Extensible Application Markup Language (XAML) e consente di visualizzare facilmente immagini come proprietà Source di un controllo Image.

Nell'esempio riportato di seguito viene illustrato come eseguire il rendering di un'immagine con una larghezza di 200 pixel mediante codice.

Nota
BitmapImage implementa l'interfaccia di ISupportInitialize per ottimizzare l'inizializzazione su più proprietà.Le modifiche della proprietà possono verificarsi solo durante l'inizializzazione dell'oggetto.Chiamare il metodo BeginInit per segnalare che l'inizializzazione è stata avviata e il metodo EndInit per segnalare che l'inizializzazione è stata completata.Dopo l'inizializzazione, le modifiche della proprietà vengono ignorate.

BitmapImage implementa l'interfaccia di ISupportInitialize per ottimizzare l'inizializzazione su più proprietà.Le modifiche della proprietà possono verificarsi solo durante l'inizializzazione dell'oggetto.Chiamare il metodo BeginInit per segnalare che l'inizializzazione è stata avviata e il metodo EndInit per segnalare che l'inizializzazione è stata completata.Dopo l'inizializzazione, le modifiche della proprietà vengono ignorate.

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

Rotazione, conversione e ritaglio delle immagini

WPF consente agli utenti di trasformare le immagini utilizzando proprietà di BitmapImage oppure oggetti BitmapSource aggiuntivi, quali CroppedBitmap o FormatConvertedBitmap. Queste trasformazioni delle immagini consentono di ridimensionare o ruotare un'immagine, modificarne il formato di pixel o ritagliarla.

Le rotazioni delle immagini vengono eseguite tramite la proprietà Rotation di BitmapImage. Le rotazioni possono essere eseguite solo con incrementi di 90 gradi. Nell'esempio riportato di seguito un'immagine viene ruotata di 90 gradi.

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

La conversione di un'immagine in un diverso formato di pixel, ad esempio le gradazioni di grigio, viene eseguita tramite FormatConvertedBitmap. Negli esempi riportati di seguito un'immagine viene convertita in 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
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;

Per ritagliare un'immagine, è possibile utilizzare la proprietà Clip di Image o di CroppedBitmap. In genere, per visualizzare una parte di un'immagine, è opportuno utilizzare Clip. Se è necessario codificare e salvare un'immagine ritagliata, utilizzare CroppedBitmap. Nell'esempio riportato di seguito, un'immagine viene ritagliata tramite la proprietà Clip utilizzando un oggetto 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
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;

Adattamento delle immagini

La proprietà Stretch controlla la modalità in cui un'immagine viene adattata per riempire il proprio contenitore. La proprietà Stretch accetta i seguenti valori, definiti dall'enumerazione Stretch:

None: l'immagine non viene adattata per riempire l'area di output. Se l'immagine è più grande dell'area di output, viene disegnata nell'area di output tagliando la parte che non è possibile inserire.
Fill: l'immagine viene ridimensionata per adattarsi all'area di output. Poiché l'altezza e la larghezza dell'immagine vengono ridimensionate in modo indipendente, le proporzioni originali dell'immagine potrebbero non essere mantenute. In atri termini, l'immagine potrebbe essere distorta allo scopo di riempire completamente il contenitore di output.
Uniform: l'immagine viene ridimensionata in modo da adattarsi completamente all'area di output. Le proporzioni dell'immagine vengono mantenute.
UniformToFill: l'immagine viene ridimensionata in modo da riempire completamente l'area di output, rispettando al tempo stesso le proporzioni originali dell'immagine.

Nell'esempio riportato di seguito ogni enumerazione di Stretch disponibile viene applicata a un oggetto Image.

Nell'immagine riportata di seguito viene illustrato l'output dell'esempio e l'impatto delle diverse impostazioni di Stretch al momento dell'applicazione a un'immagine.

Impostazioni di adattamento diverse

TileBrush con impostazioni Stretch diverse

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

Disegno con le immagini

Le immagini possono anche essere visualizzate in un'applicazione tramite il disegno con Brush. I pennelli consentono di disegnare oggetti dell'UI utilizzando colori semplici e a tinta unita, ma anche insiemi complessi di modelli e immagini. Per disegnare con le immagini, utilizzare ImageBrush. ImageBrush è un tipo di oggetto TileBrush che definisce il proprio contenuto come immagine bitmap. In un oggetto ImageBrush viene visualizzata una sola immagine, specificata dalla relativa proprietà ImageSource. È possibile controllare il modo in cui l'immagine viene adattata, allineata e affiancata, consentendo all'utente di evitare distorsioni e produrre pattern e altri effetti. Nella figura riportata di seguito vengono illustrati alcuni degli effetti che possono essere ottenuti con ImageBrush.

Tramite i tratti con immagine è possibile riempire forme, controlli, testo e così via

Esempi di output di ImageBrush

Nell'esempio riportato di seguito viene illustrato come disegnare lo sfondo di un pulsante con un'immagine utilizzando 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>

Per ulteriori informazioni su ImageBrush e sul disegno di immagini vedere Disegnare con oggetti Image, Drawing e Visual.

Metadati delle immagini

Alcuni file di immagine contengono metadati che ne descrivono il contenuto o le caratteristiche. Ad esempio, la maggior parte delle fotocamere digitali creano immagini che contengono metadati relativi alla fabbricazione e al modello della fotocamera utilizzata per scattare la fotografia. Ogni formato immagine gestisce i metadati in modo diverso ma WPF Imaging offre un sistema uniforme per archiviare e recuperare i metadati per ogni formato immagine supportato.

L'accesso ai metadati viene fornito tramite la proprietà Metadata di un oggetto BitmapSource. Metadata restituisce un oggetto BitmapMetadata che include tutti i metadati contenuti nell'immagine. Questi dati possono essere contenuti in uno schema di metadati o in una combinazione di schemi diversi. WPF Imaging supporta i seguenti schemi di metadati di immagine: Exchangeable image file (Exif), tEXt (dati testuali PNG), image file directory (IFD), International Press Telecommunications Council (IPTC) e Extensible Metadata Platform (XMP).

Per semplificare il processo di lettura dei metadati, BitmapMetadata fornisce diverse proprietà denominate facilmente accessibili, ad esempio Author, Title e CameraModel. È inoltre possibile utilizzare molte di queste proprietà denominate per scrivere metadati. Il lettore di query dei metadati offre supporto aggiuntivo per la lettura dei metadati. Il metodo GetQuery viene utilizzato per recuperare un lettore di query dei metadati fornendo una query di stringa come "/app1/exif/". Nell'esempio riportato di seguito, viene utilizzato GetQuery per ottenere il testo archiviato nel percorso "/Text/Description".

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

Per scrivere metadati, viene utilizzato un writer di query dei metadati. Tramite SetQuery viene ottenuto il writer di query e impostato il valore desiderato. Nell'esempio riportato di seguito, viene utilizzato SetQuery per scrivere il testo archiviato nel percorso "/Text/Description".

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

Estensibilità dei codec

Una funzionalità fondamentale di WPF Imaging è il modello di estensibilità per i codec di nuove immagini. Queste interfacce non gestite consentono agli sviluppatori di codec di integrare i codec con WPF, in modo da consentire alle applicazioni WPF di utilizzare automaticamente nuovi formati immagine.

Per un esempio di API di estensibilità, vedere l'esempio di codec Win32 (la pagina potrebbe essere in inglese). In questo esempio viene illustrato come creare un decodificatore e un codificatore per un formato immagine personalizzato.

Nota
Affinché il sistema lo riconosca, è necessario che il codec disponga di una firma digitale.

Vedere anche

Condividi tramite