LoadPartialArgb32Pixels

RasterImage.LoadPartialArgb32Pixels method

Carica i pixel ARGB a 32 bit parzialmente per pacchetti.

public void LoadPartialArgb32Pixels(Rectangle rectangle, 
    IPartialArgb32PixelLoader partialPixelLoader)
ParametroTipoDescrizione
rectangleRectangleIl rettangolo desiderato.
partialPixelLoaderIPartialArgb32PixelLoaderIl caricatore di pixel ARGB a 32 bit.

Esempi

L’esempio seguente mostra come caricare ed elaborare i pixel di un’immagine raster utilizzando il proprio processore parziale. Si consideri ad esempio un problema di conteggio dei pixel completamente trasparenti di un’immagine. Per contare i pixel trasparenti utilizzando il meccanismo di caricamento parziale, viene introdotta una classe separata TransparentArgb32PixelCounter che implementa Aspose.Imaging.IPartialArgb32PixelLoader.

[C#]

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

    // Crea un'istanza di Aspose.Imaging.IPartialArgb32PixelLoader e passala a Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
    TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();

    // Carica pixel per l'intera immagine. Qualsiasi parte rettangolare dell'immagine può essere specificata come primo parametro del metodo Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels.
    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);
}

// Il contatore potrebbe assomigliare a questo:        
/// <summary>
/// Conta il numero di pixel completamente trasparenti con valore del canale alfa pari a 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
    /// <summary>
    /// Il numero di pixel completamente trasparenti.
    /// </summary>
    private int count;

    /// <summary>
    /// Ottiene il numero di pixel completamente trasparenti.
    /// </summary>
    public int Count
    {
        get { return this.count; }
    }

    /// <summary>
    /// Elabora i pixel caricati. Questo metodo viene richiamato ogni volta che viene caricata una nuova porzione di pixel.
    /// </summary>
    /// <param name="pixelsRectangle">Il rettangolo dei pixel.</param>
    /// <param name="pixels">I pixel ARGB a 32 bit.</param>
    /// <param name="start">Il punto iniziale dei pixel.</param>
    /// <param name="end">Il punto finale dei pixel.</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++;
            }
        }
    }
}

Guarda anche

LoadCmyk32Pixels LoadPartialPixels