帮我用c#这一个有内轮廓和外轮廓的填充算法

以下是一个使用C#编写的有内轮廓和外轮廓的填充算法示例：

using System;
using System.Collections.Generic;

namespace FillAlgorithm
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建一个包含内轮廓和外轮廓的多边形
            List<Point> polygon = new List<Point>();
            polygon.Add(new Point(0, 0));
            polygon.Add(new Point(0, 5));
            polygon.Add(new Point(5, 5));
            polygon.Add(new Point(5, 0));
            polygon.Add(new Point(2.5f, 2.5f));
            polygon.Add(new Point(3.5f, 2.5f));
            polygon.Add(new Point(3.5f, 3.5f));
            polygon.Add(new Point(2.5f, 3.5f));

            // 填充多边形
            List<Point> filledPolygon = FillPolygon(polygon);

            // 输出填充后的多边形顶点坐标
            Console.WriteLine("Filled Polygon:");
            foreach (Point p in filledPolygon)
            {
                Console.WriteLine("(" + p.X + ", " + p.Y + ")");
            }
        }

        // 有内轮廓和外轮廓的多边形填充算法
        static List<Point> FillPolygon(List<Point> polygon)
        {
            // 填充后的多边形顶点列表
            List<Point> filledPolygon = new List<Point>();

            // 计算多边形的最小外接矩形
            float minX = float.MaxValue;
            float maxX = float.MinValue;
            float minY = float.MaxValue;
            float maxY = float.MinValue;
            foreach (Point p in polygon)
            {
                if (p.X < minX) minX = p.X;
                if (p.X > maxX) maxX = p.X;
                if (p.Y < minY) minY = p.Y;
                if (p.Y > maxY) maxY = p.Y;
            }

            // 遍历最小外接矩形内的每个像素，判断像素是否在多边形内部
            for (int y = (int)minY; y <= (int)maxY; y++)
            {
                for (int x = (int)minX; x <= (int)maxX; x++)
                {
                    Point p = new Point(x, y);

                    // 判断像素是否在多边形内部
                    if (IsPointInPolygon(p, polygon))
                    {
                        filledPolygon.Add(p);
                    }
                }
            }

            return filledPolygon;
        }

        // 判断点是否在多边形内部
        static bool IsPointInPolygon(Point p, List<Point> polygon)
        {
            int count = 0;
            int n = polygon.Count;

            for (int i = 0; i < n; i++)
            {
                Point p1 = polygon[i];
                Point p2 = polygon[(i + 1) % n];

                // 判断点是否在线段上
                if (p.X >= Math.Min(p1.X, p2.X) && p.X <= Math.Max(p1.X, p2.X) &&
                    p.Y >= Math.Min(p1.Y, p2.Y) && p.Y <= Math.Max(p1.Y, p2.Y))
                {
                    // 计算点到线段的距离
                    float distance = Math.Abs((p2.X - p1.X) * (p1.Y - p.Y) - (p1.X - p.X) * (p2.Y - p1.Y)) / 
                        (float)Math.Sqrt(Math.Pow(p2.X - p1.X, 2) + Math.Pow(p2.Y - p1.Y, 2));

                    // 如果距离小于等于1个像素，则认为点在线段上
                    if (distance <= 1)
                    {
                        return true;
                    }
                }

                // 判断线段和水平线的交点个数
                if (p1.Y == p2.Y) continue;
                if (p.Y < Math.Min(p1.Y, p2.Y) || p.Y > Math.Max(p1.Y, p2.Y)) continue;
                float x = (float)(p.Y - p1.Y) * (p2.X - p1.X) / (p2.Y - p1.Y) + p1.X;
                if (x > p.X) count++;
            }

            // 如果交点个数为奇数，则点在多边形内部
            if (count % 2 == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    // 二维坐标点结构体
    struct Point
    {
        public float X { get; set; }
        public float Y { get; set; }

        public Point(float x, float y)
        {
            X = x;
            Y = y;
        }
    }
}

该算法的基本思路是遍历多边形最小外接矩形内的每个像素，判断像素是否在多边形内部。判断像素是否在多边形内部的方法是计算像素到多边形每条边的距离，并判断是否在边上，然后判断交点的个数。如果交点个数为奇数，则认为点在多边形内部。