LoadPartialArgb32Pixels

RasterImage.LoadPartialArgb32Pixels method

Charge les pixels ARGB 32 bits partiellement par packs.

public void LoadPartialArgb32Pixels(Rectangle rectangle, 
    IPartialArgb32PixelLoader partialPixelLoader)

Paramètre	Taper	La description
rectangle	Rectangle	Le rectangle souhaité.
partialPixelLoader	IPartialArgb32PixelLoader	Le chargeur de pixels ARGB 32 bits.

Exemples

L’exemple suivant montre comment charger et traiter les pixels d’une image raster à l’aide de votre propre processeur partiel. Par exemple, considérons un problème de comptage de pixels entièrement transparents d’une image. Afin de compter les pixels transparents à l’aide du mécanisme de chargement partiel, une classe distincte TransparentArgb32PixelCounter implémentant Aspose.Imaging.IPartialArgb32PixelLoader est introduite.

[C#]

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

    // Créez une instance de Aspose.Imaging.IPartialArgb32PixelLoader et passez-la à Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
    TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();

    // Charge les pixels pour toute l'image. Toute partie rectangulaire de l'image peut être spécifiée comme premier paramètre de la méthode 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);
}

// Le compteur peut ressembler à ceci :        
/// <summary>
/// Compte le nombre de pixels entièrement transparents avec une valeur de canal alpha de 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
    /// <summary>
    /// Le nombre de pixels entièrement transparents.
    /// </summary>
    private int count;

    /// <summary>
    /// Obtient le nombre de pixels entièrement transparents.
    /// </summary>
    public int Count
    {
        get { return this.count; }
    }

    /// <summary>
    /// Traite les pixels chargés. Cette méthode est rappelée à chaque fois qu'une nouvelle portion de pixels est chargée.
    /// </summary>
    /// <param name="pixelsRectangle">Le rectangle de pixels.</param>
    /// <param name="pixels">Les pixels ARGB 32 bits.</param>
    /// <param name="start">Le point de départ des pixels.</param>
    /// <param name="end">Le point des pixels de fin.</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++;
            }
        }
    }
}

Voir également

struct Rectangle
interface IPartialArgb32PixelLoader
class RasterImage
espace de noms Aspose.Imaging
Assemblée Aspose.Imaging

LoadCmyk32Pixels LoadPartialPixels