Un algoritmo para inflar / desinflar (compensar, amortiguar) polígonos

¿Cómo "inflaría" un polígono? Es decir, quiero hacer algo similar a esto:

El requisito es que los bordes / puntos del nuevo polígono (inflado) estén a la misma distancia constante de los polígonos (originales) antiguos (en la imagen de ejemplo no lo son, ya que entonces tendría que usar arcos para vértices inflados, pero vamos a olvídate de eso por ahora;)).

El término matemático para lo que estoy buscando es en realidad offseting de polígono interno / externo . +1 a balint por señalar esto. La denominación alternativa es el almacenamiento en búfer de polígonos .

Resultados de mi búsqueda:

Aquí hay algunos enlaces:

• Una encuesta de estrategias de desplazamiento de polígonos
• Desplazamiento de polígono, PROBLEMA
• Almacenamiento de datos de polígono

Pensé que podría mencionar brevemente mi propia biblioteca de recorte y compensación de polígonos - Clipper .

Si bien Clipper está diseñado principalmente para operaciones de recorte de polígonos, también compensa el polígono. La biblioteca es un software gratuito de código abierto escrito en Delphi, C ++ y C # . Tiene una licencia de Boost muy libre de gravámenes que le permite ser utilizado en aplicaciones gratuitas y comerciales sin cargo.

La compensación de polígonos se puede realizar utilizando uno de los tres estilos de compensación: cuadrado, redondo y a inglete.

El polígono que está buscando se llama polígono de desplazamiento hacia adentro / hacia afuera en geometría computacional y está estrechamente relacionado con el esqueleto recto .

Estos son varios polígonos desplazados para un polígono complicado:

Y este es el esqueleto recto para otro polígono:

Como se señaló en otros comentarios, también, dependiendo de qué tan lejos planee "inflar / desinflar" su polígono, puede terminar con una conectividad diferente para la salida.

Desde el punto de vista del cálculo: una vez que tenga el esqueleto recto, uno debería poder construir los polígonos de desplazamiento con relativa facilidad. La biblioteca CGAL de código abierto y (gratuita para no comerciales) tiene un paquete que implementa estas estructuras. Ver este ejemplo de código para calcular polígonos de compensación usando CGAL.

El manual del paquete debería darle un buen punto de partida sobre cómo construir estas estructuras, incluso si no va a utilizar CGAL, y contiene referencias a los documentos con las definiciones y propiedades matemáticas:

Manual CGAL: esqueleto recto 2D y compensación de polígono

Para este tipo de cosas, generalmente uso JTS . Para fines de demostración, creé este jsFiddle que usa JSTS (puerto JavaScript de JTS). Solo necesita convertir las coordenadas que tiene en coordenadas JSTS:

function vectorCoordinates2JTS (polygon) {
  var coordinates = [];
  for (var i = 0; i < polygon.length; i++) {
    coordinates.push(new jsts.geom.Coordinate(polygon[i].x, polygon[i].y));
  }
  return coordinates;
}

El resultado es algo como esto:

Información adicional : generalmente uso este tipo de inflado / desinflado (un poco modificado para mis propósitos) para establecer límites con radio en los polígonos que se dibujan en un mapa (con folletos o mapas de Google). Simplemente convierte pares (lat, lng) a coordenadas JSTS y todo lo demás es igual. Ejemplo:

Me parece que lo que quieres es:

• Comenzando en un vértice, mire hacia la izquierda a lo largo de un borde adyacente.
• Reemplace el borde con un nuevo borde paralelo colocado a una distancia da la "izquierda" del anterior.
• Repita para todos los bordes.
• Encuentra las intersecciones de los nuevos bordes para obtener los nuevos vértices.
• Detecta si te has convertido en un polígono cruzado y decide qué hacer al respecto. Probablemente agregue un nuevo vértice en el punto de cruce y elimine algunos viejos. No estoy seguro de si hay una mejor manera de detectar esto que simplemente comparar cada par de bordes no adyacentes para ver si su intersección se encuentra entre ambos pares de vértices.

El polígono resultante se encuentra a la distancia requerida del antiguo polígono "lo suficientemente lejos" de los vértices. Cerca de un vértice, el conjunto de puntos a distanciad del antiguo polígono no es, como usted dice, un polígono, por lo que no se puede cumplir el requisito como se indica.

No sé si este algoritmo tiene un nombre, un código de ejemplo en la web o una optimización diabólica, pero creo que describe lo que quieres.

En el mundo SIG, se utiliza el almacenamiento en búfer negativo para esta tarea: http://www-users.cs.umn.edu/~npramod/enc_pdf.pdf

La biblioteca JTS debería hacer esto por usted. Consulte la documentación para la operación del búfer: http://tsusiatsoftware.net/jts/javadoc/com/vividsolutions/jts/operation/buffer/package-summary.html

Para obtener una descripción general, consulte también la Guía del desarrollador: http://www.vividsolutions.com/jts/bin/JTS%20Developer%20Guide.pdf

Cada línea debe dividir el plano a "dentro" y "contorno"; Puede averiguarlo utilizando el método habitual de producto interno.

Mueva todas las líneas hacia afuera por cierta distancia.

Considere todos los pares de líneas vecinas (líneas, no segmentos de línea), encuentre la intersección. Estos son el nuevo vértice.

Limpie el nuevo vértice eliminando las partes que se cruzan. - tenemos algunos casos aquí

(a) Caso 1:

 0--7  4--3
 |  |  |  |
 |  6--5  |
 |        |
 1--------2

si lo gastas por uno, obtienes esto:

0----a----3
|    |    |
|    |    |
|    b    |
|         |
|         |
1---------2

7 y 4 se superponen ... si ve esto, elimina este punto y todos los puntos intermedios.

(b) caso 2

 0--7  4--3
 |  |  |  |
 |  6--5  |
 |        |
 1--------2

si lo gastas por dos, obtienes esto:

0----47----3
|    ||    |
|    ||    |
|    ||    |
|    56    |
|          |
|          |
|          |
1----------2

Para resolver esto, para cada segmento de línea, debe verificar si se superpone con los últimos segmentos.

(c) caso 3

       4--3
 0--X9 |  |
 |  78 |  |
 |  6--5  |
 |        |
 1--------2

gasto por 1. este es un caso más general para el caso 1.

(d) caso 4

igual que en el caso 3, pero gasto por dos.

En realidad, si puede manejar el caso 4. Todos los demás casos son solo casos especiales con alguna superposición de línea o vértice.

Para hacer el caso 4, mantienes una pila de vértices ... empujas cuando encuentras líneas superpuestas con la última línea, revísala cuando obtienes la última línea. - Al igual que lo que haces en el casco convexo.

Aquí hay una solución alternativa, mira si te gusta más.

1. Haga una triangulación , no tiene que ser delaunay, cualquier triangulación funcionaría.

2. Infle cada triángulo; esto debería ser trivial. Si almacena el triángulo en el orden antihorario, simplemente mueva las líneas hacia el lado derecho y haga la intersección.

3. Fusionarlos usando un algoritmo de recorte Weiler-Atherton modificado

Muchas gracias a Angus Johnson por su biblioteca de podadoras. Hay buenos ejemplos de código para hacer el recorte en la página de inicio de Clipper en http://www.angusj.com/delphi/clipper.php#code pero no vi un ejemplo para la compensación de polígonos. Entonces pensé que tal vez sea útil para alguien si publico mi código:

    public static List<Point> GetOffsetPolygon(List<Point> originalPath, double offset)
    {
        List<Point> resultOffsetPath = new List<Point>();

        List<ClipperLib.IntPoint> polygon = new List<ClipperLib.IntPoint>();
        foreach (var point in originalPath)
        {
            polygon.Add(new ClipperLib.IntPoint(point.X, point.Y));
        }

        ClipperLib.ClipperOffset co = new ClipperLib.ClipperOffset();
        co.AddPath(polygon, ClipperLib.JoinType.jtRound, ClipperLib.EndType.etClosedPolygon);

        List<List<ClipperLib.IntPoint>> solution = new List<List<ClipperLib.IntPoint>>();
        co.Execute(ref solution, offset);

        foreach (var offsetPath in solution)
        {
            foreach (var offsetPathPoint in offsetPath)
            {
                resultOffsetPath.Add(new Point(Convert.ToInt32(offsetPathPoint.X), Convert.ToInt32(offsetPathPoint.Y)));
            }
        }

        return resultOffsetPath;
    }

Una opción más es utilizar boost :: polygon : falta algo de documentación, pero debería encontrar los métodos resizey bloat, también, el +=operador sobrecargado , que realmente implementa el almacenamiento en búfer. Entonces, por ejemplo, aumentar el tamaño de un polígono (o un conjunto de polígonos) en algún valor puede ser tan simple como:

poly += 2; // buffer polygon by 2

Según los consejos de @ JoshO'Brian, parece que el rGeospaquete en el Rlenguaje implementa este algoritmo. Ver rGeos::gBuffer.

Hay un par de bibliotecas que se pueden usar (también se pueden usar para conjuntos de datos 3D).

1. https://github.com/otherlab/openmesh
2. https://github.com/alecjacobson/nested_cages
3. http://homepage.tudelft.nl/h05k3/Projects/MeshThickeningProj.htm

También se pueden encontrar las publicaciones correspondientes para estas bibliotecas para comprender los algoritmos con más detalle.

El último tiene la menor dependencia y es autónomo y puede leer en archivos .obj.

Mis mejores deseos, Stephan

Utilizo geometría simple: vectores y / o trigonometría

1. En cada esquina, encuentre el vector medio y el ángulo medio. El vector medio es el promedio aritmético de los dos vectores unitarios definidos por los bordes de la esquina. El ángulo medio es la mitad del ángulo definido por los bordes.

2. Si necesita expandir (o contraer) su polígono por la cantidad de d de cada borde; debe salir (dentro) por la cantidad d / sin (midAngle) para obtener el nuevo punto de esquina.

3. Repita esto para todas las esquinas

*** Ten cuidado con tu dirección. Haga la prueba CounterClockWise usando los tres puntos que definen la esquina; para averiguar qué camino está afuera o adentro.