Alla ricerca di algoritmo per rilevare la cerchia, l'inizio e la fine del cerchio?


24

Ho un sacco di dati di volo da piloti di alianti sotto forma di correzioni gps in un intervallo fisso. Vorrei analizzare la traiettoria di volo e rilevare l'inizio e la fine del "giro" che il pilota di aliante farà quando troverà le termiche.

Idealmente, un algoritmo mi darebbe un inizio e un punto finale sulla linea, definendo un "cerchio". Questi punti potrebbero essere uguali a una delle correzioni gps e non devono essere interpolati.

Potrei semplicemente camminare lungo la traiettoria di volo, controllare la velocità di virata e avere alcuni criteri per decidere se l'aliante sta girando o meno.

Dato che sto usando PostgreSQL con l'estensione PostGIS, ero curioso di sapere se esiste un approccio migliore a questo problema. Ho già una procedura per calcolare l'angolo di due segmenti di linea:

CREATE OR REPLACE FUNCTION angle_between(
  _p1 GEOMETRY(PointZ,4326),
  _p2 GEOMETRY(PointZ,4326),
  _p3 GEOMETRY(PointZ,4326)
) RETURNS DECIMAL AS $$
DECLARE
  az1 FLOAT;
  az3 FLOAT;
BEGIN
  az1 = st_azimuth(_p2,_p1);
  az3 = st_azimuth(_p2,_p3);
IF az3 > az1 THEN
  RETURN (
      degrees(az3 - az1)::decimal - 180
  );
ELSE
  RETURN (
      degrees(az3 - az1)::decimal + 180
  );
END IF;
END;
$$ LANGUAGE plpgsql;

Dovrebbe essere possibile eseguire il loop su tutti i segmenti di linea e verificare, quando la somma degli angoli è maggiore di 360 o inferiore a -360 gradi. Quindi potrei usare st_centroid per rilevare il centro del cerchio, se necessario.

C'è un approccio migliore?


Come richiesto, ho caricato un volo di esempio .

Un percorso di volo di esempio


1
Guardarsi intorno ha dato una svolta a Hough Circle Transform. C'è una discussione utente postgis simile (con un poligono) qui: lists.osgeo.org/pipermail/postgis-users/2015-February/…
Barrett

Grazie ad entrambi. Dò un'occhiata alla trasformazione di Hough. La discussione su osgeo.org presuppone che io sappia già dove inizia e finisce il cerchio, se l'ho capito correttamente?
pgross,


@DevdattaTengshe Sì, ma grazie comunque. Sarebbe un approccio in cui dovrei calcolare le spline e la curvatura esternamente, giusto? Per esterno, intendo non come procedura o query direttamente sul database. Poiché i voli non cambiano, una volta inseriti nel database, questa sarebbe un'opzione.
pgross,

Puoi pubblicare alcuni dati di esempio come file .sql?
dbaston,

Risposte:


14

Non riuscivo a smettere di pensarci ... Sono stato in grado di elaborare una Stored Procedure per eseguire il conteggio dei loop. Il percorso di esempio contiene 109 loop!

Ecco i punti di volo mostrati con i centroidi del loop in rosso: inserisci qui la descrizione dell'immagine

Fondamentalmente, scorre attraverso i punti nell'ordine in cui sono stati catturati e costruisce una linea mentre scorre i punti. Quando la linea che stiamo costruendo crea un loop (usando ST_BuildArea) quindi contiamo un loop e ricominciamo a costruire una linea da quel punto.

Questa funzione restituisce un recordset di ciascun loop che contiene il numero del loop, la sua geometria, il suo punto iniziale / finale e il suo centroide (l'ho anche ripulito un po 'e ho creato nomi di variabili migliori):

DROP FUNCTION test.find_loop_count(flightid int);

create function test.find_Loop_count(
    IN flightid      int,
    OUT loopnumber   int,
    OUT loopgeometry geometry,
    OUT loopstartend geometry,
    OUT loopcentroid geometry
    ) 
  RETURNS SETOF record AS
$BODY$

-- s schema 'test' must exist
-- a table 'points' of flight points must exist
--  we are going to iterate through the point path, building a line as we go
--   If the line creates a loop then we count a loop and start over building a new line
--     add the intersection point to the returning recordset
--     add the centroid of the loop to the resulting recordset
-- pass in the flight ID of the flight that you wish to count its loops for example:
--   SELECT * FROM find_loop_count(37);

DECLARE
    rPoint              RECORD;
    gSegment            geometry = NULL;
    gLastPoint          geometry = NULL;
    gLoopPolygon        geometry = NULL;
    gIntersectionPoint  geometry = NULL;
    gLoopCentroid       geometry = NULL;
    iLoops              integer := 0;
BEGIN
    -- for each line segment in Point Path
    FOR rPoint IN 
        WITH
            pts as (
                SELECT location as geom,datetime,row_number() OVER () as rnum 
                FROM test.points 
                WHERE flight_id=flightid
                ORDER BY 2) 
            SELECT ST_AsText(ST_MakeLine(ARRAY[a.geom, b.geom])) AS geom, a.rnum, b.rnum 
            FROM pts as a, pts as b 
            WHERE a.rnum = b.rnum-1 AND b.rnum > 1
        LOOP

        -- if this is the start of a new line then start the segment otherwise add the point to the segment
        if gSegment is null then
            gSegment=rPoint.geom;
        elseif rPoint.geom::geometry=gLastPoint::geometry then
        -- do not add this point to the segment because it is at the same location as the last point
        else
        -- add this point to the line
        gSegment=ST_Makeline(gSegment,rPoint.geom);
        end if;
        -- ST_BuildArea will return true if the line segment is noded and closed
        --  we must also flatten the line to 2D
        --  lets also make sure that there are more than three points in our line to define a loop
        gLoopPolygon=ST_BuildArea(ST_Node(ST_Force2D(gSegment)));
        if gLoopPolygon is not NULL and ST_Numpoints(gSegment) > 3 then
        -- we found a loop
        iLoops:=iLoops+1;

        -- get the intersection point (start/end)
        gIntersectionPoint=ST_Intersection(gSegment::geometry,rPoint.geom::geometry);

        -- get the centroid of the loop
        gLoopCentroid=ST_Centroid(gLoopPolygon);

        -- start building a new line
        gSegment=null;

        LOOPNUMBER   := iLoops;
        LOOPGEOMETRY := gLoopPolygon;
        LOOPSTARTEND := gIntersectionPoint;
        LOOPCENTROID := gLoopCentroid;

        RETURN NEXT;
        end if;
        -- keep track of last segment
        gLastPoint=rPoint.geom;
    END LOOP;
    RAISE NOTICE 'Total loop count is %.', iLoops;
END;
$BODY$
  LANGUAGE plpgsql STABLE
  COST 100
  ROWS 1000;

Questa è una semplice funzione per restituire solo il conteggio dei loop:

DROP FUNCTION test.find_loop_count(flightid int);

create function test.find_Loop_count(flightid int) RETURNS integer AS $$
-- s schema 'test' must exist
-- a table 'points' of flight points must exist
--  we are going to iterate through the line path, building the line as we go
--   If the line creates a loop then we count a loop and start over building a new line
-- pass in the flight ID of the flight that you wish to count its loops for example:
--   SELECT find_loop_count(37);

DECLARE
    segment RECORD;
    s geometry = NULL;
    lastS geometry = NULL;
    b geometry = NULL;
    loops integer := 1;
BEGIN
    -- for each line segment is Point Path
    FOR segment IN 
        WITH
            pts as (
                SELECT location as geom,datetime,row_number() OVER () as rnum 
                FROM test.points 
                WHERE flight_id=flightid
                ORDER BY 2) 
            SELECT ST_AsText(ST_MakeLine(ARRAY[a.geom, b.geom])) AS geom, a.rnum, b.rnum 
            FROM pts as a, pts as b 
            WHERE a.rnum = b.rnum-1 AND b.rnum > 1
        LOOP

        -- if this is the start of a new line then make s be the segment otherwise add the segment to s
        if s is null then
            s=segment.geom;
        elseif segment.geom::geometry=lastS::geometry then
        else
            s=ST_Makeline(s,segment.geom);
        end if;
        -- ST_BuildArea will return true if the line segment is noded and closed
        --  we must also flatten the line to 2D
        b=ST_BuildArea(st_node(ST_Force2D(s)));
        if b is not NULL and st_numpoints(s) > 3 then
            RAISE NOTICE 's: %', s;
            RAISE NOTICE 'vvvvv %',st_numpoints(s);
            RAISE NOTICE 'I found a loop! Loop count is now %', loops;
            RAISE NOTICE '^^^^^';
            s=null;
            loops:=loops +1;
        end if;
        lastS=segment.geom;
    END LOOP;
    RAISE NOTICE 'Total loop count is %.', loops-1;
    RETURN loops-1;
END;
$$ LANGUAGE plpgsql;


Sembra molto promettente. Grazie mille. Dovrò migliorarlo, poiché non sono interessato al numero di cerchi ma ai punti di inizio / fine. Ma dovrebbe essere facilmente possibile tornare, immagino.
pgross,

Sembra abbastanza intelligente. Come gestisce la situazione in cui un loop interseca un altro loop? O stai saltando i punti iniziali dopo aver individuato un loop?
Peter Horsbøll Møller,

@ PeterHorsbøllMøller Analizza quando la linea crea un ciclo (ST_BuildArea restituirà vero solo quando la linea crea un'area chiusa) piuttosto che cercare intersezioni.
kttii,

@pgross oops true! Mi sono un po 'distratto e ho dimenticato i punti di inizio / fine, ma sì, è una determinazione abbastanza facile ora che i loop si distinguono.
kttii,

@pgross Mi sembra che probabilmente otterresti posizioni più ragionevoli delle termiche localizzando lo ST_Centroid di ciascun loop piuttosto che localizzando l'inizio / la fine di ciascun loop. Cosa pensi? Naturalmente, la funzione potrebbe fornire tutte e tre le statistiche.
kttii,

3

Ho notato che il file gpx ha un timestamp che potrebbe essere sfruttato. Forse l'approccio di seguito potrebbe funzionare.

Make a linesegement with Vi,Vi+1
Make it Polyline
Proceed to Vi+2,Vi+3 check intersection with Polyline
  if it intersects 
      find the point of intersection-Designate this as start/end point of the loop
      Make this intersection point as Vi and Vi+1 would next gpx point per time sequence  
  if the linesegement does not intersect with polyyline then  increment 'i' 

Ho trovato difficile usare ST_Intersects a causa di cerchi sovrapposti che mi hanno portato a utilizzare ST_BuildArea.
kttii,

Ti ho dato la grazia poiché la tua risposta è generalmente sulla stessa strada.
kttii,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.