GaborConversion(ColorFloatImage image, int x, int y, float[,] matr, float normValue)
        {
            ColorFloatPixel tempPixel = image[x, y];

            tempPixel.r = 0;
            tempPixel.g = 0;
            tempPixel.b = 0;

            int n = matr.GetLength(0);

            for (int i = 0; i < n; ++i)
            {
                for (int j = 0; j < n; ++j)
                {
                    tempPixel.r += matr[i, j] * image[((x + i - (n - 1) / 2) < 0 || (x + i - (n - 1) / 2) >= image.Width ? x : (x + i - (n - 1) / 2)), ((y + j - (n - 1) / 2) < 0 || (y + j - (n - 1) / 2) >= image.Height ? y : (y + j - (n - 1) / 2))].r;
                    tempPixel.g += matr[i, j] * image[((x + i - (n - 1) / 2) < 0 || (x + i - (n - 1) / 2) >= image.Width ? x : (x + i - (n - 1) / 2)), ((y + j - (n - 1) / 2) < 0 || (y + j - (n - 1) / 2) >= image.Height ? y : (y + j - (n - 1) / 2))].g;
                    tempPixel.b += matr[i, j] * image[((x + i - (n - 1) / 2) < 0 || (x + i - (n - 1) / 2) >= image.Width ? x : (x + i - (n - 1) / 2)), ((y + j - (n - 1) / 2) < 0 || (y + j - (n - 1) / 2) >= image.Height ? y : (y + j - (n - 1) / 2))].b;
                }
            }
            tempPixel.r = tempPixel.r / normValue;
            tempPixel.g = tempPixel.g / normValue;
            tempPixel.b = tempPixel.b / normValue;

            return(tempPixel);
        }
Example #2
0
        public static Bitmap ImageToBitmap(ColorFloatImage image)
        {
            Bitmap B = new Bitmap(image.Width, image.Height, PixelFormat.Format24bppRgb);

            LockBitmapInfo lbi = LockBitmap(B);

            try
            {
                for (int j = 0; j < image.Height; j++)
                {
                    for (int i = 0; i < image.Width; i++)
                    {
                        ColorFloatPixel p = image[i, j];
                        lbi.data[lbi.linewidth * j + i * 4]     = p.b <0.0f ? (byte)0 : p.b> 255.0f ? (byte)255 : (byte)p.b;
                        lbi.data[lbi.linewidth * j + i * 4 + 1] = p.g <0.0f ? (byte)0 : p.g> 255.0f ? (byte)255 : (byte)p.g;
                        lbi.data[lbi.linewidth * j + i * 4 + 2] = p.r <0.0f ? (byte)0 : p.r> 255.0f ? (byte)255 : (byte)p.r;
                    }
                }
            }
            finally
            {
                UnlockBitmap(lbi);
            }

            return(B);
        }
        public static void Median(ColorFloatImage image, int rad)
        {
            float[]         med     = new float[(rad * 2 + 1) * (rad * 2 + 1)];
            ColorFloatImage tempImg = new ColorFloatImage(image.Width, image.Height);
            int             index   = 0;

            for (int y = 0; y < image.Height; y++)
            {
                for (int x = 0; x < image.Width; x++)
                {
                    ColorFloatPixel tempPixel = image[x, y];
                    index = 0;
                    for (int i = -rad; i <= rad; i++)
                    {
                        for (int j = -rad; j <= rad; j++)
                        {
                            med[index] = image[((x + i) < 0 || (x + i) >= image.Width ? x : (x + i)), ((y + j) < 0 || (y + j) >= image.Height ? y : (y + j))].g;
                            index++;
                        }
                    }
                    Array.Sort(med);
                    tempPixel.g = med[2 * rad * rad + 2 * rad + 1];

                    index = 0;
                    for (int i = -rad; i <= rad; i++)
                    {
                        for (int j = -rad; j <= rad; j++)
                        {
                            med[index] = image[((x + i) < 0 || (x + i) >= image.Width ? x : (x + i)), ((y + j) < 0 || (y + j) >= image.Height ? y : (y + j))].r;
                            index++;
                        }
                    }
                    Array.Sort(med);
                    tempPixel.r = med[2 * rad * rad + 2 * rad + 1];

                    index = 0;
                    for (int i = -rad; i <= rad; i++)
                    {
                        for (int j = -rad; j <= rad; j++)
                        {
                            med[index] = image[((x + i) < 0 || (x + i) >= image.Width ? x : (x + i)), ((y + j) < 0 || (y + j) >= image.Height ? y : (y + j))].b;
                            index++;
                        }
                    }
                    Array.Sort(med);
                    tempPixel.b   = med[2 * rad * rad + 2 * rad + 1];
                    tempImg[x, y] = tempPixel;
                }
            }

            for (int y = 0; y < image.Height; y++)
            {
                for (int x = 0; x < image.Width; x++)
                {
                    image[x, y] = tempImg[x, y];
                }
            }
        }
Example #4
0
        public static ColorFloatPixel operator +(ColorFloatPixel P1, ColorFloatPixel P2)
        {
            ColorFloatPixel tmp = P1;

            tmp.r += P2.r;
            tmp.g += P2.g;
            tmp.b += P2.b;
            return(tmp);
        }
Example #5
0
        public static ColorFloatPixel operator *(ColorFloatPixel P, float n)
        {
            ColorFloatPixel tmp = new ColorFloatPixel();

            tmp.a = P.a;
            tmp.r = P.r * n;
            tmp.g = P.g * n;
            tmp.b = P.b * n;
            return(tmp);
        }
        public static void Sobel(ColorFloatImage image, string type = "xy")
        {
            ColorFloatImage tempImg = new ColorFloatImage(image.Width + 2, image.Height + 2);

            ResizeImage(image, tempImg);

            if (type == "x")
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempP = SobelX(tempImg, x + 1, y + 1);
                        tempP.a    += 128;
                        tempP.r    += 128;
                        tempP.g    += 128;
                        tempP.b    += 128;
                        image[x, y] = tempP;
                    }
                }
            }
            else if (type == "y")
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempP = SobelY(tempImg, x + 1, y + 1);
                        tempP.a    += 128;
                        tempP.r    += 128;
                        tempP.g    += 128;
                        tempP.b    += 128;
                        image[x, y] = tempP;
                    }
                }
            }
            else
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempPX = SobelX(tempImg, x + 1, y + 1),
                                        tempPY = SobelY(tempImg, x + 1, y + 1), tempP;
                        tempP.a     = 128 + image[x, y].a;
                        tempP.r     = 128 + (float)Math.Sqrt(tempPX.r * tempPX.r + tempPY.r * tempPY.r);
                        tempP.g     = 128 + (float)Math.Sqrt(tempPX.g * tempPX.g + tempPY.g * tempPY.g);
                        tempP.b     = 128 + (float)Math.Sqrt(tempPX.b * tempPX.b + tempPY.b * tempPY.b);
                        image[x, y] = tempP;
                    }
                }
            }
        }
 public static void FlipImageX(ColorFloatImage image)
 {
     for (int y = 0; y < image.Height / 2; y++)
     {
         for (int x = 0; x < image.Width; x++)
         {
             ColorFloatPixel p = image[x, y];
             image[x, y] = image[x, image.Height - 1 - y];
             image[x, image.Height - 1 - y] = p;
         }
     }
 }
 public static void FlipImageY(ColorFloatImage image)
 {
     for (int y = 0; y < image.Height; y++)
     {
         for (int x = 0; x < image.Width / 2; x++)
         {
             ColorFloatPixel p = image[x, y];
             image[x, y] = image[image.Width - 1 - x, y];
             image[image.Width - 1 - x, y] = p;
         }
     }
 }
        public static void Roberts(ColorFloatImage image, int type = 0)
        {
            ColorFloatImage tempImg = new ColorFloatImage(image.Width + 2, image.Height + 2);

            ResizeImage(image, tempImg);
            if (type == 1)
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempP = Roberts1(tempImg, x + 1, y + 1);
                        tempP.a    += 128;
                        tempP.r    += 128;
                        tempP.g    += 128;
                        tempP.b    += 128;
                        image[x, y] = tempP;
                    }
                }
            }
            else if (type == 2)
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempP = Roberts2(tempImg, x + 1, y + 1);
                        tempP.a    += 128;
                        tempP.r    += 128;
                        tempP.g    += 128;
                        tempP.b    += 128;
                        image[x, y] = tempP;
                    }
                }
            }
            else
            {
                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        ColorFloatPixel tempPX = Roberts1(tempImg, x + 1, y + 1),
                                        tempPY = Roberts2(tempImg, x + 1, y + 1), tempP;
                        tempP.a     = 128 + image[x, y].a;
                        tempP.r     = 128 + (float)Math.Sqrt(tempPX.r * tempPX.r + tempPY.r * tempPY.r);
                        tempP.g     = 128 + (float)Math.Sqrt(tempPX.g * tempPX.g + tempPY.g * tempPY.g);
                        tempP.b     = 128 + (float)Math.Sqrt(tempPX.b * tempPX.b + tempPY.b * tempPY.b);
                        image[x, y] = tempP;
                    }
                }
            }
        }
 public static void InvertImage(ColorFloatImage image)
 {
     for (int y = 0; y < image.Height; y++)
     {
         for (int x = 0; x < image.Width; x++)
         {
             ColorFloatPixel p = image[x, y];
             p.r         = 255 - image[x, y].r;
             p.g         = 255 - image[x, y].g;
             p.b         = 255 - image[x, y].b;
             image[x, y] = p;
         }
     }
 }
        public static void downsample(ref ColorFloatImage image, float s, string paramoff = "")
        {
            ColorFloatImage tempImg = new ColorFloatImage((int)(image.Width / s), image.Height);

            if (paramoff != "-off")
            {
                ImageProcessing.Gauss(ref image, (float)Math.Sqrt(Math.Abs(s * s - 1)));
            }
            float n = (image.Width * s - s) / ((float)image.Width - s);

            for (int y = 0; y < image.Height; ++y)
            {
                tempImg[0, y] = image[0, y];
                tempImg[tempImg.Width - 1, y] = image[image.Width - 1, y];
                for (int x = 1; x < tempImg.Width - 1; ++x)
                {
                    ColorFloatPixel p  = new ColorFloatPixel();
                    float           x1 = (float)Math.Truncate(x * n),
                                    x2 = (int)(x * n) + 1;
                    p.r           = (x2 - (float)x * n) * image[(int)x1, y].r + ((float)x * n - x1) * image[(int)x2, y].r;
                    p.g           = (x2 - (float)x * n) * image[(int)x1, y].g + ((float)x * n - x1) * image[(int)x2, y].g;
                    p.b           = (x2 - (float)x * n) * image[(int)x1, y].b + ((float)x * n - x1) * image[(int)x2, y].b;
                    tempImg[x, y] = p;
                }
            }
            image = tempImg;

            tempImg = new ColorFloatImage(image.Width, (int)(image.Height / s));
            n       = (image.Height * s - s) / ((float)image.Height - s);
            for (int x = 0; x < image.Width; ++x)
            {
                tempImg[x, 0] = image[x, 0];
                tempImg[x, tempImg.Height - 1] = image[x, image.Height - 1];
                for (int y = 1; y < tempImg.Height - 1; ++y)
                {
                    ColorFloatPixel p  = new ColorFloatPixel();
                    float           y1 = (float)Math.Truncate(y * n) > image.Height - 1 ? image.Height - 1 : (float)Math.Truncate(y * n),
                                    y2 = (int)(y * n) + 1 > image.Height - 1 ? image.Height - 1 : (int)(y * n) + 1;
                    p.r           = (y2 - (float)y * n) * image[x, (int)y1].r + ((float)y * n - y1) * image[x, (int)y2].r;
                    p.g           = (y2 - (float)y * n) * image[x, (int)y1].g + ((float)y * n - y1) * image[x, (int)y2].g;
                    p.b           = (y2 - (float)y * n) * image[x, (int)y1].b + ((float)y * n - y1) * image[x, (int)y2].b;
                    tempImg[x, y] = p;
                }
            }
            image = tempImg;
        }
        public static void up_bilinear(ref ColorFloatImage image, float s)
        {
            ColorFloatImage tempImg = new ColorFloatImage((int)(image.Width * s), image.Height);
            float           n       = (image.Width * s - 1) / ((float)image.Width - 1);

            for (int y = 0; y < image.Height; ++y)
            {
                tempImg[0, y] = image[0, y];
                tempImg[tempImg.Width - 1, y] = image[image.Width - 1, y];
                for (int x = 1; x < tempImg.Width - 1; ++x)
                {
                    ColorFloatPixel p  = new ColorFloatPixel();
                    float           x1 = (float)Math.Truncate(x / n),
                                    x2 = (int)(x / n) + 1;
                    p.r           = (x2 - (float)x / n) * image[(int)x1, y].r + ((float)x / n - x1) * image[(int)x2, y].r;
                    p.g           = (x2 - (float)x / n) * image[(int)x1, y].g + ((float)x / n - x1) * image[(int)x2, y].g;
                    p.b           = (x2 - (float)x / n) * image[(int)x1, y].b + ((float)x / n - x1) * image[(int)x2, y].b;
                    tempImg[x, y] = p;
                }
            }
            image = tempImg;

            tempImg = new ColorFloatImage(image.Width, (int)(image.Height * s));
            n       = (image.Height * s - 1) / ((float)image.Height - 1);
            for (int x = 0; x < image.Width; ++x)
            {
                tempImg[x, 0] = image[x, 0];
                tempImg[x, tempImg.Height - 1] = image[x, image.Height - 1];
                for (int y = 1; y < tempImg.Height - 1; ++y)
                {
                    ColorFloatPixel p  = new ColorFloatPixel();
                    float           y1 = (float)Math.Truncate(y / n),
                                    y2 = (int)(y / n) + 1;
                    p.r           = (y2 - (float)y / n) * image[x, (int)y1].r + ((float)y / n - y1) * image[x, (int)y2].r;
                    p.g           = (y2 - (float)y / n) * image[x, (int)y1].g + ((float)y / n - y1) * image[x, (int)y2].g;
                    p.b           = (y2 - (float)y / n) * image[x, (int)y1].b + ((float)y / n - y1) * image[x, (int)y2].b;
                    tempImg[x, y] = p;
                }
            }
            image = tempImg;
        }
Example #13
0
        public static ColorFloatImage BitmapToColorFloatImage(Bitmap B)
        {
            int             W = B.Width, H = B.Height;
            ColorFloatImage res = new ColorFloatImage(W, H);

            if (B.PixelFormat == PixelFormat.Format8bppIndexed)
            {
                Color[] pi  = B.Palette.Entries;
                byte[]  pal = new byte[1024];
                for (int i = 0; i < pi.Length; i++)
                {
                    Color C = pi[i];
                    pal[i * 4]     = C.B;
                    pal[i * 4 + 1] = C.G;
                    pal[i * 4 + 2] = C.R;
                    pal[i * 4 + 3] = C.A;
                }

                LockBitmapInfo lbi = LockBitmap(B, PixelFormat.Format8bppIndexed, 1);
                try
                {
                    for (int j = 0; j < H; j++)
                    {
                        for (int i = 0; i < W; i++)
                        {
                            int c = lbi.data[lbi.linewidth * j + i];
                            int b = pal[c * 4];
                            int g = pal[c * 4 + 1];
                            int r = pal[c * 4 + 2];
                            res[i, j] = new ColorFloatPixel()
                            {
                                b = b, g = g, r = r, a = 0.0f
                            };
                        }
                    }
                }
                finally
                {
                    UnlockBitmap(lbi);
                }
            }
            else
            {
                LockBitmapInfo lbi = LockBitmap(B);
                try
                {
                    for (int j = 0; j < H; j++)
                    {
                        for (int i = 0; i < W; i++)
                        {
                            int b = lbi.data[lbi.linewidth * j + i * 4];
                            int g = lbi.data[lbi.linewidth * j + i * 4 + 1];
                            int r = lbi.data[lbi.linewidth * j + i * 4 + 2];
                            res[i, j] = new ColorFloatPixel()
                            {
                                b = b, g = g, r = r, a = 0.0f
                            };
                        }
                    }
                }
                finally
                {
                    UnlockBitmap(lbi);
                }
            }

            return(res);
        }