Аппроксимация\Интерполяция массива координат

List<Point> GetSmoothedPoints(IList<Point> inputPoints)
{
List<Point> points = new List<Point>{inputPoints[0]};
int start = 0;
int end = 2;
const double maxError = 1;
 
while(end < inputPoints.Count)
{
      while(end <inputPoints.Count && GetError(inputPoints, start, end) < maxError) end++;
      start = end - 1;
      if(end < inputPoints.Count) points.Add(inputPoints[start]);
      end++;
}
points.Add(inputPoints.Last());
return points;
}
 
// Функция определяющая погрешность приближения диапазона точек inputPoints отрезком отрезком 
// от start до end
double  GetError(IList<Point> inputPoints, int start,int end)
{
///
}

        public class Point 
        {
            public double lat {get; set;}
            public double lng {get; set;}
        }

        public static List<Point> GetListPoints()
        {
            List<Point> Points = new List<Point>();
            string[] s = System.IO.File.ReadAllLines("4.txt");
            for (int i = 0; i < s.Length; i++)
            {
                string[] split = s[i].Split(',');
                Point point = new Point();
                point.lat = Convert.ToDouble(split[0] + "," + split[1]);
                point.lng = Convert.ToDouble(split[2] + "," + split[3]);
                Points.Add(point);
            }
            return Points;
        }

 private static List<Point> GDouglasPeucker(List<Point> source, int kink)
        {
            int n_source, n_stack, n_dest, start, end, i, sig;
            double dev_sqr, max_dev_sqr, band_sqr;
            double x12, y12, d12, x13, y13, d13, x23, y23, d23;
            var F = ((Math.PI / 180.0) * 0.5);
            int[] index;
            int[] sig_start; 
            int[] sig_end;
 
            if (source.Count < 3) return (source);
 
            n_source = source.Count;
            band_sqr = kink * 360.0 / (2.0 * Math.PI * 6378137.0);
            band_sqr *= band_sqr;
            n_dest = 0;
            sig_start = new int[source.Count];
            sig_end = new int[source.Count];
            index = new int[source.Count];
            sig_start[0] = 0;
            sig_end[0] = n_source - 1;
            n_stack = 1;
 
            while (n_stack > 0) {
 
                start = sig_start[n_stack - 1];
                end = sig_end[n_stack - 1];
                n_stack--;
 
                if ((end - start) > 1)
                {
                    x12 = (source[end].lng - source[start].lng);
                    y12 = (source[end].lat - source[start].lat);
                    if (Math.Abs(x12) > 180.0)
                    x12 = 360.0 - Math.Abs(x12);
                    x12 *= Math.Cos(F * (source[end].lat + source[start].lat));
                    d12 = (x12 * x12) + (y12 * y12);
 
                    for (i = start + 1, sig = start, max_dev_sqr = -1.0; i < end; i++)
                    {
                        x13 = (source[i].lng - source[start].lng);
                        y13 = (source[i].lat - source[start].lat);
                        if (Math.Abs(x13) > 180.0)
                        x13 = 360.0 - Math.Abs(x13);
                        x13 *= Math.Cos(F * (source[i].lat + source[start].lat));
                        d13 = (x13 * x13) + (y13 * y13);
                        x23 = (source[i].lng - source[end].lng);
                        y23 = (source[i].lat - source[end].lat);
                        if (Math.Abs(x23) > 180.0)
                        x23 = 360.0 - Math.Abs(x23);
                        x23 *= Math.Cos(F * (source[i].lat + source[end].lat));
                        d23 = (x23 * x23) + (y23 * y23);
 
                        if (d13 >= (d12 + d23))
                            dev_sqr = d23;
                        else if (d23 >= (d12 + d13))
                            dev_sqr = d13;
                        else
                            dev_sqr = (x13 * y12 - y13 * x12) * (x13 * y12 - y13 * x12) / d12;// solve triangle
 
                        if (dev_sqr > max_dev_sqr)
                        {
                            sig = i;
                            max_dev_sqr = dev_sqr;
                        }
                    }
 
                    if (max_dev_sqr < band_sqr)
                    {   
                        index[n_dest] = start;
                        n_dest++;
                    }
                    else
                    {
                        n_stack++;
                        sig_start[n_stack - 1] = sig;
                        sig_end[n_stack - 1] = end;
                        n_stack++;
                        sig_start[n_stack - 1] = start;
                        sig_end[n_stack - 1] = sig;
                    }
                }
                else
                {
                    index[n_dest] = start;
                    n_dest++;
                }
            }
            index[n_dest] = n_source - 1;
            n_dest++;
            List<Point> r = new List<Point>();
            for (i = 0; i < n_dest; i++)
                r.Add(source[index[i]]);
            return r;
        }