Реализация алгоритма Retinex

Question

Мне нужно реализовать единый масштаб ретинекса и многомасштабный алгоритм ретинекса в C#,
Я искал немного, но не смог найти полезных тренировочных проектов и артиллерийских программ с кодом
Как я правильно понял, я должен:

1. Конвертировать RGB в YUV
2. Размытие изображения с помощью фильтра размытия по Гауссу
3. Используйте I'(x, y) = 255*log10( I(x, y)/G(x, y)) + 127,5
   Я - это освещение, G - ядро ​​Гаусса, я ' - результат изображения
4. Конвертировать обратно YUV в RGB

Этот код не работает правильно

 public static Image<Bgr, byte> SingleScaleRetinex(this Image<Bgr, byte> img, int gaussianKernelSize, double sigma)
            {
                var radius = gaussianKernelSize / 2;
                var kernelSize = 2 * radius + 1;

                var ycc = img.Convert<Ycc, byte>();

                var sum = 0f;
                var gaussKernel = new float[kernelSize * kernelSize];
                for (int i = -radius, k = 0; i <= radius; i++, k++)
                {
                    for (int j = -radius; j <= radius; j++)
                    {
                        var val = (float)Math.Exp(-(i * i + j * j) / (sigma * sigma));
                        gaussKernel[k] = val;
                        sum += val;
                    }
                }
                for (int i = 0; i < gaussKernel.Length; i++)
                    gaussKernel[i] /= sum;

                var gray = new Image<Gray, byte>(ycc.Size);
                CvInvoke.cvSetImageCOI(ycc, 1);
                CvInvoke.cvCopy(ycc, gray, IntPtr.Zero);

                // Размеры изображения
                var width = img.Width;
                var height = img.Height;

                var bmp = gray.Bitmap;
                var bitmapData = bmp.LockBits(new Rectangle(Point.Empty, gray.Size), ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

                unsafe
                {
                    for (var y = 0; y < height; y++)
                    {
                        var row = (byte*)bitmapData.Scan0 + y * bitmapData.Stride;
                        for (var x = 0; x < width; x++)
                        {
                            var color = row + x;

                            float val = 0;

                            for (int i = -radius, k = 0; i <= radius; i++, k++)
                            {
                                var ii = y + i;
                                if (ii < 0) ii = 0; if (ii >= height) ii = height - 1;

                                var row2 = (byte*)bitmapData.Scan0 + ii * bitmapData.Stride;
                                for (int j = -radius; j <= radius; j++)
                                {
                                    var jj = x + j;
                                    if (jj < 0) jj = 0; if (jj >= width) jj = width - 1;

                                    val += *(row2 + jj) * gaussKernel[k];

                                }
                            }

                            var newColor = 127.5 + 255 * Math.Log(*color / val);
                            if (newColor > 255)
                                newColor = 255;
                            else if (newColor < 0)
                                newColor = 0;
                            *color = (byte)newColor;
                        }
                    }
                }
                bmp.UnlockBits(bitmapData);

                CvInvoke.cvCopy(gray, ycc, IntPtr.Zero);
                CvInvoke.cvSetImageCOI(ycc, 0);

                return ycc.Convert<Bgr, byte>();

            }

Answer 1

Посмотрите на: http://www.fer.unizg.hr/ipg/resources/color_constancy

Эти алгоритмы являются модификациями алгоритма Retinex (с улучшением скорости), хотя автор дал им забавные имена:)

Существует полный исходный код (C++, но он написан очень красиво).

Answer 2

Извините за некропубликуцию, но кажется, что в шаге 3 вашей процедуры есть ошибка, которая может ввести в заблуждение проходящего мимо человека.

Чтобы применить коррекцию, вы хотите разделить исходное изображение на его отфильтрованную по Гауссу копию, а не само ядро ​​Гаусса. Примерно в псевдокоде:

I_filtered(x,y) = G(x,y) * I(x,y)
I'(x,y) = log(I(x,y) / I_filtered(x,y))

А затем применить кастинг I'(x,y) на требуемый числовой тип (uint8, как я могу сослаться из оригинального поста).

Больше на эту тему можно найти в этой статье:

Ri(x, y) = log(Ii(x, y)) − log(Ii(x, y) ∗ F(x, y))

где Ii является входным изображением на i-ом цветном канале, Ri является выходным изображением ретинекса на i-м канале и F является нормализованной функцией объемного звучания.,