Exemplo n.º 1
0
        public Bitmap applyRecursiveFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            List <int> redList   = new List <int>();
            List <int> greenList = new List <int>();
            List <int> blueList  = new List <int>();

            double[] rSumsArray = new double[apertures.Count];
            double[] gSumsArray = new double[apertures.Count];
            double[] bSumsArray = new double[apertures.Count];

            for (int x = 0; x < apertures.Count; x++)
            {
                redList.Clear();
                blueList.Clear();
                greenList.Clear();
                int rSum = 0, gSum = 0, bSum = 0, kSum = 0;
                List <List <Point> > matrix = apertures[x].matrix;
                bool isSideAperture         = false;
                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        //проверяем, выйдем ли мы за границы изображения слева, при расчетах,
                        // ведь идем от -r до +r потом.
                        if (pixelPosX <= filterSize.X || pixelPosY <= filterSize.Y)
                        {
                            isSideAperture = true;
                        }

                        Color color = image.GetPixel(pixelPosX, pixelPosY);
                        redList.Add(color.R);
                        greenList.Add(color.G);
                        blueList.Add(color.B);
                        kSum += 1;
                    }
                }
                //если при расчетах выйдем за рамки, считаем просто стреднее арифметическое.
                if (isSideAperture)
                {
                    for (int i = 0; i < redList.Count; i++)
                    {
                        rSum += redList[i];
                        gSum += greenList[i];
                        bSum += blueList[i];
                    }

                    rSumsArray[x] = rSum;
                    gSumsArray[x] = gSum;
                    bSumsArray[x] = bSum;
                }
                else
                {
                    int rSum1 = 0, gSum1 = 0, bSum1 = 0, kSum1 = 0;
                    int rSum2 = 0, gSum2 = 0, bSum2 = 0, kSum2 = 0;

                    //крайне правый элемент предыдущего окна
                    for (int i = 0; i < matrix.Count; i++)
                    {
                        Color color = image.GetPixel(matrix[i][0].X - 1, matrix[i][0].Y);
                        rSum1 += color.R;
                        gSum1 += color.G;
                        bSum1 += color.B;
                        kSum1 += 1;
                    }

                    for (int i = 0; i < matrix.Count; i++)
                    {
                        Color color = image.GetPixel(matrix[i][filterSize.X - 1].X, matrix[i][filterSize.X - 1].Y);
                        rSum2 += color.R;
                        gSum2 += color.G;
                        bSum2 += color.B;
                        kSum2 += 1;
                    }

                    //вычислять рекурсию только если предыдущая апертура на той же линии
                    if (apertures[x].y == apertures[x - 1].y)
                    {
                        double rSumReal = rSumsArray[x - 1] - rSum1 + rSum2;
                        double gSumReal = gSumsArray[x - 1] - rSum1 + rSum2;
                        double bSumReal = gSumsArray[x - 1] - rSum1 + rSum2;

                        rSumsArray[x] = rSumReal;
                        gSumsArray[x] = gSumReal;
                        bSumsArray[x] = bSumReal;
                    }
                    else
                    {
                        for (int i = 0; i < redList.Count; i++)
                        {
                            rSum += redList[i];
                            gSum += greenList[i];
                            bSum += blueList[i];
                        }

                        rSumsArray[x] = rSum;
                        gSumsArray[x] = gSum;
                        bSumsArray[x] = bSum;
                    }
                }

                // int pixelCount = filterSize.X * filterSize.Y;

                rSum = (int)rSumsArray[x] / kSum;
                if (rSum < 0)
                {
                    rSum = 0;
                }
                else if (rSum > 255)
                {
                    rSum = 255;
                }

                gSum = (int)gSumsArray[x] / kSum;
                if (gSum < 0)
                {
                    gSum = 0;
                }
                else if (gSum > 255)
                {
                    gSum = 255;
                }

                bSum = (int)bSumsArray[x] / kSum;
                if (bSum < 0)
                {
                    bSum = 0;
                }
                else if (bSum > 255)
                {
                    bSum = 255;
                }

                int aperturePosX = matrix.Count / 2;
                if (matrix.Count != 0 && matrix[aperturePosX].Count / 2 != 0)
                {
                    int aperturePosY = matrix[aperturePosX].Count / 2;

                    Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                    if (colorChannelIndex == 0)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, (int)gSum, (int)bSum));
                    }
                    else if (colorChannelIndex == 1)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, oldColor.G, oldColor.B));
                    }
                    else if (colorChannelIndex == 2)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, (int)gSum, oldColor.B));
                    }
                    else if (colorChannelIndex == 3)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, (int)bSum));
                    }
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 2
0
        public Bitmap applyMeanFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            for (int x = 0; x < apertures.Count; x++)
            {
                int rSum = 0, gSum = 0, bSum = 0, kSum = 0;

                //for(int i = 0; i < apertures[x].matrix.Count; i++)
                //{
                List <List <Point> > matrix = apertures[x].matrix;
                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        Color color = image.GetPixel(pixelPosX, pixelPosY);
                        rSum += color.R;
                        gSum += color.G;
                        bSum += color.B;
                        kSum += 1;
                    }
                }
                //}

                if (kSum <= 0)
                {
                    kSum = 1;
                }

                rSum = rSum / kSum;
                if (rSum < 0)
                {
                    rSum = 0;
                }
                else if (rSum > 255)
                {
                    rSum = 255;
                }

                gSum = gSum / kSum;
                if (gSum < 0)
                {
                    gSum = 0;
                }
                else if (gSum > 255)
                {
                    gSum = 255;
                }

                bSum = bSum / kSum;
                if (bSum < 0)
                {
                    bSum = 0;
                }
                else if (bSum > 255)
                {
                    bSum = 255;
                }

                int aperturePosX            = matrix.Count / 2;
                int aperturePosY            = matrix[aperturePosX].Count / 2;


                Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                if (colorChannelIndex == 0)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rSum, gSum, bSum));
                }
                else if (colorChannelIndex == 1)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rSum, oldColor.G, oldColor.B));
                }
                else if (colorChannelIndex == 2)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, gSum, oldColor.B));
                }
                else if (colorChannelIndex == 3)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, bSum));
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 3
0
        public Bitmap applySplitMiddleFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, int d, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            List <int> redList   = new List <int>();
            List <int> greenList = new List <int>();
            List <int> blueList  = new List <int>();

            List <int> redListAfterD   = new List <int>();
            List <int> greenListAfterD = new List <int>();
            List <int> blueListAfterD  = new List <int>();

            if (d >= filterSize.X * filterSize.Y)
            {
                MessageBox.Show("D не может быть больше или равен общему количеству пикселей в апертуре");
                return(rezult);
            }

            for (int x = 0; x < apertures.Count; x++)
            {
                redList.Clear();
                blueList.Clear();
                greenList.Clear();

                redListAfterD.Clear();
                greenListAfterD.Clear();
                blueListAfterD.Clear();

                List <List <Point> > matrix = apertures[x].matrix;
                //int line = 0;
                foreach (var matrixLine in matrix)
                {
                    //int point = 0;
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        Color color = image.GetPixel(pixelPosX, pixelPosY);
                        redList.Add(color.R);
                        greenList.Add(color.G);
                        blueList.Add(color.B);

                        //point++;
                    }
                    //line++;
                }

                redList.Sort();
                greenList.Sort();
                blueList.Sort();

                //отсечение краев
                for (int i = d / 2; i < redList.Count - d / 2; i++)
                {
                    redListAfterD.Add(redList[i]);
                    greenListAfterD.Add(greenList[i]);
                    blueListAfterD.Add(blueList[i]);
                }

                int rSum = 0, gSum = 0, bSum = 0, kSum = 0;
                for (int i = 0; i < redListAfterD.Count; i++)
                {
                    rSum += redListAfterD[i];
                    gSum += greenListAfterD[i];
                    bSum += blueListAfterD[i];
                    kSum += 1;
                }

                if (kSum <= 0)
                {
                    kSum = 1;
                }

                rSum = rSum / kSum;
                if (rSum < 0)
                {
                    rSum = 0;
                }
                else if (rSum > 255)
                {
                    rSum = 255;
                }

                gSum = gSum / kSum;
                if (gSum < 0)
                {
                    gSum = 0;
                }
                else if (gSum > 255)
                {
                    gSum = 255;
                }

                bSum = bSum / kSum;
                if (bSum < 0)
                {
                    bSum = 0;
                }
                else if (bSum > 255)
                {
                    bSum = 255;
                }


                int aperturePosX = matrix.Count / 2;
                if (matrix.Count != 0 && matrix[aperturePosX].Count / 2 != 0)
                {
                    int aperturePosY = matrix[aperturePosX].Count / 2;

                    Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                    if (colorChannelIndex == 0)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, (int)gSum, (int)bSum));
                    }
                    else if (colorChannelIndex == 1)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, oldColor.G, oldColor.B));
                    }
                    else if (colorChannelIndex == 2)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, (int)gSum, oldColor.B));
                    }
                    else if (colorChannelIndex == 3)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, (int)bSum));
                    }
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 4
0
        public Bitmap applyJimCasaburiFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, double threshold, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            double sigma = 0.5;

            for (int x = 0; x < apertures.Count; x++)
            {
                double ccRed = 0, svRed = 0, ccGreen = 0, svGreen = 0, ccBlue = 0, svBlue = 0;
                Color  centerColor = image.GetPixel(apertures[x].x, apertures[x].y);

                List <List <Point> > matrix = apertures[x].matrix;
                //int line = 0;
                foreach (var matrixLine in matrix)
                {
                    //int point = 0;
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        Color color = image.GetPixel(pixelPosX, pixelPosY);

                        ccRed += getClippingColor(color.R, centerColor.R, threshold);
                        svRed += getSuitabilityValue(color.R, centerColor.R, threshold);

                        ccGreen += getClippingColor(color.G, centerColor.G, threshold);
                        svGreen += getSuitabilityValue(color.G, centerColor.G, threshold);

                        ccBlue += getClippingColor(color.B, centerColor.B, threshold);
                        svBlue += getSuitabilityValue(color.B, centerColor.B, threshold);



                        //point++;
                    }
                    //line++;
                }

                int R;
                if (ccRed != 0)
                {
                    R = (int)(svRed / ccRed);
                }
                else
                {
                    R = centerColor.R;
                }

                int G;
                if (ccGreen != 0)
                {
                    G = (int)(svGreen / ccGreen);
                }
                else
                {
                    G = centerColor.G;
                }

                int B;
                if (ccBlue != 0)
                {
                    B = (int)(svBlue / ccBlue);
                }
                else
                {
                    B = centerColor.B;
                }


                int aperturePosX = matrix.Count / 2;
                if (matrix.Count != 0 && matrix[aperturePosX].Count / 2 != 0)
                {
                    int aperturePosY = matrix[aperturePosX].Count / 2;

                    Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                    if (colorChannelIndex == 0)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)R, (int)G, (int)B));
                    }
                    else if (colorChannelIndex == 1)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)R, oldColor.G, oldColor.B));
                    }
                    else if (colorChannelIndex == 2)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, (int)G, oldColor.B));
                    }
                    else if (colorChannelIndex == 3)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, (int)B));
                    }
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 5
0
        public static Bitmap applyGaussianBlurFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            double sigma = 0.5;

            for (int x = 0; x < apertures.Count; x++)
            {
                double rSum = 0, gSum = 0, bSum = 0, kSum = 0;

                List <List <Point> > matrix = apertures[x].matrix;
                int line = 0;
                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        Color  color = image.GetPixel(pixelPosX, pixelPosY);
                        double kVal  = calculateGaussian(line, sigma);

                        rSum += color.R * kVal;
                        gSum += color.G * kVal;
                        bSum += color.B * kVal;

                        kSum += kVal;
                    }
                    line++;
                }

                if (kSum <= 0)
                {
                    kSum = 1;
                }

                rSum = rSum / kSum;
                if (rSum < 0)
                {
                    rSum = 0;
                }
                else if (rSum > 255)
                {
                    rSum = 255;
                }

                gSum = gSum / kSum;
                if (gSum < 0)
                {
                    gSum = 0;
                }
                else if (gSum > 255)
                {
                    gSum = 255;
                }

                bSum = bSum / kSum;
                if (bSum < 0)
                {
                    bSum = 0;
                }
                else if (bSum > 255)
                {
                    bSum = 255;
                }



                int aperturePosX = matrix.Count / 2;


                if (matrix.Count != 0 && matrix[aperturePosX].Count / 2 != 0)
                {
                    int aperturePosY = matrix[aperturePosX].Count / 2;

                    Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                    if (colorChannelIndex == 0)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, (int)gSum, (int)bSum));
                    }
                    else if (colorChannelIndex == 1)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb((int)rSum, oldColor.G, oldColor.B));
                    }
                    else if (colorChannelIndex == 2)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, (int)gSum, oldColor.B));
                    }
                    else if (colorChannelIndex == 3)
                    {
                        rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, (int)bSum));
                    }
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 6
0
        public Bitmap applyMedianFilter(string colorMode, Bitmap image, Point imageSize, Point filterSize, int colorChannelIndex = 0)
        {
            Bitmap rezult = new Bitmap(image);

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            List <int> redList   = new List <int>();
            List <int> greenList = new List <int>();
            List <int> blueList  = new List <int>();

            for (int x = 0; x < apertures.Count; x++)
            {
                redList.Clear();
                blueList.Clear();
                greenList.Clear();

                List <List <Point> > matrix = apertures[x].matrix;
                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        Color color = image.GetPixel(pixelPosX, pixelPosY);
                        redList.Add(color.R);
                        greenList.Add(color.G);
                        blueList.Add(color.B);
                    }
                }

                redList.Sort();
                greenList.Sort();
                blueList.Sort();

                int apertureCenter = redList.Count / 2;
                int rValue         = redList[apertureCenter];
                int gValue         = greenList[apertureCenter];
                int bValue         = blueList[apertureCenter];

                int aperturePosX = matrix.Count / 2;
                int aperturePosY = matrix[aperturePosX].Count / 2;

                Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                if (colorChannelIndex == 0)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rValue, gValue, bValue));
                }
                else if (colorChannelIndex == 1)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rValue, oldColor.G, oldColor.B));
                }
                else if (colorChannelIndex == 2)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, gValue, oldColor.B));
                }
                else if (colorChannelIndex == 3)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, bValue));
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 7
0
        public Bitmap applyBernzenThersholding(Bitmap image, Point imageSize, Point filterSize, bool convert = true)
        {
            Bitmap rezult = new Bitmap(image);
            Bitmap tempImage;

            if (convert)
            {
                tempImage = convertImageToGrayscale(image);
            }
            else
            {
                tempImage = new Bitmap(image);
            }

            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, filterSize);

            for (int x = 0; x < apertures.Count; x++)
            {
                int    minValue = 255, maxValue = 0;
                double average;

                List <List <Point> > matrix = apertures[x].matrix;
                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;

                        //т.к. картинка черно белая, то значения РГБ одинаковы, можно брыть любое из трех.
                        if (tempImage.GetPixel(pixelPosX, pixelPosY).R > maxValue)
                        {
                            maxValue = tempImage.GetPixel(pixelPosX, pixelPosY).R;
                        }
                        if (tempImage.GetPixel(pixelPosX, pixelPosY).R < minValue)
                        {
                            minValue = tempImage.GetPixel(pixelPosX, pixelPosY).R;
                        }
                    }
                }
                average = ((double)minValue + maxValue) / 2;

                foreach (var matrixLine in matrix)
                {
                    foreach (var Point in matrixLine)
                    {
                        int pixelPosX = Point.X;
                        int pixelPosY = Point.Y;


                        if (tempImage.GetPixel(pixelPosX, pixelPosY).R < average)
                        {
                            rezult.SetPixel(pixelPosX, pixelPosY, Color.FromArgb(0, 0, 0));
                        }
                        else
                        {
                            rezult.SetPixel(pixelPosX, pixelPosY, Color.FromArgb(255, 255, 255));
                        }
                    }
                }
            }

            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }
Exemplo n.º 8
0
        public static Bitmap applyDillation(string colorModelTag, int colorChannelIndex, Bitmap image, Point imageSize, List <List <bool> > mask, Point maskSize)
        {
            Bitmap          rezult  = new Bitmap(image);
            ApertureService service = new ApertureService();

            List <Aperture> apertures = service.getApertureMatrixGenerator(imageSize, maskSize);

            for (int x = 0; x < apertures.Count; x++)
            {
                int rMax = 0, gMax = 0, bMax = 0;

                List <List <Point> > matrix = apertures[x].matrix;
                int i = 0, j = 0;
                foreach (var matrixLine in matrix)
                {
                    j = 0;
                    foreach (var Point in matrixLine)
                    {
                        int   pixelPosX = Point.X;
                        int   pixelPosY = Point.Y;
                        Color color     = image.GetPixel(pixelPosX, pixelPosY);
                        if (mask[i][j] == true)
                        {
                            if (color.R > rMax)
                            {
                                rMax = color.R;
                            }
                            if (color.G > gMax)
                            {
                                gMax = color.G;
                            }
                            if (color.B > bMax)
                            {
                                bMax = color.B;
                            }
                        }
                        j++;
                    }
                    i++;
                }

                int aperturePosX = matrix.Count / 2;
                int aperturePosY = matrix[aperturePosX].Count / 2;


                Color oldColor = image.GetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y);

                if (colorChannelIndex == 0)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rMax, gMax, bMax));
                }
                else if (colorChannelIndex == 1)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(rMax, oldColor.G, oldColor.B));
                }
                else if (colorChannelIndex == 2)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, gMax, oldColor.B));
                }
                else if (colorChannelIndex == 3)
                {
                    rezult.SetPixel(matrix[aperturePosX][aperturePosY].X, matrix[aperturePosX][aperturePosY].Y, Color.FromArgb(oldColor.R, oldColor.G, bMax));
                }
            }


            service = null;
            for (int i = 0; i < apertures.Count; i++)
            {
                apertures[i].Dispose();
            }
            apertures.Clear();

            return(rezult);
        }