LoadPartialArgb32Pixels

RasterImage.LoadPartialArgb32Pixels method

Lädt 32-Bit-ARGB-Pixel teilweise nach Paketen.

public void LoadPartialArgb32Pixels(Rectangle rectangle, 
    IPartialArgb32PixelLoader partialPixelLoader)

Parameter	Typ	Beschreibung
rectangle	Rectangle	Das gewünschte Rechteck.
partialPixelLoader	IPartialArgb32PixelLoader	Der 32-Bit-ARGB-Pixel-Loader.

Beispiele

Das folgende Beispiel zeigt, wie Sie Pixel eines Rasterbildes mit Ihrem eigenen Teilprozessor laden und verarbeiten. Betrachten wir zum Beispiel ein Problem des Zählens von vollständig transparenten Pixeln eines Bildes. Um transparente Pixel mit dem Teillademechanismus zu zählen, wird eine separate Klasse TransparentArgb32PixelCounter eingeführt, die Aspose.Imaging.IPartialArgb32PixelLoader implementiert.

[C#]

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

    // Eine Instanz von Aspose.Imaging.IPartialArgb32PixelLoader erstellen und an Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels übergeben
    TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();

    // Pixel für das ganze Bild laden. Jeder rechteckige Teil des Bildes kann als erster Parameter der Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels-Methode angegeben werden.
    rasterImage.LoadPartialArgb32Pixels(rasterImage.Bounds, counter);

    System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
    System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}

// Der Zähler könnte so aussehen:        
/// <summary>
/// Zählt die Anzahl der vollständig transparenten Pixel mit einem Alphakanalwert von 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
    /// <summary>
    /// Die Anzahl der vollständig transparenten Pixel.
    /// </summary>
    private int count;

    /// <summary>
    /// Ruft die Anzahl der vollständig transparenten Pixel ab.
    /// </summary>
    public int Count
    {
        get { return this.count; }
    }

    /// <summary>
    /// Verarbeitet die geladenen Pixel. Diese Methode wird jedes Mal aufgerufen, wenn ein neuer Teil von Pixeln geladen wird.
    /// </summary>
    /// <param name="pixelsRectangle">Das Pixelrechteck.</param>
    /// <param name="pixels">Die 32-Bit-ARGB-Pixel.</param>
    /// <param name="start">Der Startpixelpunkt.</param>
    /// <param name="end">Der Endpixelpunkt.</param>
    public void Process(Aspose.Imaging.Rectangle pixelsRectangle, int[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
    {
        foreach (int pixel in pixels)
        {
            int alpha = (pixel >> 24) & 0xff;
            if (alpha == 0)
            {
                this.count++;
            }
        }
    }
}

Siehe auch

LoadCmyk32Pixels LoadPartialPixels