Come funzionano le forme (rettangoli) negli alberi quad?

Mi è stato detto che un albero quad è la struttura dati ideale per il mio gioco, ma ho difficoltà a capire come funzionano esattamente le forme all'interno degli alberi quad.

Lo sto facendo in JavaScript, ma penso che queste domande potrebbero applicarsi ai quad alberi in qualsiasi lingua.

Credo soprattutto capire come (x, y) di base punti e inserimento punto opere in alberi quad, e che ho potuto farlo su carta.

Ecco un JSfiddle della mia sperimentazione di punti.

A parte un caso, i miei test con i punti funzionano come previsto.

Ma la mia confusione inizia quando sono coinvolte forme come rettangoli. Quando stai recuperando da un albero quad con forme, controlla ogni punto della forma e in quali nodi rientrano? E come funzionano anche gli inserimenti di forme, quando accetta i parametri (x, y, larghezza, altezza) per ogni forma? Usa la larghezza / altezza dal punto iniziale per calcolare altri punti d'angolo, che vengono quindi distribuiti in nodi appropriati? Se una forma inserita si estende in quattro nodi, i dati di quella forma vengono salvati in tutti e quattro i nodi?

E quando un metodo di recupero accetta una forma come parametro (x, y, larghezza, altezza), cosa sta realmente succedendo? Sta prima vedendo a quali nodi si estenderebbe la forma se dovesse essere inserita, e quindi recupererà tutti gli oggetti di quei nodi?

Ho un JSfiddle che lavora con le forme , ma sono completamente confuso sui risultati dei miei test. Ricevo oggetti duplicati restituiti!

Ad esempio, il quadrato rosso è un equivalente disegnato dei parametri che sto inserendo nel mio metodo di recupero. Penserei che, dato che questo quadrato rosso si estende su tutti e quattro i nodi, dovrebbe restituire ogni oggetto nel quad! Ma non è così e ho problemi a razionalizzare ciò che restituisce. Ho una serie di altri test che sono attualmente commentati, ma è possibile annullare il commento ed eseguirli per vedere risultati più confusi!

Come dire, se voglio restituire tutti i punti in un albero quad, come potrei farlo? Un metodo di recupero che utilizza una forma dell'intera dimensione dei limiti? Ad esempio, recuperare (0, 0, canvas.width, canvas.height)?

La libreria JavaScript QuadTree che sto usando è stata citata da varie altre fonti, quindi presumo che l'implementazione effettiva sia corretta e affidabile.

Penso che molta della mia confusione possa derivare da un malinteso sulla terminologia dei quad tree. Ad esempio, perché dicono limiti anziché dimensioni, quando un "punto" ha anche parametri larghezza / altezza? È una questione di convenzione / di breve durata o sono concetti completamente diversi?

Grazie per il tuo tempo!

I quadricipiti in genere archiviano e recuperano rettangoli. Un punto è un caso specifico in cui larghezza e altezza sono zero. La seguente logica viene utilizzata per trovare home per i nuovi rettangoli nella struttura, a partire dal nodo radice:

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
    }
}

Si noti che i rettangoli possono essere memorizzati a qualsiasi profondità, non deve essere un quadrifoglio. Se il rettangolo si trova a cavallo del limite a livello di radice, il quadrupolo di radice memorizzerà il rettangolo.

Ad esempio, il quadrato rosso è un equivalente disegnato dei parametri che sto inserendo nel mio metodo di recupero. Penserei che, dato che questo quadrato rosso si estende su tutti e quattro i nodi, dovrebbe restituire ogni oggetto nel quad! Ma non lo è, e ho problemi a razionalizzare ciò che restituisce.

Quando si esegue una query su quadtree, verranno restituiti solo rettangoli contenuti nella query. Nel tuo esempio, imponi a ciascuno dei 4 quadratini figlio di essere esaminato in modo più dettagliato perché il rettangolo di query rosso interseca ogni quadratino figlio. Dal momento che i bambini non hanno altri figli, ciascuno dei rettangoli in questi quadratini figlio verrà confrontato con il rettangolo rosso. Poiché nessuno dei rettangoli dell'albero si scontra con il rettangolo rosso della query, non è necessario restituire nulla.

Inizi davvero a vedere i vantaggi dei quadrifici quando hai molti oggetti e un sacco di spazio per gli oggetti rispetto alle aree di query. In questi casi, una piccola area di query può eliminare rapidamente grandi porzioni del quad tree. Solo i quad che si intersecano con il rettangolo della query verranno mai esaminati in modo più dettagliato.

MODIFICARE

Il recupero viene solitamente eseguito come segue:

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;
}

Nella tua libreria, tuttavia, non sembra verificare se i rettangoli che sta tornando si intersecano con la query, quindi dovrai aggiungerlo tu stesso.