Вопрос по c#, performance – Как я могу ускорить этот класс гистограммы?

2

Это должно рассчитать гистограмму 8-битного изображения в градациях серого. С тестовым растровым изображением 1024x770 время CreateTime составляет около 890 мс. Как я могу сделать это (путь, путь) быстрее?

EDIT: я должен упомянуть, что это фактически еще не вычисляет гистограмму, это только получает значения из растрового изображения. Так что я действительно должен был спросить, каков самый быстрый способ получить все значения пикселей из 8-битного изображения в градациях серого?

public class Histogram {

    private static int[,] values;

    public Histogram(Bitmap b) {
        var sw = Stopwatch.StartNew();
        values = new int[b.Width, b.Height];

        for (int w = 0; w < b.Width; ++w) {
            for (int h = 0; h < b.Height; ++h) {
                values[w, h] = b.GetPixel(w, h).R;
            }
        }

        sw.Stop();
        CreateTime = (sw.ElapsedTicks /
            (double)Stopwatch.Frequency) * 1000;
    }

    public double CreateTime { get; set; }
}
Я в памяти? C. Ross
Взгляните на ссылку, размещенную McWafflestix. Раньше я делал это в C ++, но когда я попытался перенести мою библиотеку в C #, именно на этом сайте я изучил инструменты C # для быстрого доступа к пикселям. Andres

Ваш Ответ

3   ответа
1

с которой я столкнулся, основываясь на этой теме.

Небезопасный код ожидает, что растровое изображение будет Format24bppRgb, и если это не так, оно преобразует растровое изображение в этот формат и будет работать с клонированной версией.

Обратите внимание, что вызов функции image.Clone () будет сброшен, если вы передадите растровое изображение в формате индексированного пикселя, например Format4bppIndexed.

Требуется ~ 200 мс, чтобы получить гистограмму из изображения 9100x2048 на моем компьютере разработчика.

    private long[] GetHistogram(Bitmap image)
    {
        var histogram = new long[256];

        bool imageWasCloned = false;

        if (image.PixelFormat != PixelFormat.Format24bppRgb)
        {
            //the unsafe code expects Format24bppRgb, so convert the image...
            image = image.Clone(new Rectangle(0, 0, image.Width, image.Height), PixelFormat.Format24bppRgb);
            imageWasCloned = true;
        }

        BitmapData bmd = null;
        try
        {
            bmd = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly,
                                 PixelFormat.Format24bppRgb);

            const int pixelSize = 3; //pixels are 3 bytes each w/ Format24bppRgb

            //For info on locking the bitmap bits and finding the 
            //pixels using unsafe code, see http://www.bobpowell.net/lockingbits.htm
            int height = bmd.Height;
            int width = bmd.Width;
            int rowPadding = bmd.Stride - (width * pixelSize);
            unsafe
            {
                byte* pixelPtr = (byte*)bmd.Scan0;//starts on the first row
                for (int y = 0; y < height; ++y)
                {
                    for (int x = 0; x < width; ++x)
                    {
                        histogram[(pixelPtr[0] + pixelPtr[1] + pixelPtr[2]) / 3]++;
                        pixelPtr += pixelSize;//advance to next pixel in the row
                    }
                    pixelPtr += rowPadding;//advance ptr to the next pixel row by skipping the padding @ the end of each row.
                }
            }
        }
        finally
        {
            if (bmd != null)
                image.UnlockBits(bmd);
            if (imageWasCloned)
                image.Dispose();
        }

        return histogram;
    }
5

int[] hist = new hist[256];
//at this point dont forget to initialize your vector with 0s.

for(int i = 0; i < height; ++i)
{
   for(int j = 0 ; j < widthl ++j)
   {
        hist[ image[i,j] ]++;
   }
}

Алгоритм суммирует, сколько пикселей со значением 0 у вас есть, сколько со значением = 1 и так далее. Основная идея состоит в том, чтобы использовать значение пикселя в качестве индекса для позиции гистограммы, где вы будете считат

У меня есть одна версия этого алгоритма, написанная для C # с использованием неуправляемого кода (это быстро). Я не знаю, быстрее ли это, чем ваш, но вы можете взять его и проверить, вот код:

    public void Histogram(double[] histogram, Rectangle roi)
    {
        BitmapData data = Util.SetImageToProcess(image, roi);

        if (image.PixelFormat != PixelFormat.Format8bppIndexed)
            return;

        if (histogram.Length < Util.GrayLevels)
            return;

        histogram.Initialize();
        int width = data.Width;
        int height = data.Height;
        int offset = data.Stride - width;

        unsafe
        {
            byte* ptr = (byte*)data.Scan0;

            for (int y = 0; y < height; ++y)
            {
                for (int x = 0; x < width; ++x, ++ptr)
                    histogram[ptr[0]]++;

                ptr += offset;
            }
        }
        image.UnlockBits(data);         
    }

    static public BitmapData SetImageToProcess(Bitmap image, Rectangle roi)
    {
        if (image != null)
            return image.LockBits(
                roi,
                ImageLockMode.ReadWrite,
                image.PixelFormat);

        return null;
    }

Надеюсь, я смогу тебе помочь.

Правильно относительно гистограммы, и правильно, что чтение пикселей - это то, что нужно оптимизировать. Mike Dunlavey
3

Эт хорошая ссылка на процесс. По сути, вам нужно использоватьunsafe код для перебора растровых данных.

Похожие вопросы