अपडेट: क्लेमेंस का समाधान सबसे तेज है। मैं उस विकल्प को छोड़ दूँगा जो मुझे केवल मामले में मिला है:

एक न्यूनतम प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने की कोशिश करते हुए जैसा कि पीटर ड्यूनिहो ने टिप्पणी में सुझाव दिया था, मैंने पाया कि गलत पारदर्शिता मान BitmapImageToBitmapConverter() से आ रहे थे। यह पूरी छवि को खराब कर रहा था। अब मैं पीएनजी को सीधे बिटमैप पर लोड करता हूं और इसे स्कैन करता हूं और यह सटीक परिणाम देता है:

Bitmap bmp = new Bitmap("icon.png");
Console.WriteLine(TransparencyPercentageInImage(bmp));

प्रश्न था:

मेरे पास सूची में कुछ छवि नियंत्रण हैं:

imagesList[index].Source = ReloadIcon(index);

वे ".png" फ़ाइलों से छवियों को लोड करते हैं जैसे:

public BitmapImage ReloadIcon(int index)
        {
            var image = new BitmapImage();
            image.BeginInit();
            image.CacheOption = BitmapCacheOption.OnLoad;
            image.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
            image.UriSource = new Uri(iconPaths[index], UriKind.Absolute);
            image.EndInit();
            return image;
        }

मैं फिर उन्हें इस कनवर्टर का उपयोग करके बिटमैप्स में परिवर्तित करता हूं:

private Bitmap BitmapImageToBitmapConverter(BitmapImage bitmapImage)      
{
    using (MemoryStream outStream = new MemoryStream())
    {
        BitmapEncoder enc = new BmpBitmapEncoder();
        enc.Frames.Add(BitmapFrame.Create(bitmapImage));
        enc.Save(outStream);
        System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(outStream);

        return new Bitmap(bitmap);
    }
}

बाद में इस कोड का उपयोग करके पारदर्शिता के लिए प्रत्येक पिक्सेल को स्कैन करने के लिए:

private double TransparencyPercentageInImage(Bitmap image)
{
    double transpPercentage;
    double transpPixelCount = 0;
    double totalPixelCount = image.Height * image.Width;
    Console.WriteLine("Total pixel count: " + totalPixelCount);

    for (int y = 0; y < image.Height; ++y)
    {
        for (int x = 0; x < image.Width; ++x)
        {
            if (image.GetPixel(x, y).A == 0) //or !=255
            {
                transpPixelCount++;
            }
        }
    }

    transpPercentage = transpPixelCount / totalPixelCount * 100;
    return transpPercentage;
}

मूल रूप से, बिटमैप से सटीक पारदर्शी पिक्सेल प्रतिशत/गिनती प्राप्त करने के लिए मुझे क्या करना चाहिए?

मैं अर्ध-पारदर्शी नहीं, बिल्कुल पारदर्शी पिक्सल की गिनती की तलाश में हूं।

मैं वास्तव में यहां गति की तलाश नहीं कर रहा हूं इसलिए कोई समाधान हो जाता है। मैं पहले से ही असुरक्षित कोड का उपयोग कर रहा हूं, इसलिए इसका भी स्वागत है।

-1
Tony Steel 29 सितंबर 2019, 01:42

1 उत्तर

सबसे बढ़िया उत्तर

बिटमैप स्रोत में पिक्सेल मानों तक पहुँचने के लिए आपको न तो System.Drawing.Bitmap और न ही WriteableBitmap की आवश्यकता है।

पिक्सेल बफ़र प्राप्त करने के लिए बस CopyPixels पर कॉल करें और 0 के अल्फा मान वाले पिक्सेल की गणना करें। पहले सुनिश्चित करें कि आप वांछित प्रारूप में बफर तक पहुँच प्राप्त करते हैं:

private double GetTransparentPixelsPercentage(BitmapSource bitmap)
{
    if (bitmap.Format != PixelFormats.Bgra32)
    {
        bitmap = new FormatConvertedBitmap(bitmap, PixelFormats.Bgra32, null, 0);
    }

    var pixelCount = bitmap.PixelWidth * bitmap.PixelHeight;
    var pixels = new byte[4 * pixelCount];

    bitmap.CopyPixels(pixels, 4 * bitmap.PixelWidth, 0);

    var transparentPixelCount = 0;

    for (var i = 3; i < 4 * pixelCount; i += 4) // start at first alpha value
    {
        if (pixels[i] == 0)
        {
            transparentPixelCount++;
        }
    }

    return (double)transparentPixelCount / pixelCount;
}
0
Clemens 29 सितंबर 2019, 09:27