c# - sacar - Calcular las coordenadas de los vértices de un polígono regular.

como sacar el area de un poligono

Question

Estoy escribiendo un programa en el que necesito dibujar polígonos de un número arbitrario de lados, cada uno traducido por una fórmula dada que cambia dinámicamente. Hay algunas matemáticas bastante interesantes involucradas pero estoy atascado en este problema.

¿Cómo puedo calcular las coordenadas de los vértices de un polígono regular (uno en el que todos los ángulos son iguales), dado solo el número de lados , e idealmente (pero no necesariamente) teniendo el origen en el centro?

Por ejemplo: un hexágono puede tener los siguientes puntos (todos son float ):

( 1.5  ,  0.5 *Math.Sqrt(3) )
( 0    ,  1   *Math.Sqrt(3) )
(-1.5  ,  0.5 *Math.Sqrt(3) )
(-1.5  , -0.5 *Math.Sqrt(3) )
( 0    , -1   *Math.Sqrt(3) )
( 1.5  , -0.5 *Math.Sqrt(3) )

Mi método se ve así:

void InitPolygonVertexCoords(RegularPolygon poly)

y las coordenadas deben agregarse a esto (o algo similar, como una lista):

Point[] _polygonVertexPoints;

Estoy interesado principalmente en el algoritmo aquí, pero los ejemplos en C # serían útiles. Ni siquiera sé por dónde empezar. ¿Cómo debo implementarlo? ¿Es incluso posible?

Gracias.

Answer 1

Diga que la distancia de los vértices al origen es 1. Y digamos que (1, 0) siempre es una coordenada del polígono.

Dado el número de vértices (por ejemplo, n), el ángulo de rotación requerido para posicionar (1, 0) en la siguiente coordenada sería (360 / n).

El cálculo requerido aquí es rotar las coordenadas. Aquí está lo que es; Matriz de Rotación .

Di theta = 360 / n;

[cos(theta) -sin(theta)]
[sin(theta) cos(theta)]

Sería tu matriz de rotación.

Si conoces el álgebra lineal ya sabes a qué me refiero. Si no tienes solo un vistazo a la multiplicación de matrices

Answer 2

El método simple es: Tomemos N-gone (número de lados) y la longitud del lado L. El ángulo será T = 360 / N. Digamos que uno de los vértices se encuentra en el origen.

* First vertex = (0,0)
* Second vertex = (LcosT,LsinT)
* Third vertex = (LcosT+Lcos2T, LsinT+Lsin2T)
* Fourth vertex = (LcosT+Lcos2T+Lcos3T, LsinT+Lsin2T+Lsin3T)

Usted puede hacer en para bucle

Answer 3

El número de puntos es igual al número de lados.

El ángulo que necesitas es angle = 2 * pi / numPoints .

Luego, comience verticalmente sobre el origen con el tamaño del polígono dado por el radius :

for (int i = 0; i < numPoints; i++)
{
    x = centreX + radius * sin(i * angle);
    y = centreY + radius * cos(i * angle);
}

Si su centro es el origen, simplemente ignore los términos centreX y centreY , ya que serán 0,0.

Al cambiar el cos y el sin , el primer punto apuntará horizontalmente a la derecha del origen.

Answer 4

Lo siento, no tengo una solución completa a la mano en este momento, pero deberías intentar buscar la representación en 2D de círculos. Todas las implementaciones clásicas de círculo (x, y, r) usan un polígono como el que describiste para el dibujo (pero con más de 50 lados).

Answer 5

Una posible implementación para generar un conjunto de coordenadas para un polígono regular es:

Define polígono centro , radio y primer vértice ¹ .
Gire el vértice n-veces ² en un ángulo de: 360 / n.

En esta implementación, uso un vector para almacenar las coordenadas generadas y una función recursiva para generarlas:

void generateRegularPolygon(vector<Point>& v, Point& center, int sidesNumber, int radius){
    // converted to radians
    double angRads = 2 * PI / double(sidesNumber);
    // first vertex  
    Point initial(center.x, center.y - radius);
    rotateCoordinate(v, center, initial, angRads, sidesNumber);
}

dónde:

void rotateCoordinate(vector<Point>& v, Point& axisOfRotation, Point& initial, double angRads, int numberOfRotations){
    // base case: number of transformations < 0
    if(numberOfRotations <= 0) return;
    else{
        // apply rotation to: initial, around pivot point: axisOfRotation
        double x = cos(angRads) * (initial.x - axisOfRotation.x) - sin(angRads) * (initial.y - axisOfRotation.y) + axisOfRotation.x;
        double y = sin(angRads) * (initial.x - axisOfRotation.x) + cos(angRads) * (initial.y - axisOfRotation.y) + axisOfRotation.y;
        // store the result
        v.push_back(Point(x, y));
        rotateCoordinate(v, axisOfRotation, Point(x,y), angRads, --numberOfRotations);
    }
}

Nota:

Point es una clase simple para envolver la coordenada en una estructura de datos única:

class Point{
public:
    Point(): x(0), y(0){ }
    Point(int xx, int yy): x(xx), y(yy) { }
private:
    int x;
    int y; 
}; 

^{1 en términos de (relativo a) el centro, el radio. En mi caso, el primer vértice se traduce desde el centro hacia arriba horizontalmente por la longitud del radio.}

^{2 n-polígono regular tiene n vértices.}

Answer 6

hmm, si prueba todas las versiones que se enumeran aquí, verá que la implementación no es buena. Puede verificar la distancia desde el centro a cada punto generado del polígono con: http://www.movable-type.co.uk/scripts/latlong.html

Ahora he buscado mucho y no pude encontrar ninguna buena implementación para calcular un polígono usando el centro y el radio ... así que volví al libro de matemáticas e intenté implementarlo yo mismo. Al final se me ocurrió esto ... que es 100% bueno:

            List<double[]> coordinates = new List<double[]>();
            #region create Polygon Coordinates
            if (!string.IsNullOrWhiteSpace(bus.Latitude) && !string.IsNullOrWhiteSpace(bus.Longitude) && !string.IsNullOrWhiteSpace(bus.ListingRadius))
            {
                double lat = DegreeToRadian(Double.Parse(bus.Latitude));
                double lon = DegreeToRadian(Double.Parse(bus.Longitude));
                double dist = Double.Parse(bus.ListingRadius);
                double angle = 36;

                for (double i = 0; i <= 360; i += angle)
                {
                    var bearing = DegreeToRadian(i);

                    var lat2 = Math.Asin(Math.Sin(lat) * Math.Cos(dist / earthRadius) + Math.Cos(lat) * Math.Sin(dist / earthRadius) * Math.Cos(bearing));
                    var lon2 = lon + Math.Atan2(Math.Sin(bearing) * Math.Sin(dist / earthRadius) * Math.Cos(lat),Math.Cos(dist / earthRadius) - Math.Sin(lat) * Math.Sin(lat2));

                    coordinates.Add(new double[] { RadianToDegree(lat2), RadianToDegree(lon2) });

                }

                poly.Coordinates = new[] { coordinates.ToArray() };
            }
            #endregion

Si prueba esto, verá que todos los puntos están a la distancia exacta que usted le da (radio). Tampoco te olvides de declarar la tierraRadio.

private const double earthRadius = 6371.01;

Esto calcula las coordenadas de un decágono. Usted ve que el ángulo utilizado es de 36 grados. Puede dividir 360 grados a cualquier número de lados que desee y colocar el resultado en la variable de ángulo. De todos modos .. espero que esto te ayude @rmx!

Answer 7

for (i = 0; i < n; i++) {
  printf("%f %f/n",r * Math.cos(2 * Math.PI * i / n), r * Math.sin(2 * Math.PI * i / n));
}

donde r es el radio del círculo circunscrito. Perdón por el lenguaje equivocado No Habla C #.

Básicamente, el ángulo entre dos vértices cualquiera es 2 pi / n y todos los vértices están a una distancia r del origen.

EDITAR: Si desea tener el centro en otro lugar que no sea el origen, diga en (x, y)

for (i = 0; i < n; i++) {
  printf("%f %f/n",x + r * Math.cos(2 * Math.PI * i / n), y + r * Math.sin(2 * Math.PI * i / n));
}