source: subversion/applications/editors/potlatch/gps.as @ 34598

Last change on this file since 34598 was 19607, checked in by richard, 10 years ago

fix Douglas-Peucker tolerance and background menu layering

File size: 6.9 KB
Line 
1
2        // ================================================================
3        // GPS functions
4       
5        // loadGPS              - load GPS backdrop from server
6
7        function loadGPS() {
8                var q='?xmin='+(_root.edge_l-0.01)+'&xmax='+(_root.edge_r+0.01)+'&ymin='+(_root.edge_b-0.01)+'&ymax='+(_root.edge_t+0.01)+'&baselong='+_root.baselong+'&basey='+_root.basey+'&masterscale='+_root.masterscale;
9                if (q==_root.lastgps) {
10                        _root.gpsoffset+=1;
11                } else {
12                        _root.gpsoffset=0;
13                        _root.map.createEmptyMovieClip('gps',3);
14                }
15                _root.map.gps.createEmptyMovieClip(_root.gpsoffset,_root.gpsoffset);
16                _root.lastgps=q;
17
18                if (Key.isDown(Key.SHIFT)) { loadMovie(gpsurl+q+'&start='+(_root.gpsoffset*10000)+'&token='+_root.usertoken,_root.map.gps[_root.gpsoffset]); }
19                                                          else { loadMovie(gpsurl+q+'&start='+(_root.gpsoffset*10000),_root.map.gps[_root.gpsoffset]); }
20        }
21
22        // parseGPX             - parse GPX file
23        // parsePoint
24       
25        function parseGPX(gpxname) {
26                writeText(_root.windows.pleasewait.box.prompt,iText('gpxpleasewait'));
27
28                _root.tracks=new Array();
29                _root.curtrack=0; _root.tracks[curtrack]=new Array();
30                _root.map.gpx.createEmptyMovieClip("line",1);
31                _root.map.gpx.line.lineStyle(1,0x00FFFF,100,false,"none");
32                _root.gpxpoints=0;
33
34                var gpxs=gpxname.split(',');
35                for (var g in gpxs) {
36                        var gpxdoc=new XML();
37                        gpxdoc.load(gpxurl+gpxs[g]+gpxsuffix);
38                        gpxdoc.onLoad=function() {
39               
40                                _root.lastTime=0;
41                                var waypoints=new Array();
42                                var level1=this.childNodes;
43                                for (i=0; i<level1.length; i+=1) {
44                                        if (level1[i].nodeName=='gpx') {
45                                                var level2=level1[i].childNodes;
46                                                for (j=0; j<level2.length; j+=1) {
47                                                        if (level2[j].nodeName=='trk') {
48                                                                var level3=level2[j].childNodes;
49                                                                for (k=0; k<level3.length; k+=1) {
50                                                                        if (level3[k].nodeName=='trkseg') {
51                                                                                var level4=level3[k].childNodes;
52                                                                                for (l=0; l<level4.length; l+=1) {
53                                                                                        if (level4[l].nodeName=='trkpt') {
54                                                                                                parsePoint(level4[l]);
55                                                                                        }
56                                                                                }
57                                                                                lastTime=0;
58                                                                        }
59                                                                }
60                                                        } else if (level2[j].nodeName=='wpt') {
61                                                                var wpattr=new Array();
62                                                                var level3=level2[j].childNodes;
63                                                                for (k=0; k<level3.length; k+=1) {
64                                                                        if (level3[k].nodeName=='name') { wpattr['name'                   ]=level3[k].firstChild.nodeValue; }
65                                                                        if (level3[k].nodeName=='ele' ) { wpattr['ele'                    ]=level3[k].firstChild.nodeValue; }
66                                                                        if (level3[k].nodeName=='sym' ) { wpattr['wpt_symbol'     ]=level3[k].firstChild.nodeValue; }
67                                                                        if (level3[k].nodeName=='desc') { wpattr['wpt_description']=level3[k].firstChild.nodeValue; }
68                                                                }
69                                                                waypoints.push(new Array(level2[j].attributes['lon'],level2[j].attributes['lat'],wpattr));
70                                                        }
71                                                }
72                                        }
73                                }
74                                // Do waypoints last, because we might not have the base lat/lon at the start
75                                for (i in waypoints) {
76                                        _root.map.pois.attachMovie("poi",--newnodeid,++poidepth);
77                                        _root.map.pois[newnodeid]._x=long2coord(waypoints[i][0]);
78                                        _root.map.pois[newnodeid]._y=lat2coord (waypoints[i][1]);
79                                        _root.map.pois[newnodeid].attr=waypoints[i][2];
80                                        _root.map.pois[newnodeid].locked=true;
81                                        _root.map.pois[newnodeid].clean=false;
82                                        _root.map.pois[newnodeid].recolour();
83                                        _root.poicount+=1;
84                                }
85                                _root.windows.pleasewait.remove();
86                        };
87                }
88        }
89
90        function parsePoint(xmlobj) {
91                _root.gpxpoints++;
92                if (lat) {
93                } else {                                                                        // Get root co-ords from first point in GPX
94                        _root.lat =xmlobj.attributes['lat'];    // (was briefly if (gpxpoints>4), but
95                        _root.long=xmlobj.attributes['lon'];    //  obviously this broke lat2coord for the
96                        changeScaleTo(17); bscale=16;                   //  first four points... ** need to fix)
97                        startPotlatch();                                                //
98                }
99                var y= lat2coord(xmlobj.attributes['lat']);
100                var x=long2coord(xmlobj.attributes['lon']);
101                var tme=new Date();
102                tme.setTime(0);
103                var xcn=xmlobj.childNodes;
104                for (a in xcn) {
105                        if (xcn[a].nodeName=='time') {
106                                str=xcn[a].firstChild.nodeValue;
107                                if (str.substr( 4,1)=='-' &&
108                                        str.substr(10,1)=='T') {
109                                        tme.setFullYear(str.substr(0,4),str.substr(5,2),str.substr(8,2));
110                                        tme.setHours(str.substr(11,2));
111                                        tme.setMinutes(str.substr(14,2));
112                                        tme.setSeconds(str.substr(17,2));
113                                }
114                        }
115                }
116
117                if (tme==null || tme.getTime()-_root.lastTime<180000) {
118                        _root.map.gpx.line.lineTo(x,y);
119                        _root.tracks[curtrack].push(new Array(x,y));
120                } else {
121                        _root.map.gpx.line.moveTo(x,y);
122                        _root.curtrack+=1;
123                        _root.tracks[curtrack]=new Array();
124                        _root.tracks[curtrack].push(new Array(x,y));
125                }
126                lastTime=tme.getTime();
127        }
128       
129        // gpxToWays    - convert all GPS tracks to ways
130       
131        function gpxToWays() {
132                var tol=0.2*64; if (Key.isDown(Key.SHIFT)) { tol=0.1*64; }
133                for (var i=0; i<_root.tracks.length; i+=1) {
134                        _root.tracks[i]=simplifyPath(_root.tracks[i],tol);
135
136                        _root.newwayid--;
137                        _root.map.ways.attachMovie("way",newwayid,++waydepth);
138                        _root.map.ways[newwayid].xmin= 999999;
139                        _root.map.ways[newwayid].xmax=-999999;
140                        _root.map.ways[newwayid].ymin= 999999;
141                        _root.map.ways[newwayid].ymax=-999999;
142                        for (var j=0; j<_root.tracks[i].length; j+=1) {
143                                _root.newnodeid--;
144                                _root.nodes[newnodeid]=new Node(newnodeid,_root.tracks[i][j][0],_root.tracks[i][j][1],new Array(),0);
145                                _root.nodes[newnodeid].addWay(newwayid);
146                                _root.map.ways[newwayid].path.push(_root.nodes[newnodeid]);
147                                _root.map.ways[newwayid].xmin=Math.min(_root.tracks[i][j][0],_root.map.ways[newwayid].xmin);
148                                _root.map.ways[newwayid].xmax=Math.max(_root.tracks[i][j][0],_root.map.ways[newwayid].xmax);
149                                _root.map.ways[newwayid].ymin=Math.min(_root.tracks[i][j][1],_root.map.ways[newwayid].ymin);
150                                _root.map.ways[newwayid].ymax=Math.max(_root.tracks[i][j][1],_root.map.ways[newwayid].ymax);
151                        }
152                        _root.map.ways[newwayid].clean=false;
153                        _root.map.ways[newwayid].locked=true;
154                        _root.map.ways[newwayid].redraw();
155                }
156        }
157
158        // ================================================================
159        // Douglas-Peucker code
160
161        function distance(ax,ay,bx,by,l,cx,cy) {
162                // l=length of line
163                // r=proportion along AB line (0-1) of nearest point
164                var r=((cx-ax)*(bx-ax)+(cy-ay)*(by-ay))/(l*l);
165                // now find the length from cx,cy to ax+r*(bx-ax),ay+r*(by-ay)
166                var px=(ax+r*(bx-ax)-cx);
167                var py=(ay+r*(by-ay)-cy);
168                return Math.sqrt(px*px+py*py);
169        }
170
171        function simplifyPath(track,tolerance) {
172                if (track.length<=2) { return track; }
173               
174                result=new Array();
175                stack=new Array();
176                stack.push(track.length-1);
177                anchor=0;
178               
179                while (stack.length) {
180                        float=stack[stack.length-1];
181                        var xa=track[anchor][0]; var xb=track[float][0];
182                        var ya=track[anchor][1]; var yb=track[float][1];
183                        var l=Math.sqrt((xb-xa)*(xb-xa)+(yb-ya)*(yb-ya));
184                        var furthest=0; var furthdist=0;
185       
186                        // find furthest-out point
187                        for (var i=anchor+1; i<float; i+=1) {
188                                var d=distance(xa,ya,xb,yb,l,track[i][0],track[i][1]);
189                                if (d>furthdist && d>tolerance) { furthest=i; furthdist=d; }
190                        }
191                       
192                        if (furthest==0) {
193                                anchor=stack.pop();
194                                result.push(new Array(track[float][0],track[float][1]));
195                        } else {
196                                stack.push(furthest);
197                        }
198                }
199
200                return result;
201        }
202
Note: See TracBrowser for help on using the repository browser.