Qual è un modo efficiente per visitare ogni spazio raggiungibile su una griglia con ostacoli sconosciuti?

Sto cercando di creare una mappa degli ostacoli in uno spazio di griglia 2D abbastanza grossolano, usando l'esplorazione. Rilevo gli ostacoli tentando di spostarmi da uno spazio a uno spazio adiacente, e se ciò fallisce, allora c'è un ostacolo nello spazio di destinazione (non esiste un concetto di sensore di rilevamento della portata in questo problema).

griglia di esempio http://www.eriding.net/resources/general/prim_frmwrks/images/asses/asses_y3_5d_3.gif (ad esempio)

Il processo è completo quando sono stati visitati tutti i quadrati raggiungibili. In altre parole, alcuni spazi potrebbero essere completamente irraggiungibili anche se non hanno ostacoli perché sono circondati. Questo è previsto.

Nel caso più semplice, potrei usare un algoritmo DFS , ma sono preoccupato che il completamento del processo richiederà troppo tempo: il robot impiegherà più tempo a tornare indietro rispetto all'esplorazione di nuovi territori. Mi aspetto che ciò sia particolarmente problematico quando si tenta di raggiungere i quadrati irraggiungibili, perché il robot esaurirà ogni opzione.

Nel metodo più sofisticato, la cosa giusta da fare sembra essere la decomposizione cellulare di Boustrophedon .

Tuttavia, non riesco a trovare una buona descrizione dell'algoritmo di decomposizione delle cellule di Boustrophedon (ovvero una descrizione completa in termini semplici). Ci sono risorse come questo , o questo uno più generale sulla decomposizione cella verticale , ma non offrono molta comprensione gli algoritmi di alto livello, né le strutture di dati a basso livello coinvolti.

Come posso visitare (mappare) questa griglia in modo efficiente? Se esiste, vorrei un algoritmo che funzioni meglio di $O(n^2)$ rispetto al numero totale di quadrati della griglia ( cioè migliore di $O(n^4)$ per un $n*n$ griglia).

La decomposizione delle cellule di Boustrophedon consiste semplicemente nella suddivisione di un ambiente in aree che possono essere efficacemente coperte da un percorso di boustrophedon. Una decomposizione trapezoidale farà, e può essere realizzata usando un algoritmo di line-sweep. Vedi [Choset 2000], Questo sito web , o (raccomando!) L'eccellente libro "Geometria computazionale" di Mark de Berg, et. al, per una descrizione completa delle strutture dati e degli algoritmi richiesti.

Choset, Howie. Robot autonomi "Copertura di spazi noti: la decomposizione cellulare di Boustrophedon" , 2000.

Ad esempio, considera l'insieme di ostacoli come bordi e vertici. Diciamo che anche l'ambiente è delimitato da un poligono speciale. Abbiamo qualcosa di simile al seguente. Per scomporre questo spazio, aggiungiamo semplicemente bordi verticali tra ogni vertice e la linea o il vertice più vicino.

Per eseguire ciò nel codice, è necessario solo un test di intersezione del segmento di linea, un elenco ordinato di spigoli e un elenco ordinato di vertici.

1. $v_i$
2. $l_i$$v_i$
3. Ad ogni incrocio, creare un nuovo vertice.

Al termine, l'insieme di nuovi bordi e vertici racchiude solo i trapezi. Ma sottolineo che non puoi farlo online (senza una conoscenza preliminare degli ostacoli). Se si desidera eseguire una copertura efficace senza una conoscenza preliminare, è possibile esaminare gli "algoritmi di bug". In particolare, ecco un semplice algoritmo, supponendo che l'ambiente sia limitato.

1. Dalla posizione iniziale, spostati verso l'alto e a sinistra fino a raggiungere l'angolo in alto a sinistra dell'ambiente. Se incontri prima un ostacolo, devi attraversarlo. Sai che qualcosa è un ostacolo se può essere circumnavigato (urtare e muovere).

2. Dall'angolo in alto a sinistra, muoviti a destra fino a quando non incontri il confine. Quindi scorri verso il basso e verso sinistra (stiamo facendo un boustrophedon dell'intero spazio).

3. Quando sei sulla linea sinistra-destra e incontri un ostacolo, hai due opzioni. (i) Possiamo circumnavigare fino a raggiungere la linea sinistra-destra che stiamo cercando di coprire, quindi continuare. (ii), possiamo voltarci e coprire una nuova linea sinistra-destra fino a quando non troviamo di nuovo l'ostacolo o finiamo di nuovo in questa situazione. Illustrerò.

A sinistra, ci muoviamo intorno all'ostacolo fino a quando non possiamo tornare alla "linea" che stavamo cercando di seguire. Sulla destra, continuiamo a coprire l'area (più piccola) da un lato dell'ostacolo.

Il vantaggio del primo metodo è di mappare sempre completamente l'ostacolo prima di prendere una decisione su come aggirarlo, in modo da poter prendere il percorso più breve. Il vantaggio del secondo metodo è che non devi assolutamente aggirare l'ostacolo, puoi semplicemente procedere per coprire l'area in cui ti trovi.

Nota che questo definisce la tua decomposizione del boustrophedon in modo online : copri l'area tra gli ostacoli o tra gli ostacoli e il confine.

Tuttavia, per quanto ne so, il primo metodo è più facile da analizzare. Gli algoritmi più complicati (come BFS, ecc.), Vengono scelti o perché l'ambiente è illimitato (non si vuole passare per sempre alla ricerca di un confine), oppure c'è un ostacolo davvero brutto nel modo in cui sostanzialmente si divide l'ambiente. Perché è così male? guarda questo esempio:

Muoversi da sinistra a destra, quindi circondare ogni ostacolo produce modo troppe copertine delle piccole parti tra ogni ostacolo. In effetti, senza una pianificazione globale del percorso, puoi renderlo negativo quanto la risoluzione della tua griglia posizionando queste colonne di 1 px di larghezza, alte quanto l'intero ambiente e 1 px di distanza. Quindi dovresti muoverti attorno all'ostacolo ogni volta che lo colpisci.

Questo è il motivo per cui ti ho chiesto se avevi qualche idea di dove fossi nell'ambiente o se potessi fare una pianificazione globale del percorso. Ma la discussione online vs offline e gli algoritmi ottimali per questo non sono ciò che volevi veramente.

Aggiornamento: ho dovuto rimuovere le immagini (non https) e pubblicherò questo che viene spesso utilizzato nelle applicazioni pratiche del mondo reale. http://www.cs.cmu.edu/~motionplanning/papers/sbp_papers/integrated1/yamauchi_frontiers.pdf

Alla fine, ho scoperto che il modo migliore per farlo era quello di impiegare un concetto molto semplice: Flood Fill . Ho usato un approccio iterativo basato su stack anziché l'opzione ricorsiva e l'ho modificato per lo spazio fisico utilizzando una ricerca A * per trovare un percorso dalla posizione corrente alla posizione successiva nello stack (utilizzando solo quei quadrati della griglia che hanno già stato visitato, poiché sono sicuro di avere un percorso tra di loro).

L'efficienza sembra abbastanza ragionevole.