Como funcionam as formas (retângulos) em árvores quad?

Foi-me dito que uma árvore quádrupla é a estrutura de dados ideal para o meu jogo, mas estou tendo problemas para entender como exatamente as formas funcionam dentro das árvores quádruplas.

Estou fazendo isso em JavaScript, mas acho que essas perguntas podem se aplicar a árvores em qualquer idioma.

Eu acho que a maioria entender como básica (x, y) pontos e de inserção ponto de obras em árvores quad, e que eu poderia fazê-lo no papel.

Aqui está um JSfiddle da minha experiência com pontos.

Além de um caso, meus testes com pontos estão funcionando conforme o esperado.

Mas minha confusão começa quando formas como retângulos estão envolvidos. Quando você está recuperando de uma árvore quádrupla com formas, ele verifica cada ponto da forma e em quais nós eles se enquadram? E como as inserções de formas funcionam mesmo quando aceitam parâmetros (x, y, largura, altura) para cada forma? Ele usa a largura / altura do ponto de partida para calcular outros pontos de canto, que são dispensados ​​nos nós apropriados? Se uma forma inserida se estender em quatro nós, os dados dessa forma serão salvos nos quatro nós?

E quando um método de recuperação aceita uma forma como parâmetro (x, y, largura, altura), o que realmente está acontecendo? É primeiro ver em que nós a forma se estenderia se ela fosse inserida e depois recuperar todos os objetos desses nós?

Eu tenho um JSfiddle trabalhando com formas , mas estou totalmente confuso com os resultados dos meus testes. Estou recebendo objetos duplicados sendo devolvidos!

Por exemplo, o quadrado vermelho é um equivalente desenhado dos parâmetros que estou inserindo no meu método de recuperação. Eu pensaria que, uma vez que esse quadrado vermelho abrange todos os quatro nós, ele deve retornar todos os objetos no quad tree! Mas isso não acontece, e estou tendo problemas para racionalizar o que retorna. Eu tenho vários outros testes atualmente comentados, mas você pode cancelar o comentário e executá-los para obter resultados mais confusos!

Por exemplo, se eu quiser retornar todos os pontos em uma árvore quádrupla, como eu faria isso? Um método de recuperação usando uma forma de todo o tamanho dos limites? Por exemplo, recuperar (0, 0, canvas.width, canvas.height)?

A biblioteca JavaScript QuadTree que estou usando já foi referida por várias outras fontes, portanto, presumo que a implementação real seja correta e respeitável.

Penso que grande parte da minha confusão pode resultar de um mal-entendido da terminologia de árvores quádruplas. Como, por que eles dizem limites em vez de dimensões, quando um "ponto" também tem parâmetros de largura / altura? É uma questão de convenção / mão curta, ou são conceitos completamente diferentes?

Obrigado pelo seu tempo!

Quadríceps geralmente armazenam e recuperam retângulos. Um ponto é um caso específico em que largura e altura são zero. A lógica a seguir é usada para encontrar o local para novos retângulos na árvore, começando com o nó raiz:

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

Observe que os retângulos podem ser armazenados em qualquer profundidade, não precisa ser um quad-leaf. Se o retângulo ultrapassar o limite no nível da raiz, o quad raiz armazenará o retângulo.

Por exemplo, o quadrado vermelho é um equivalente desenhado dos parâmetros que estou inserindo no meu método de recuperação. Eu pensaria que, uma vez que esse quadrado vermelho abrange todos os quatro nós, ele deve retornar todos os objetos no quad tree! Mas isso não acontece, e estou tendo problemas para racionalizar o que retorna.

Ao consultar o quadtree, ele retornará apenas retângulos contidos na consulta. No seu exemplo, você força cada um dos quatro quadríceps filhos a serem vistos com mais detalhes, porque o retângulo de consulta vermelho cruza cada quadri filho. Como os filhos não têm mais filhos, cada um dos retângulos nesses quadríceps filhos será comparado ao retângulo vermelho. Como nenhum dos retângulos da árvore colide com o retângulo de consulta vermelho, nada deve ser retornado.

Você realmente começa a ver os benefícios dos quadríceps quando tem muitos objetos e muito espaço para os objetos existirem em comparação com a (s) área (s) de consulta. Nesses casos, uma pequena área de consulta pode eliminar rapidamente grandes pedaços da árvore quádrupla. Somente quads que se cruzam com o retângulo de consulta serão vistos com mais detalhes.

EDITAR

A recuperação geralmente é feita da seguinte maneira:

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

Na sua biblioteca, no entanto, não parece verificar se os retângulos que estão retornando se cruzam com a consulta; portanto, você precisará adicioná-lo.