五点光滑法

class Cal
    {
        //闭合计算补充点 首尾补充
        public void addPoints1(List<Data> data)
        {
            data.Insert(0, data[13]);
            data.Insert(0, data[13]);
            data.Add(data[2]);
            data.Add(data[3]);
            data.Add(data[4]);
        }

        //不闭合计算补充点 首尾补充
        public void addPoints2(List<Data> data)
        {
            double A_X = 3 * data[0].X - 3 * data[1].X + data[2].X;
            double A_Y = 3 * data[0].Y - 3 * data[1].Y + data[2].Y;
            Data A = new Data("A", A_X, A_Y);

            double B_X = 3 * A_X - 3 * data[0].X + data[1].X;
            double B_Y = 3 * A_Y - 3 * data[0].Y + data[1].Y;
            Data B = new Data("B", B_X, B_Y);

            double C_X = 3 * data[13].X - 3 * data[12].X + data[11].X;
            double C_Y = 3 * data[13].Y - 3 * data[12].Y + data[11].Y;
            Data C = new Data("C", C_X, C_Y);

            double D_X = 3 * C_X - 3 * data[13].X + data[12].X;
            double D_Y = 3 * C_Y - 3 * data[13].Y + data[12].Y;
            Data D = new Data("D", D_X, D_Y);

            data.Insert(0, A);
            data.Insert(0, B);
            data.Add(C);
            data.Add(D);
        }

        public List<Result> calGradient(List<Data> data)
        {
            List<Result> result = new List<Result>();
            for (int i = 0; i < data.Count() - 4; i++)
            {
                double a1 = data[i - 1 + 2].X - data[i - 2 + 2].X;
                double a2 = data[i + 2].X - data[i - 1 + 2].X;
                double a3 = data[i + 1 + 2].X - data[i + 2].X;
                double a4 = data[i + 2 + 2].X - data[i + 1 + 2].X;

                double b1 = data[i - 1 + 2].Y - data[i - 2 + 2].Y;
                double b2 = data[i + 2].Y - data[i - 1 + 2].Y;
                double b3 = data[i + 1 + 2].Y - data[i + 2].Y;
                double b4 = data[i + 2 + 2].Y - data[i + 1 + 2].Y;

                double w2 = Math.Abs(a3 * b4 - a4 * b3);
                double w3 = Math.Abs(a1 * b2 - a2 * b1);

                double a0 = w2 * a2 + w3 * a3;
                double b0 = w2 * b2 + w3 * b3;

                double cos_sita = a0 / Math.Sqrt(a0 * a0 + b0 * b0);
                double sin_sita = b0 / Math.Sqrt(a0 * a0 + b0 * b0);
                Result re = new Result(cos_sita, sin_sita);
                result.Add(re);
            }
            return result;
        }

        public List<InsertPoint> calParam(List<Data> data, List<Result> result)
        {
            List<InsertPoint> insertpoint = new List<InsertPoint>();
            for (int i = 0; i < data.Count() - 5; i++)
            {
                double r = Math.Sqrt(Math.Pow(data[i + 1 + 2].X - data[i + 2].X, 2) + Math.Pow(data[i + 1 + 2].Y - data[i + 2].Y, 2));
                double E0 = data[i + 2].X;
                double E1 = r * result[i].cos_sita;
                double E2 = 3 * (data[i + 1 + 2].X - data[i + 2].X) - r * (result[i + 1].cos_sita + 2 * result[i].cos_sita);
                double E3 = -2 * (data[i + 1 + 2].X - data[i + 2].X) + r * (result[i + 1].cos_sita + result[i].cos_sita);

                double F0 = data[i + 2].Y;
                double F1 = r * result[i].sin_sita;
                double F2 = 3 * (data[i + 1 + 2].Y - data[i + 2].Y) - r * (result[i + 1].sin_sita + 2 * result[i].sin_sita);
                double F3 = -2 * (data[i + 1 + 2].Y - data[i + 2].Y) + r * (result[i + 1].sin_sita + result[i].sin_sita);

                double z = 0.1;
                //double x = E0 + E1 * z + E2 * z * z + E3 * z * z * z;
                //double y = F0 + F1 * z + F2 * z * z + F3 * z * z * z;
                double m = 1 / z;
                for (int j = 0; j < m; j++)
                {
                    double x = E0 + E1 * z + E2 * z * z + E3 * z * z * z;
                    double y = F0 + F1 * z + F2 * z * z + F3 * z * z * z;
                    z += 0.1;
                    InsertPoint ip = new InsertPoint(x, y);
                    insertpoint.Add(ip);
                }
            }
            return insertpoint;
        }
    }

主要计算类的实现过程。