Cómo calcular el centroide

Estoy trabajando con formas geoespaciales y mirando el algoritmo de centroide aquí,

http: //en.wikipedia.org/wiki/Centroid#Centroid_of_polygo

He implementado el código en C # como este (que es solo esto adaptado),

¿Encontrar el centroide de un polígono?

class Program
{
    static void Main(string[] args)
    {
        List<Point> vertices = new List<Point>();

        vertices.Add(new Point() { X = 1, Y = 1 });
        vertices.Add(new Point() { X = 1, Y = 10 });
        vertices.Add(new Point() { X = 2, Y = 10 });
        vertices.Add(new Point() { X = 2, Y = 2 });
        vertices.Add(new Point() { X = 10, Y = 2 });
        vertices.Add(new Point() { X = 10, Y = 1 });
        vertices.Add(new Point() { X = 1, Y = 1 });

        Point centroid = Compute2DPolygonCentroid(vertices);
    }

    static Point Compute2DPolygonCentroid(List<Point> vertices)
    {
        Point centroid = new Point() { X = 0.0, Y = 0.0 };
        double signedArea = 0.0;
        double x0 = 0.0; // Current vertex X
        double y0 = 0.0; // Current vertex Y
        double x1 = 0.0; // Next vertex X
        double y1 = 0.0; // Next vertex Y
        double a = 0.0;  // Partial signed area

        // For all vertices except last
        int i=0;
        for (i = 0; i < vertices.Count - 1; ++i)
        {
            x0 = vertices[i].X;
            y0 = vertices[i].Y;
            x1 = vertices[i+1].X;
            y1 = vertices[i+1].Y;
            a = x0*y1 - x1*y0;
            signedArea += a;
            centroid.X += (x0 + x1)*a;
            centroid.Y += (y0 + y1)*a;
        }

        // Do last vertex
        x0 = vertices[i].X;
        y0 = vertices[i].Y;
        x1 = vertices[0].X;
        y1 = vertices[0].Y;
        a = x0*y1 - x1*y0;
        signedArea += a;
        centroid.X += (x0 + x1)*a;
        centroid.Y += (y0 + y1)*a;

        signedArea *= 0.5;
        centroid.X /= (6*signedArea);
        centroid.Y /= (6*signedArea);

        return centroid;
    }
}

public class Point
{
    public double X { get; set; }
    public double Y { get; set; }
}

El problema es que este algoritmo cuando tengo esta forma (que es una forma de L),

(1,1) (1,10) (2,10) (2,2) (10,2) (10,1) (1,1)

Me da el resultado (3.62, 3.62). Lo cual está bien, excepto que ese punto está fuera de la forma. ¿Existe otro algoritmo que tenga esto en cuenta?

Básicamente, una persona va a dibujar una forma en un mapa. Esta forma podría abarcar múltiples caminos (por lo que podría ser una forma de L) y quiero trabajar en el centro de la forma. Esto es para que pueda calcular el nombre del camino en ese punto. No tiene sentido para mí que esté fuera de la forma si han dibujado una forma de L larga y delgada.