Comment Calculer le Centre de gravité

Je travaille avec des formes géospatiales et de la recherche au centre de gravité de l'algorithme ici,

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

J'ai mis en place le code en C# comme ceci (qui est juste de ce adapté),

Trouver le centre de gravité d'un polygone?

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; }
}

Le problème est que cet algorithme lorsque j'ai cette forme (qui est en forme de L),

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

Il me donne le résultat (3.62, 3.62). Qui est OK, sauf que le point est à l'extérieur de la forme. Est-il un autre algorithme, autour de qui le prend en compte?

Fondamentalement, une personne va être en dessiner une forme sur une carte. Cette forme peut s'étaler sur plusieurs routes (et pourrait donc être une forme L) et je veux travailler sur le centre de la forme. Il en est ainsi, je peux travailler sur le nom de la route à ce point. Ça n'a pas de sens pour moi, pour être à l'extérieur de la forme si ils en ont tiré une longue skinny forme L.

Le centre de gravité d'un polygone n'a pas à être à l'intérieur. C'est seulement garanti à appliquer pour convexe polygones.
Oui l'algorithme est correct, je suis d'accord, mais est-il un autre algorithme qui permettra de s'assurer qu'un point dans le polygone est-il calculé? Idéalement, le résultat de la forme ci-dessus (1.5, 1.5).
Si elle fait sens pour votre problème, vous pouvez représenter les routes comme des lignes épaisses ou même de l'union ou des rectangles (il y en amenant de la notion d'axe). Votre centre est à mi-chemin de cet axe.
N'utilisez pas de point pour trouver le nom de la route. Il n'y aurait aucune garantie que le point soit assez proche de la route d'être décrites. La bonne chose à faire est de récupérer la route des segments de ligne dans ce domaine et de comprendre quel est le chemin qui a le plus de longueur dans le polygone.

OriginalL'auteur peter | 2012-03-22

  1. 1

    Je recommanderais de ne pas écrire vous-même et d'utiliser plutôt SharpMap

    http://sharpmap.codeplex.com/

    Ils ont fait un bon travail de donner à votre centroïdes (même doit être à l'intérieur) et tout un tas de davantage de fonctionnalités que vous pourriez vouloir.

    OriginalL'auteur TheSteve0

  2. 9

    Cette réponse est inspiré par la réponse par Jer2654 et cette source:
    http://coding-experiments.blogspot.com/2009/09/xna-quest-for-centroid-of-polygon.html

      ///<summary>
///Method to compute the centroid of a polygon. This does NOT work for a complex polygon.
///</summary>
///<param name="poly">points that define the polygon</param>
///<returns>centroid point, or PointF.Empty if something wrong</returns>
public static PointF GetCentroid(List<PointF> poly)
{
float accumulatedArea = 0.0f;
float centerX = 0.0f;
float centerY = 0.0f;
for (int i = 0, j = poly.Count - 1; i < poly.Count; j = i++)
{
float temp = poly[i].X * poly[j].Y - poly[j].X * poly[i].Y;
accumulatedArea += temp;
centerX += (poly[i].X + poly[j].X) * temp;
centerY += (poly[i].Y + poly[j].Y) * temp;
}
if (Math.Abs(accumulatedArea) < 1E-7f)
return PointF.Empty;  //Avoid division by zero
accumulatedArea *= 3f;
return new PointF(centerX / accumulatedArea, centerY / accumulatedArea);
}
    if (Math.Abs(accumulatedArea) < 1E-7f)
    Merci!!!! Vous ne comprenez pas bien la nécessité pour cela, mais je suppose que vous êtes de droite, et j'ai inclus votre suggestion dans ma réponse et dans ma propre utilisation de ce code, également une version de Java que j'utilise dans une application Android.
    Votre code fonctionne très bien, cependant si certains coordonnées sont négatifs, cela est nécessaire. Si il est garanti que chaque coordonnée est positif, il n'est pas nécessaire. Je vous remercie.

    OriginalL'auteur RenniePet

  3. 5

    Vous pouvez vérifier si .NET 4.5 DbSpatialServices fonctions, comme DbSpatialServices.GetCentroid

    OriginalL'auteur ITmeze

  4. 2
    public static Point GetCentroid( Point[ ] nodes, int count )
{
int x = 0, y = 0, area = 0, k;
Point a, b = nodes[ count - 1 ];
for( int i = 0; i < count; i++ )
{
a = nodes[ i ];
k = a.Y * b.X - a.X * b.Y;
area += k;
x += ( a.X + b.X ) * k;
y += ( a.Y + b.Y ) * k;
b = a;
}
area *= 3;
return ( area == 0 ) ? Point.Empty : new Point( x /= area, y /= area );
}
    code sans référence, la formule que vous utilisez, n'a pas de valeur
    Il semble que ce soit basé sur le même algorithme que celui utilisé ici: coding-experiments.blogspot.com/2009/09/...

    OriginalL'auteur Jer2654