Hola usuario de nuestra página, hemos encontrado la respuesta a lo que buscabas, deslízate y la verás a continuación.
Solución:
La implementación de la fórmula Shoelace podría hacerse en Numpy. Suponiendo estos vértices:
import numpy as np
x = np.arange(0,1,0.001)
y = np.sqrt(1-x**2)
Podemos redefinir la función en numpy para encontrar el área:
def PolyArea(x,y):
return 0.5*np.abs(np.dot(x,np.roll(y,1))-np.dot(y,np.roll(x,1)))
Y obteniendo resultados:
print PolyArea(x,y)
# 0.26353377782163534
Evitando for loop hace que esta función sea ~50 veces más rápida que PolygonArea:
%timeit PolyArea(x,y)
# 10000 loops, best of 3: 42 µs per loop
%timeit PolygonArea(zip(x,y))
# 100 loops, best of 3: 2.09 ms per loop.
El tiempo se realiza en el cuaderno Jupyter.
Puede usar la fórmula del cordón de zapato, por ejemplo
def PolygonArea(corners):
n = len(corners) # of corners
area = 0.0
for i in range(n):
j = (i + 1) % n
area += corners[i][0] * corners[j][1]
area -= corners[j][0] * corners[i][1]
area = abs(area) / 2.0
return area
# examples
corners = [(2.0, 1.0), (4.0, 5.0), (7.0, 8.0)]
Esto solo funciona para polígonos simples.
-
Si tienes un polígono con agujeros : Calcular el área del anillo exterior y restar las áreas de los anillos interiores
-
Si usted tiene anillos de autointersección : Tienes que descomponerlos en sectores simples
La respuesta de maxb brinda un buen rendimiento, pero puede conducir fácilmente a una pérdida de precisión cuando los valores de las coordenadas o la cantidad de puntos son grandes. Esto se puede mitigar con un simple cambio de coordenadas:
def polygon_area(x,y):
# coordinate shift
x_ = x - x.mean()
y_ = y - y.mean()
# everything else is the same as maxb's code
correction = x_[-1] * y_[0] - y_[-1]* x_[0]
main_area = np.dot(x_[:-1], y_[1:]) - np.dot(y_[:-1], x_[1:])
return 0.5*np.abs(main_area + correction)
Por ejemplo, un sistema de referencia geográfica común es UTM, que puede tener coordenadas (x,y) de (488685.984, 7133035.984). El producto de esos dos valores es 3485814708748.448. Puede ver que este producto único ya está en el borde de la precisión (tiene el mismo número de lugares decimales que las entradas). Agregar solo algunos de estos productos, por no hablar de miles, resultará en una pérdida de precisión.
Una forma sencilla de mitigar esto es cambiar el polígono de coordenadas positivas grandes a algo más cercano a (0,0), por ejemplo, restando el centroide como en el código anterior. Esto ayuda de dos maneras:
- Elimina un factor de
x.mean() * y.mean()de cada producto - Produce una combinación de valores positivos y negativos dentro de cada producto escalar, que se cancelará en gran medida.
El cambio de coordenadas no altera el área total, solo hace que el cálculo sea más estable numéricamente.