Obter n número de coordenadas de um octógono

Vamos usar um pouco de matemática.

Cada triângulo no polígono é isósceles. Assumindo ro raio do círculo que o contém e acada lado do polígono, temos:

n_sides = 8
perimeter = n_sides * a
a/2 = sin(pi/n_sides) / r # isosceles = 2 equal right triangles
perimeter = n_sides * 2 * sin(pi/n_sides) / r
r =  perimeter/(2 * n_sides * sin(pi/n_sides))

Assim, as coordenadas são:

perimeter = 30.72
n_sides = 8

r = perimeter/(2 * n_sides * np.sin(np.pi/n_sides))
x = r * np.cos(np.linspace(0, 2 * np.pi, n_sides, endpoint=False))
y = r * np.sin(np.linspace(0, 2 * np.pi, n_sides, endpoint=False))

Observe o endpoint=Falseem linspace.

Como um gráfico:

ax = plt.subplot(aspect=1)
ax.plot(x, y, marker='o')

Saída:

Se você quiser um ponto extra para "fechar" o polígono (o último ponto sendo o mesmo que o primeiro ponto):

x = r * np.cos(np.linspace(0, 2 * np.pi, n_sides+1))
y = r * np.sin(np.linspace(0, 2 * np.pi, n_sides+1))

Agora, vamos usar shapelypara verificar se o cálculo está correto:

from shapely.geometry import Polygon

Polygon(zip(x, y)).length # 30.72

Interpolação de npontos no octógono/polígono

Agora que temos um polígono, podemos interpolar npontos ao longo de seu perímetro.

Vamos gerar um polígono "fechado" (ou seja, n_sides+1 ponto em que o último é igual ao primeiro), criar um LineStringe interpolate nvalores ao longo dele:

from shapely.geometry import LineString

perimeter = 30.72
n_sides = 8
n = 12

# compute the points of the polygon
r = perimeter/(2 * n_sides * np.sin(np.pi/n_sides))
x = r * np.cos(np.linspace(0, 2 * np.pi, n_sides+1))
y = r * np.sin(np.linspace(0, 2 * np.pi, n_sides+1))

# create a line string
# interpolate n points on the perimeter
line = LineString(zip(x, y))

coords = np.concatenate(list(line.interpolate(x).coords
                             for x in np.linspace(0, line.length, n,
                                                  endpoint=False)))

# plot
ax = plt.subplot(aspect=1)
ax.plot(x, y)
ax.plot(*coords.T, ls='', marker='o', label='n = 8')

Saída:

Bem, se você definir n=8 e usar seu código para um círculo, você receberá coordenadas para um octógono. Você então precisa escalar esse octógono para encontrar seu perímetro. Eu adicionei uma função de distância para ajudar a calcular o tamanho das bordas do octógono original. Também há um arredondamento para 4 casas decimais para torná-lo mais legível, mas você pode escolher remover isso. Eu acredito que isso funcionará para uma forma de qualquer tamanho e qualquer perímetro desejado.

import numpy as np
    
def distance(coords1, coords2):
    return ((coords1[0] - coords2[0])**2 + (coords1[1] - coords2[1])**2 )**0.5

n = 8
target_perimeter = 30.72
x = np.cos(np.linspace(0, 2 * np.pi, n+1))
y = np.sin(np.linspace(0, 2 * np.pi, n+1))

coordinates = list(zip(x, y))
perimeter = n * distance(coordinates[0], coordinates[1])
scaling_factor = target_perimeter / perimeter
scaled_coordinates = scaling_factor * np.array(coordinates)
print(scaled_coordinates.round(4))

Outro uso para números complexos. Seu gráfico é um diagrama de Argand, com coordenadas x e y, as partes real e imaginária de uma variável complexa em forma polar.

Parte 1: Octógono Simples

Vai contra a corrente para meus octógonos terem 9 vértices, então eu usei endpoint=Falsena numpy.linspacechamada. Para fechar o polígono, eu simplesmente junto o último e o primeiro ponto com uma plotchamada separada.

Se você não quiser octógonos, altere para qualquer valor que numsidesdesejar.

from math import pi, sin
import numpy as np
import matplotlib.pyplot as plt

perimeter = 30.72
numsides = 8

radius = perimeter / ( 2 * numsides * sin( pi / numsides ) )
start = 0.5 / numsides         # or just 0
z = radius * np.exp( 2j * pi * ( np.linspace( 0, 1, numsides, endpoint=False ) + start ) )
x, y = z.real, z.imag
plt.plot( x, y, 'r-', marker='o' );   plt.plot( [x[-1],x[0]], [y[-1],y[0]], 'r-' )
plt.gca().set_aspect('equal')
plt.show()

Parte 2: Pontos Adicionais

Não está muito claro o que "uniformemente espaçado" significa: pode significar igualmente distribuído por distância perimétrica, ou pode significar ângulos polares iguais. Como é mais fácil, presumi o primeiro.

Quando você quiser npontos do original, numsidesvocê pode simplesmente mapear números e interpolar:

0 ... n
0 ... numsides

Assim, seu índice de interpolação (de ponto flutuante) vem da multiplicação do índice de ponto por numsides/n. A interpolação é feita extraindo partes inteiras e fracionárias. Um pouco de cuidado deve ser exercido no último segmento se o ponto final (como aqui) não repetir o primeiro.

Funciona seja num múltiplo de numsides(por exemplo n=24) ou não (por exemplo n=13). No entanto, parece mais natural quando é um múltiplo de número inteiro (nesse caso, a interpolação pode ser feita com um loop aninhado simples).

from math import pi, sin
import numpy as np
import matplotlib.pyplot as plt

perimeter = 30.72
numsides = 8            # number of sides (e.g. 8 -> octagon)
n = 24                  # number of perimeter-interpolated points

# Main polygon
radius = perimeter / ( 2 * numsides * sin( pi / numsides ) )
start = 0.5 / numsides         # or just 0
z = radius * np.exp( 2j * pi * ( np.linspace( 0, 1, numsides, endpoint=False ) + start ) )
x, y = z.real, z.imag
plt.plot( x, y, 'r-' );   plt.plot( [x[-1],x[0]], [y[-1],y[0]], 'r-' )

# Added interpolated points
zp = np.zeros( n, dtype=complex )
for p in range( n ):
    r = p * numsides / n                         # rescaled index
    i = int( r );   f = r - i                    # integer and fractional part
    iplus1 = i + 1 if i < numsides-1 else 0      # end point
    zp[p] = z[i] + f * ( z[iplus1] - z[i] )      # interpolate from vertices
xp, yp = zp.real, zp.imag

plt.plot( xp, yp, 'bx' )
plt.gca().set_aspect('equal')
plt.show()

Se você quiser que os pontos sejam espaçados uniformemente ao longo do perímetro, você pode calcular o comprimento do perimeter = n * sidepara um npolígono de lados, distribuir os ptspontos ao longo desse comprimento total ( totalpos = perimeter * i / pts, onde i = 0 ... pts-1), e então caminhar sobre as bordas, calculando o índice do lado atual como index = floor(totalpos / side), e a posição dentro do lado dado como sidepos = totalpos - index * side. Então pegue o lado em questão, e use essa posição interna ao longo dele para obter um ponto.

Este código JavaScript faz isso de forma interativa, a única parte complicada é que eu queria ter a borda mais inferior horizontal, é por isso que os "tradicionais" x-cos, y-sin são trocados e também deslocados pela metade (desta forma o comprimento do lado é apenas a diferença das coordenadas x). Não posso escrever isso em Python no momento.

function doThing() {
  const n = document.getElementById("ply").valueAsNumber;
  const pts = document.getElementById("pts").valueAsNumber;
  const cnv = document.getElementById("cnv");
  const points = [];
  for (let i = 0; i < n; i++) {
    points.push([
      cnv.width / 2 * (1 + 0.9 * Math.sin(2 * Math.PI * (i - 0.5) / n)),
      cnv.height / 2 * (1 + 0.9 * Math.cos(2 * Math.PI * (i - 0.5) / n))
    ]);
  }
  const side = points[1][0] - points[0][0];
  const perimeter = side * n;
  const ctx = cnv.getContext("2d");
  ctx.clearRect(0, 0, cnv.width, cnv.height);
  ctx.beginPath();
  ctx.moveTo(...points[n - 1]);
  for (const point of points)
    ctx.lineTo(...point);
  ctx.stroke();
  ctx.fillStyle = "red";
  for (let i = 0; i < pts; i++) {
    const totalpos = perimeter * i / pts;
    const index = Math.floor(totalpos / side);
    const sidepos = totalpos - index * side;
    const p1 = points[index];
    const p2 = points[(index + 1) % n];
    ctx.fillRect(p1[0] + (p2[0] - p1[0]) * sidepos / side - 2, p1[1] + (p2[1] - p1[1]) * sidepos / side - 2, 5, 5);
  }
}

doThing();

Poly: <input id="ply" type="range" min="3" max="42" value="8" oninput="doThing()"><br>
        Points: <input id="pts" type="range" min="1" max="100" value="10" oninput="doThing()"><br>
<canvas id="cnv" width="400" height="400"></canvas>

Uma solução "antiga" sem usar bibliotecas externas (exceto para calcular cos e seno!):

N = 8  # number of sides of the polygon
R = 5.0172  # radius of the circle containing the polygon
N_points = 12  # number of equally spaced points along the perimeter
PI = 3.14159265

L1 = (perimeter / N)  # length of each polygon side
perimeter = 2 * N * R * np.sin(np.pi / N)
res_coor = []  # coordinates of the N_points points

# Coordinates of the polygons points (last point = first point)
x = [R * np.cos(k * 2 * PI / N) for k in range(N+1)]
y = [R * np.sin(k * 2 * PI / N) for k in range(N+1)]
coor = list(zip(x, y))

def coordinates2D(xA, yA, xB, yB, d):
    """ Gives the coordinates of a point M on a segment [AB] 
    with M located at a distance d from A.
    With vector notation: OM = OA + AM = OA + (d/L1) * AB
    """
    return xA + d / L1 * (xB - xA), yA + d / L1 * (yB - yA)
    
def points_on_side(distances): 
    """For each point, get the distance from the origin of
    the side where it is located."""
    res = []  
    side = [x // L1 + 1 for x in distances]  # N° of the side where is each point
    for i in range(len(distances)): 
        res.append((int(side[i]),  distances[i] - (side[i] - 1) * L1))
    return res  # stores (side n° i, d_i) in a list

# Distances along the perimeter of each point (from the 1st polygon point)
distances = [k * (perimeter / N_points) for k in range(N_points)]

# List of (side n° i, distance from start of side) for each point
points_on_segment = points_on_side(distances)

# Get the 2D coordinates
for i in range(N_points):
    side = points_on_segment[i][0]  # side n°
    res_coor.append(coordinates2D(coor[side-1][0], coor[side-1][1], # xA, yA
                                  coor[side][0], coor[side][1],     # xB, yB
                                  points_on_segment[i][1]))         # d
res_x, res_y = zip(*res_coor)

_, ax = plt.subplots()
ax.set_aspect('equal', 'box')
plt.plot(x, y)
plt.scatter(x= res_x, y=res_y, color="g")
plt.show()