QuadTrees y desbordamiento de pila de constructor recursivo

Estoy creando un terreno QuadTree fragmentado e intento asegurarme de que nunca haya más de un nivel de diferencia de detalle entre dos nodos. Mi código actual para el constructor es este:

QuadNode::QuadNode(Rect area, QuadNode * p, QuadRoot * r)
{
    Root = r;

    Parent = p;
    Level = p->Level + 1;

    InitializeGeometry(area);

    for(int iii = 0; iii < 4; iii++)
            Children[iii] = 0;

    for(int iii = 0; iii < 4; iii++)
    {
            if(QuadrantNeedsChild(iii))
                    Children[iii] = new QuadNode(GetRect(iii), this, Root);
    }
}

Y eso funciona bien. Pero para forzar no más de un nivel de diferencia entre dos nodos vecinos, intento agregar esto al final del constructor:

QuadNode * neighbour;

for(int direction = 0; direction < 4; direction++)
{
    neighbour = FindNeighbour(direction);
    if(neighbour)
    {
        while(Level - neighbour->Level > 1)
        {
            neighbour->Subdivide();
            neighbour = FindNeighbour(direction);
                    //neighbour should now be a child of the previous neighbour
        }
    }
}

Pero esa pila se desborda. Una razón por la que pensar es que la porción de asignación del Children[iii] = new QuadNode(GetRect(iii), this, Root); declaración nunca se ejecuta y FindNeighbour() requiere que los niños estén dispuestos a encontrar el vecino adecuado. Pero no creo que ese sea el único problema ya que el código nunca llega al segundo neighbour = FindNeighbour(direction); línea y no tengo idea de qué está causando eso.

Si ejecuto ese segundo fragmento de código en una nueva función después de la creación base del árbol, funciona más o menos, pero luego requiere varias pasadas para garantizar que los nodos recién creados no creen una diferencia de nivel> 1. Entonces yo' Prefiero tener este código en el constructor si es posible. ¿Alguien puede pensar en una manera de lograr esto?

Algunas notas sobre la clase en caso de que ayude QuadrantNeedsChild(int quadrant) asegura que el nivel nunca exceda 8, así que sé que no estoy profundizando demasiado. Subdivide() simplemente corre Children[iii] = new QuadNode(GetRect(iii), this, Root); en todos los cuadrantes. FindNeighbour(int direction) puede devolver el padre o un antepasado. Por ejemplo, si D está buscando al vecino del norte, obtendrá su abuelo (el diagrama completo) si B nunca se subdividió en lo siguiente:

 - - - - - -
|     |     |
|  A  |  B  |
|     |     |
|- - - - - -|
|     | D|  |
|  C  |-----|
|     |  |  |
 - - - - - -

La función de subdivisión solo subdivide un cuadrante dado o todos los cuadrantes si se le proporciona un cuadrante fuera de rango.

void QuadNode::Subdivide(int quadrant)
{
    if(quadrant > -1 && quadrant < 4)
    {
        if(!Children[quadrant])
            Children[quadrant] = new QuadNode(GetRect(quadrant), this, Root);
    }
    else
        for(int iii = 0; iii < 4; iii++)
            if(Children[iii] == 0)
                Children[iii] = new QuadNode(GetRect(iii), this, Root);
}

preguntado el 12 de junio de 12 a las 22:06

Tengo que agregar la etiqueta obligatoria de stackoverflow aquí. -

Nota al margen: nombres de variables en c++ por la mayoría de las convenciones comienzan con letras minúsculas, mientras que los nombres de clase comienzan con mayúsculas. -

Por favor, publique un ejemplo completo y compilable. -

¿Por qué el vecino norte de 'D' es todo el diagrama y no 'B'? ¿Cuál es el vecino sur de 'B'? -

B no tiene vecinos ya que no se ha subdividido. Hasta que un cuadrante no se subdivide, no es un nodo. -

1 Respuestas

Cuando se construye el primer hijo de un nodo, ¿encuentra es su propio padre como vecino, ya que ese padre aún no tiene hijos (el primero está a punto de ser creado)?

Eso haría que el nodo se llamara. Subdivide() en su propio padre, que construiría un nuevo hijo que nuevamente llamaría Subdivide(), ...

E incluso sin esto, construir el primer nodo en un nuevo nivel Subdivide() todos sus vecinos que a su vez subdividirán a todos los vecinos de esos vecinos, recursivamente. ¿Es así como se supone que debe funcionar? Para el nivel más profundo, esto causará algo así como 48 niveles de recursividad.

Respondido el 16 de junio de 12 a las 02:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.