¿Cómo funcionan las formas (rectángulos) en árboles cuádruples?

Me han dicho que un árbol cuádruple es la estructura de datos ideal para mi juego, pero tengo problemas para entender cómo funcionan exactamente las formas dentro de los árboles cuádruples.

Estoy haciendo esto en JavaScript, pero creo que estas preguntas podrían aplicarse a los árboles cuádruples en cualquier idioma.

Creo que entiendo principalmente cómo funcionan los puntos básicos (x, y) y la inserción de puntos en los árboles cuádruples, y que podría hacerlo en papel.

Aquí hay un JSfiddle de mi experimentación con puntos.

Aparte de un caso, mis pruebas con puntos funcionan como se esperaba.

Pero mi confusión comienza cuando están involucradas formas como rectángulos. Cuando está recuperando de un árbol cuádruple con formas, ¿verifica cada punto de la forma y en qué nodos caen? ¿Y cómo funcionan incluso las inserciones de formas, cuando acepta parámetros (x, y, ancho, alto) para cada forma? ¿Utiliza el ancho / alto desde el punto de partida para calcular otros puntos de esquina, que luego se distribuyen en los nodos apropiados? Si una forma insertada se extiende en cuatro nodos, ¿se guardan los datos de esa forma en los cuatro nodos?

Y cuando un método de recuperación acepta una forma como parámetro (x, y, ancho, alto), ¿qué está pasando realmente? ¿Es primero ver a qué nodos abarcaría la forma si se insertara y luego recuperar todos los objetos de esos nodos?

Tengo un JSfiddle que trabaja con formas , pero estoy completamente confundido con los resultados de mis pruebas. ¡Me devuelven objetos duplicados!

Por ejemplo, el cuadrado rojo es un equivalente dibujado de los parámetros que estoy ingresando en mi método de recuperación. ¡Creo que, dado que este cuadrado rojo abarca los cuatro nodos, debería devolver cada objeto en el árbol cuádruple! Pero no lo hace, y estoy teniendo problemas para racionalizar lo que devuelve. Tengo una serie de otras pruebas que actualmente están comentadas, pero puedes descomentarlas y ejecutarlas para ver resultados más confusos.

Como digo, si quiero devolver todos los puntos en un árbol cuádruple, ¿cómo lo haría? ¿Un método de recuperación usando una forma del tamaño completo de los límites? Por ejemplo, recuperar (0, 0, canvas.width, canvas.height)?

La biblioteca de JavaScript árbol cuádruple estoy usando ha sido mencionado por varias otras fuentes, así que supongo que la implementación real es correcta y de buena reputación.

Creo que gran parte de mi confusión puede deberse a un malentendido de la terminología del árbol cuádruple. Por ejemplo, ¿por qué dicen límites en lugar de dimensiones, cuando un "punto" también tiene parámetros de ancho / alto? ¿Es una cuestión de convención / abreviatura, o son conceptos completamente diferentes?

¡Gracias por tu tiempo!

Los quadtrees generalmente almacenan y recuperan rectángulos. Un punto es un caso específico donde el ancho y la altura son cero. La siguiente lógica se utiliza para encontrar el hogar de nuevos rectángulos en el árbol, comenzando con el nodo raíz:

void Store(Rectangle rect)
{
    if(I have children nodes)
    {
        bool storedInChild = false;
        foreach(Node childNode in nodes)
        {
            if(this rectangle fits entirely inside the childNode bounds)
            {
                childNode.Store(rect);   // Go deeper into the tree
                storedInChild = true;
                break;
            }
        }
        if(not storedInChild)
        {
            Add this rectangle to the current node
        }
    }
    else
    {
        Add this rectangle to the current node
    }
}

Tenga en cuenta que los rectángulos se pueden almacenar a cualquier profundidad, no tiene que ser un quad de hoja. Si el rectángulo se extiende a ambos lados del límite en el nivel raíz, el quad raíz almacenará el rectángulo.

Por ejemplo, el cuadrado rojo es un equivalente dibujado de los parámetros que estoy ingresando en mi método de recuperación. ¡Creo que, dado que este cuadrado rojo abarca los cuatro nodos, debería devolver cada objeto en el árbol cuádruple! Pero no lo hace, y estoy teniendo problemas para racionalizar lo que devuelve.

Al consultar el quadtree, solo devolverá los rectángulos que contiene la consulta. En su ejemplo, obliga a que cada uno de los 4 quads secundarios se mire con más detalle porque el rectángulo de consulta rojo cruza cada quad secundario. Como los niños no tienen más hijos, cada uno de los rectángulos en estos quads infantiles se comparará con el rectángulo rojo. Como ninguno de los rectángulos del árbol choca con el rectángulo rojo de consulta, no se debe devolver nada.

Realmente comienzas a ver los beneficios de los árboles cuádruples cuando tienes muchos objetos y mucho espacio para que existan los objetos en comparación con el área o áreas de consulta. En estos casos, un área de consulta pequeña puede eliminar rápidamente grandes porciones del árbol cuádruple de la consideración. Solo los quads que se cruzan con el rectángulo de consulta se verán con más detalle.

EDITAR

La recuperación generalmente se realiza de la siguiente manera:

List<Rectangle> Query(Rectangle queryRect)
{
    List<Rectangle> results;
    foreach(Node childNode in children)
    {
        if(queryRect intersects with childNode bounds)
        {
            results += childNode.Query(queryRect);   // Dig deeper into the tree
        }
    }

    foreach(Rectangle I have stored in this quad)
    {
        if(queryRect intersects with rect)  // Your library doesn't do this
        {
            results += rect;
        }
    }

    return results;
}

Sin embargo, en su biblioteca, no parece verificar si los rectángulos que está regresando se cruzan con la consulta, por lo que deberá agregarlo usted mismo.