LoadPartialArgb32Pixels

RasterImage.LoadPartialArgb32Pixels method

Carga píxeles ARGB de 32 bits parcialmente por paquetes.

public void LoadPartialArgb32Pixels(Rectangle rectangle, 
    IPartialArgb32PixelLoader partialPixelLoader)
ParámetroEscribeDescripción
rectangleRectangleEl rectángulo deseado.
partialPixelLoaderIPartialArgb32PixelLoaderEl cargador de píxeles ARGB de 32 bits.

Ejemplos

El siguiente ejemplo muestra cómo cargar y procesar píxeles de una imagen ráster utilizando su propio procesador parcial. Por ejemplo, considere un problema de contar los píxeles completamente transparentes de una imagen. Para contar píxeles transparentes utilizando un mecanismo de carga parcial, se introduce una clase separada TransparentArgb32PixelCounter que 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;

    // Crear una instancia de Aspose.Imaging.IPartialArgb32PixelLoader y pasarla a Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
    TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();

    // Carga píxeles para toda la imagen. Cualquier parte rectangular de la imagen se puede especificar como el primer parámetro del método 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);
}

// El contador puede verse así:        
/// <summary>
/// Cuenta el número de píxeles completamente transparentes con un valor de canal alfa de 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
    /// <summary>
    /// El número de píxeles completamente transparentes.
    /// </summary>
    private int count;

    /// <summary>
    /// Obtiene el número de píxeles completamente transparentes.
    /// </summary>
    public int Count
    {
        get { return this.count; }
    }

    /// <summary>
    /// Procesa los píxeles cargados. Este método se vuelve a llamar cada vez que se carga una nueva porción de píxeles.
    /// </summary>
    /// <param name="pixelsRectangle">El rectángulo de píxeles.</param>
    /// <param name="pixels">Los píxeles ARGB de 32 bits.</param>
    /// <param name="start">El punto de píxeles de inicio.</param>
    /// <param name="end">El punto final de píxeles.</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++;
            }
        }
    }
}

Ver también