language agnostic - ¿Cómo dibujar un polígono regular a un lado en coordenadas cartesianas?

language-agnostic polygon

Question

He estado tratando de averiguar cómo escribir un programa simple para calcular los puntos x, y para crear un polígono regular de n lados. ¿Puede alguien darme algunos ejemplos de código que no usen funciones preexistentes que dibujen polígonos? Quiero entender el proceso, que asumo es algo como esto:

1. elige un ángulo para comenzar desde un radio y un punto central
2. de alguna manera calcula la posición x, y a esa distancia del centro (¿cómo?)
3. divide 360 ​​por el número de lados, mueve esa distancia y dibuja la siguiente línea desde el primer punto x, y
4. continúa hasta que el ángulo = 360 dividido por ese número.

Suponiendo que mis suposiciones son correctas, lo principal es entender cómo calcular los puntos x, y.

Prefiera las respuestas en un Visual Basic (o incluso en un estilo antiguo de Microsoft / Atari / Commodore BASIC) o en un conjunto de pasos legibles para el ser humano en inglés. Si tiene que responder con una fórmula matemática, hágalo en un lenguaje de computadora para que pueda leerlo, incluso en C o C ++ Puedo averiguarlo, pero no sé cómo leer la notación matemática. El lenguaje que estoy usando es un lenguaje similar a Visual Basic que casi no tiene primitivas de gráficos que no sea el dibujo de líneas.

Answer 1

Aquí hay un programa completo de c ++ que imprime los puntos de un polígono regular. En este caso, p es el número de lados, r es el radio del polígono y d es la dirección o ángulo del primer punto desde el centro. Tal vez esto ayude.

//g++ ck.cpp -o ck && ./ck
#include <stdio.h>
#include <math.h>
int p=3; //number of sides
double r=1000,d=3/4.0;
int main()
{
int i=0;
double x,y,t;
while(i<p)
{
t=2*M_PI*((double)i/p+d);
x=cos(t)*r;
y=sin(t)*r;
printf("x%i:%f y%i:%f/n",i,x,i,y);
i++;
}
}

Answer 2

La respuesta "para n_sides:" es la más fácil. Para el tipo que sugirió que podría simplificar los cálculos mediante el uso de números complejos, casi todas las bibliotecas de matemáticas tienen rutinas basadas en tablas cos () y sin () con interpolación eficiente, por lo que no hay necesidad de profundizar en soluciones relativamente poco claras. Por lo general, se puede inicializar un n-gon regular y se puede usar la escala de hardware de OpenGL para escalarlo / transformarlo para cualquier instancia en particular.

Si quieres ser duro al respecto, pre-genera todos los n-gons que necesitas y cárgalos en buffers de vértice.

A un lado, aquí está la solución anterior en Lua. Simplemente imprime las coordenadas, pero, por supuesto, puede devolver las coordenadas en una matriz / tabla. Las coordenadas devueltas se pueden usar para inicializar una primitiva de malla OpenGL GL_LINE_LOOP.

require ''math''
-- computes coordinates for n-sided, regular polygon of given radius and start angle
-- all values are in radians
function polypoints(sides, radius, start)
local x_center = 0.0
local y_center = 0.0
local angle = start
local angle_increment = 2 * math.pi / sides
local x=0.0
local y=0.0
print(string.format("coordinates for a %d sided regular polygon of radius %d/nVertex",sides,radius),"X"," ","Y")
for i=1,sides do
x = x_center + radius * math.cos(angle)
y = y_center + radius * math.sin(angle)
print(string.format("%d/t%f/t%f",i,x,y))
angle = angle + angle_increment
end
end
-- Generate a regular hexagon inscribed in unit circle
polypoints(6, 1.0, 0.0)

Answer 3

Sé que solicitó una respuesta en Visual Basic, sin embargo, aquí hay una solución en JavaScript .

Answer 4

Si desea hacerlo más rápido a costa de un error de acumulación, use una enésima raíz de unidad primitiva (compleja) y tome los poderes de la misma (ya sea utilizando el soporte de números complejos integrado en su idioma o codificando la multiplicación a mano) . Cía:

complex double omega=cexp(2*M_PI*I/n), z;
for (i=0, z=1; i<n; i++, z*=omega) {
/* do something with z */
}

Answer 5

Supongamos que desea dibujar un polígono de N lados de radio r , centrado en (0,0). Entonces los n vértices están dados por:

x[n] = r * cos(2*pi*n/N)
y[n] = r * sin(2*pi*n/N)

donde 0 <= n < N Tenga en cuenta que cos y sin aquí están trabajando en radianes, no en grados (esto es bastante común en la mayoría de los lenguajes de programación).

Si desea un centro diferente, solo agregue las coordenadas del punto central a cada ( x [n] , y [n] ). Si desea una orientación diferente, solo necesita agregar un ángulo constante. Así que la forma general es:

x[n] = r * cos(2*pi*n/N + theta) + x_centre
y[n] = r * sin(2*pi*n/N + theta) + y_centre

Answer 6

angle = start_angle
angle_increment = 360 / n_sides
for n_sides:
x = x_centre + radius * cos(angle)
y = y_centre + radius * sin(angle)
angle += angle_increment

en la práctica, al dibujar líneas en lugar de simplemente calcular los puntos de las esquinas, también debe "unir" el polígono repitiendo el primer punto.

también, si sin() y cos() funcionan en radianes en lugar de grados, quieres 2 * PI lugar de 360 .