C# Image.GetPixelColor方法代码示例

        private static List<Point> FindNeighbours(Image image, Point p)
        {
            List<Point> neighbours = new List<Point>();

            //West
            if (!(p.X - 1 < 0))
            {
                if (image.GetPixelColor(p.X - 1, p.Y) == Image.Black) neighbours.Add(new Point(p.X - 1, p.Y));
            }

            //North
            if (!(p.Y - 1 < 0))
            {
                if (image.GetPixelColor(p.X, p.Y - 1) == Image.Black) neighbours.Add(new Point(p.X, p.Y - 1));
            }

            //East
            if (!(p.X + 1 >= image.Size.Width))
            {
                if (image.GetPixelColor(p.X + 1, p.Y) == Image.Black) neighbours.Add(new Point(p.X + 1, p.Y));
            }

            //South
            if (!(p.Y + 1 >= image.Size.Height))
            {
                if (image.GetPixelColor(p.X, p.Y + 1) == Image.Black) neighbours.Add(new Point(p.X, p.Y + 1));
            }

            return neighbours;
        }

 private static int CalculateNewPixelValue(int x, int y, int layer, Image image)
 {
     int[] values = new int[8];
     List<Point> neighbours = FindNeighbours(image, layer, new Point(x, y));
     int counter = 0;
     foreach(Point p in neighbours)
     {
         if(image.GetPixelColor(p.X, p.Y) == Image.Black) counter += 1;
     }
     return (counter >= neighbours.Count/2) ? Image.Black : Image.White;
 }

        public void ApplyKernel(Image image, Kernel kernel)
        {
            int[,] currentPixels = image.GetPixels();
            int[,] newPixels = new int[image.Size.Width, image.Size.Height];

            //kernel information
            int kernelWidth = kernel.kernelSize.Width;
            int kernelHeight = kernel.kernelSize.Height;
            int middelPixelIndexWidth = kernelWidth / 2;
            int middelPixelIndexHeight = kernelHeight / 2;

            //Loop through the image
            for (int x = 0; x < image.Size.Width; x++)
            {
                for (int y = 0; y < image.Size.Height; y++)
                {
                    newPixels[x, y] = currentPixels[x, y];//current quickfix untill the proper kernel-out-of-bounce-code is implemented. This line adds an initial value of the current pixel, based on the original image.

                    //Determin kernel's position, based on current pixel
                    int kernelStartPositionX = x - middelPixelIndexWidth;
                    int kernelStartPositionY = y - middelPixelIndexHeight;

                    //variable to store the new values that are being calculated
                    double ColourValue = 0;

                    //checks if the kernel isn't out of bounce
                    if (kernelStartPositionX < 0 || kernelStartPositionY < 0) continue;
                    if (kernelStartPositionX + kernel.kernelSize.Width > image.Size.Width || kernelStartPositionY + kernel.kernelSize.Height > image.Size.Height) continue;
                    //todo: change code so it will do something other then just 'not'changing the pixel, when the kernel is ou tof bounce

                    //Loop through the kernel
                    for (int k = 0; k < kernelWidth; k++)
                    {
                        for (int l = 0; l < kernelHeight; l++)
                        {
                            //Get the current kernel's position's color-value
                            int pixelColor = image.GetPixelColor(kernelStartPositionX + k, kernelStartPositionY + l);
                            ColourValue += (pixelColor * (kernel.GetValue(l, k) * kernel.multiplier)); //calculates the value that has to be added, based on the kernel value and multiplier
                        }
                    }

                    newPixels[x, y] = (int)(ColourValue); //sets new value

                }
            }

            image.SetPixels(newPixels);
        }

        /// <summary>
        /// Calculate the Perimeter (the total length of the object boundary)
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static float Calculate(Image image)
        {
            float perimeter = 0;//Variable that holds our current length
            Point p = Toolbox.FindFirstPixel(image); //find the first pixel so we can loop through the edge/pixels of our object
            if (image.GetPixelColor(p.X, p.Y) == Image.White) return 0;//In case we found an empty starting point

            int[,] visited = new int[image.Size.Width, image.Size.Height];//array that represents visited pixels

            Stack<Point> toVisit = new Stack<Point>(); //stack with points that we still have to visit
            toVisit.Push(p);

            //While we still have to visit pixels:
            //Loop through those pixels. If they are near the edge, add a value to our perimeter and check if it has neighbours that we still have to visit.
            while (toVisit.Count > 0)
            {
                Point point = toVisit.Pop();

                if (HasVisited(ref visited, point)) //did we already visit this pixel?
                {
                    continue;
                }

                Visit(ref visited, point); //mark this pixel as visited

                List<Point> neighbours = FindNeighbours(image, point); //find black neighbours
                if (neighbours.Count >= 4) continue;//If this pixel is surrounded by black pixels, ignore it
                foreach (Point n in neighbours)
                {
                    if (!HasVisited(ref visited, n))
                    {
                        toVisit.Push(n); //push neighbours only if we havent visit them yet
                    }
                }
                perimeter += (4 - neighbours.Count); //4 possible neighbours, but the list contains the black ones, so this will add the white ones.
            }
            return perimeter;
        }

        /// <summary>
        /// Returns a list of pixels that represent the border of an item
        /// </summary>
        /// <param name="image">target item</param>
        /// <returns>list of points that represent the border of the item</returns>
        public static List<Point> OuterPoints(Image image)
        {
            List<Point> coordinates = new List<Point>();
            Point p = Toolbox.FindFirstPixel(image);
            if (image.GetPixelColor(p.X, p.Y) == Image.White) return coordinates;//In case we found an empty starting point

            int[,] visited = new int[image.Size.Width, image.Size.Height];
            Stack<Point> toVisit = new Stack<Point>();
            toVisit.Push(p);

            while (toVisit.Count > 0)
            {
                Point point = toVisit.Pop();

                if (HasVisited(ref visited, point))
                {
                    continue;
                }

                Visit(ref visited, point);
                coordinates.Add(point);
                //ObjectOuterPixels.SaveOuterPixelsAsImage(coordinates, image.Size);//uncomment this to view each step :D

                List<Point> neighbours = FindNeighbours(image, point); //find black neighbours
                if (neighbours.Count >= 8) continue;
                foreach (Point n in neighbours)
                {
                    if (!HasVisited(ref visited, n))
                    {
                        toVisit.Push(n);
                    }
                }
            }
            //ObjectOuterPixels.SaveOuterPixelsAsImage(coordinates, image.Size);//uncomment this to view result

            return coordinates;
        }