Algorithme pour résoudre le problème de contrainte planaire ("Recherche de monstre Pokemon Go")

[Remarque: ce problème a été inspiré par Pokemon Go. Je vais d'abord expliquer le problème en termes mathématiques, puis expliquer la connexion à Pokemon Go. Mon objectif n'est pas de tricher dans le jeu. Si je voulais tricher, de meilleures informations seraient disponibles plus facilement.]

Supposons qu'il y ait $N$ points (les "points inconnus") dans un avion, appelez-les $n_1,\dots,n_N$, avec des coordonnées inconnues. De plus, nous avons$M$ mesures prises à des endroits connus $m_1,\dots,m_M$.

Laisser $\text{dist}(m_i, n_j)$ être la distance euclidienne (généralement inconnue) du point de mesure $m_i$ au point inconnu $n_j$.

Pour chaque mesure $m_i$, nous avons les informations suivantes:

1. Les coordonnées exactes de chaque point inconnu $n_j$ Pour qui $\text{dist}(m_i, n_j)<d_\text{min}$ pour une constante connue $d_\text{min}$; et
2. Une liste de tous les indices $j$ Pour qui $\text{dist}(m_i, n_j) < d_\text{max}$ pour une constante connue $d_\text{max}>d_\text{min}$, trié par $\text{dist}(m_i, n_j)$.

Existe-t-il un algorithme efficace pour calculer les zones de l'avion où les points inconnus, ou un point inconnu donné $n_j$, peut être? L'algorithme reçoit les coordonnées$(X_i,Y_i)$ des points de mesure, les informations de mesure répertoriées ci-dessus et le nombre $N$de points inconnus; l'objectif est de réduire la région des emplacements possibles pour chacun des points inconnus$n_1,\dots,n_N$ autant que possible.

La connexion Pokemon:

Dans Pokemon Go, un jeu de réalité augmentée, le but est de trouver des Pokémons dans la nature. De temps en temps, le jeu montre les Pokémons dans une "plage visible" ($d_{min}$) de la position du joueur. De plus, il dispose d'un "Pokemon finder" qui affiche une liste des environs ($dist<d_{max}$) Pokémons, triés par distance. (Il est également censé montrer une distance approximative comme un, deux ou trois pas, mais apparemment il y a un bug et il montre toujours trois pas.)

Je pense que vous pourriez utiliser une "jointure spatiale". Je n'ai pas joué au jeu, mais je suppose$d_{max}$ est assez petit, c'est-à-dire qu'il y en a environ 10 $n$ et $m$ au voisinage de chacun $m$. Je suppose en outre que$N$ et $M$ sont grandes, disons 1 000 000 ou plus.

1. Met tout $m$ en tant que points 2D dans un index spatial
2. Pour chaque $m_1$ dans l'index, effectuez une requête de plage spatiale avec la distance $2*d_{max}$. Cela vous donne tous les autres$m_x$ qui peut potentiellement contenir le même $n$ comme $m_1$. Cela devrait être gérable car le nombre de$m_x$ devrait être petit (comme je l'ai supposé ci-dessus).
3. Maintenant, en obtenant toutes les autres mesures estimées pour un particulier $n$, vous pouvez essayer d'approximer la bonne $n$
4. (Optimisation potentielle): En fonction de votre indice spatial, vous pouvez supprimer le $m_1$ après avoir traité tout c'est $n$. Cela rend l'ensemble de données plus petit pour les requêtes de plage suivantes. Aussi,

D'une manière ou d'une autre, vous auriez également besoin d'identifier $n$, de sorte que vous ne calculez pas la position de $n$ à nouveau s'il apparaît lors du traitement d'un autre $m$.

À titre d'optimisation, vous souhaiterez peut-être utiliser des requêtes de fenêtre (rectangulaires) plutôt que des requêtes de plage circulaire. Les requêtes de fenêtres peuvent être beaucoup plus rapides et donner seulement un peu plus de résultats. De plus, il se peut que le jeu n'utilise pas réellement la distance euclidienne (cercles) mais la distance manhatten plus rapide, qui serait exactement un rectangle.

Pour une telle jointure spatiale, vous pouvez utiliser n'importe quel index spatial, tel que R-Tree, kd-Tree, quadtree ou l'une de leurs variantes.

Pour les grands ensembles de données, je n'utiliserais probablement pas d'arbre R (arbre R +, arbre R *, arbre X) ou une variante spéciale de l'arbre quadruple, l'arbre PH, qui convient bien aux requêtes de plage ainsi qu'aux permettant le retrait (ou l'ajout) rapide de points.

Pour Java, les implémentations de R-Trees peuvent être trouvées n'importe où sur Internet, par exemple dans le cadre ELKI ou ma propre bibliothèque d'index TinSpin . Le PH-Tree est également disponible en Java.

Un algorithme générique de jointure spatiale est appelé TOUCH , mais je ne pense pas qu'il soit open source.

Si une position d'objet $n_j$ est connue exactement (par exemple, parce $d_{min}$ d'une certaine mesure), puis chaque fois que cela $n_j$ apparaît dans l'espace annulaire pour une mesure $m_i$ (sens $d_{min} \le dist(m_i, n_j) < d_{max}$), nous pouvons réduire les régions possibles pour d'autres positions inconnues dans ce même anneau. Plus précisément, nous pouvons simplement calculer$d_{ij} = dist(m_i, n_j)$ puisque nous connaissons les deux positions ($m_i$ et $n_j$) exactement, et nous pouvons ensuite diviser l'anneau pour $m_i$ en deux sous-anneaux: une pièce "proche" (contenant tous les points $p$ tel que $d_{min} \le dist(m_i, p) < d_{ij}$) et une pièce "lointaine" (contenant tous les points $p$ tel que $d_{ij} \le dist(m_i, p) < d_{max}$). Chaque objet répertorié avant$n_j$ pour la mesure $m_i$ est nécessairement confiné à l'anneau proche, et chaque objet répertorié après $n_j$ est confiné à l'anneau lointain.

Que peut-on faire (au-delà de l'intersection des anneaux déjà suggérée par Tom van der Zanden dans un commentaire) pour des positions d'objet qui ne sont pas liées à une position d'objet déjà connue de cette manière? Cela semble très difficile. La déclaration

"$n_j$ ne peut pas apparaître à $p$"

est équivalent à

"Pour tous les emplacements possibles de tous les points inconnus restants, la définition$n_j = p$, ainsi que les inégalités de distance impliquées par l'ordre dans lequel les objets appartenant à l'anneau de chaque mesure sont répertoriés, conduit à une contradiction ".

Il me semble que pour aller n'importe où, nous devons avoir (au moins) 2 positions d'objets inconnus qui apparaissent dans l'espace annulaire (au moins) des 2 mêmes mesures. Mais alors que ces informations excluront de nombreuses paires de positions pour les deux objets, je n'ai pu trouver aucune circonstance dans laquelle une position pourrait être exclue pour un seul d'entre eux, indépendamment de la position de l'autre objet.