zkv1000 / Nasal / maps / route.nas /
Newer Older
384 lines | 14.305kb
adds route display on map
Sébastien MARQUE authored on 2017-05-11
1
# The following is largely inspired from the Extra500 Avidyne Entegra 9 
2
# https://gitlab.com/extra500/extra500.git
3
# Many thanks to authors: Dirk Dittmann and Eric van den Berg
4
var RouteItemClass = {
5
    new : func (canvasGroup, index) {
6
        var m = {parents:[RouteItemClass]};
7
        m.index = index;
8
        m.group = canvasGroup.createChild('group', 'Waypoint-' ~ index).setVisible(0);
9
        
10
        m.can = {
11
            Waypoint : m.group.createChild('path','icon-' ~ index)
12
                .setStrokeLineWidth(3)
13
                .setScale(1)
14
                .setColor(1,1,1)
15
                .setColorFill(1,1,1)
16
                .moveTo(-20, 0)
17
                .lineTo(-5, 5)
18
                .lineTo(0, 20)
19
                .lineTo(5, 5)
20
                .lineTo(20, 0)
21
                .lineTo(5, -5)
22
                .lineTo(0, -20)
23
                .lineTo(-5, -5)
24
                .close(),
25
            Label : m.group.createChild('text', 'wptLabel-' ~ index)
26
                .setFont('LiberationFonts/LiberationMono-Bold.ttf')
27
                .setTranslation(25,-25)
28
                .setFontSize(20, 1)
29
                .setColor(1,1,1)
30
                .setColorFill(1,1,1),
31
            track : canvasGroup.createChild('path','track-' ~ index)
32
                .setStrokeLineWidth(3)
33
                .setScale(1)
34
                .setColor(1,1,1)
35
                .setVisible(1),
36
        };
37
        return m;
38
    },
39
    setVisible : func (v) {
40
        me.group.setVisible(v);
41
        me.can.track.setVisible(v);
42
    },
43
    draw : func (wpt) {
44
        me.can.Label.setText(wpt[0].name);
45
        me.setColor(1,1,1);
46
        me.group.setGeoPosition(wpt[0].lat, wpt[0].lon);
47
        me.group.setVisible(1);
48
    },
49
    drawTrack : func (wpt) {
50
        var cmds = [];
51
        var coords = [];
52
        var cmd = canvas.Path.VG_MOVE_TO;
53
        me.can.track.setVisible(1);
54
        
55
        foreach (var pt; wpt) {
56
            append(coords, 'N' ~ pt.lat);
57
            append(coords, 'E' ~ pt.lon);
58
            append(cmds, cmd);
59
            cmd = canvas.Path.VG_LINE_TO;
60
        }
61
        me.can.track.setDataGeo(cmds, coords);
62
    },
63
    setColor : func (color) {
64
        me.can.Label.setColor(color).setColorFill(color);
65
        me.can.Waypoint.setColor(color).setColorFill(color);
66
    },
67
    del : func {
deletes route on display on ...
Sébastien MARQUE authored on 2017-05-20
68
        me.can.track.del();
adds route display on map
Sébastien MARQUE authored on 2017-05-11
69
        me.group.del();
70
        me = nil;
71
    },
72
};
73

            
74
var FMSIcon = {
75
    new : func (canvasGroup, text) {
76
        var m = {parents:[ FMSIcon ]};
77
        m.group = canvasGroup.createChild('group', 'FMS-' ~ text).setVisible(0);   
78
        m.can = {
79
            icon : m.group.createChild('path','FMS-icon' ~ text)
80
                .setStrokeLineWidth(3)
81
                .setScale(1)
82
                .setColor(0,1,0)
83
                .setColorFill(0,1,0)
84
                .moveTo(-15, 0)
85
                .lineTo(0, 15)
86
                .lineTo(15, 0)
87
                .lineTo(0, -15)
88
                .close(),
89
            label : m.group.createChild('text', 'FMS-label-' ~ text)
90
                .setFont('LiberationFonts/LiberationMono-Bold.ttf')
91
                .setTranslation(20,12)
92
                .setFontSize(32, 1)
93
                .setColor(0,1,0)
94
                .setColorFill(0,1,0)
95
                .setText(text),
96
        };
97
        return m;
98
    },
99
    setVisible : func (v)
100
        me.group.setVisible(v),
101
    setGeoPosition : func (lat, lon)
102
        me.group.setGeoPosition(lat, lon),
103
};
104

            
105
var FMSIconRTA = {
106
    new : func (canvasGroup, text) {
107
        var m = {parents:[FMSIconRTA]};
108
        m.group = canvasGroup.createChild('group', 'FMS-' ~ text).setVisible(0);   
109
        m.can = {
110
            icon : m.group.createChild('path','FMS-icon' ~ text)
111
                .setStrokeLineWidth(3)
112
                .setScale(1)
113
                .setColor(0,1,0)
114
                .setColorFill(0,1,0)
115
                .moveTo(-15, 0)
116
                .lineTo(0, 15)
117
                .lineTo(15, 0)
118
                .lineTo(0, -15)
119
                .close(),
120
            label : m.group.createChild('text', 'FMS-label-' ~ text)
121
                .setFont('LiberationFonts/LiberationMono-Bold.ttf')
122
                .setTranslation(-80,12)
123
                .setFontSize(32, 1)
124
                .setColor(0,1,0)
125
                .setColorFill(0,1,0)
126
                .setText(text),
127
        };
128
        return m;
129
    },
130
    setVisible : func (v)
131
        me.group.setVisible(v),
132
    setGeoPosition : func (lat, lon)
133
        me.group.setGeoPosition(lat, lon),
134
};
135

            
136
var MapRoute = {
137
    new : func (device, group) {
138
        var m = {parents:[ MapRoute ]}; 
139
        m.item       = [];
140
        m.itemIndex  = 0;
141
        m.visibility = 0;
142
        m.device = device;
143
        m.group = group.createChild('map', 'route map')
144
            .setTranslation(
145
                m.device.role == 'MFD' ? (m.device.data.mapview[0] + m.device.data.mapclip.left)/2 : 120,
146
                m.device.role == 'MFD' ? 400 : 600)
147
            .setVisible(m.visibility);
close issue with misplacing ...
Sébastien MARQUE authored on 2020-06-22
148
        m.group.setRange(m.device.data['range-nm']/2);
adds route display on map
Sébastien MARQUE authored on 2017-05-11
149
        m.group._node
150
            .getNode('ref-lat', 1).setDoubleValue(data.lat);
151
        m.group._node
152
            .getNode('ref-lon', 1).setDoubleValue(data.lon);
153

            
154
        m.groupTrack = m.group.createChild('group', 'Track')
155
            .setVisible(1);
156
        m.groupOBS   = m.group.createChild('group', 'OBS')
157
            .setVisible(0);
158
        m.groupFMS   = m.group.createChild('group', 'FMS')
159
            .setVisible(1);
160
        
161
        m.can = {
162
            track : m.group.createChild('path', 'track')
163
                .setStrokeLineWidth(3)
164
                .setScale(1)
165
                .setColor(1,1,1),
166
            currentLeg : m.groupFMS.createChild('path', 'currentLeg')
167
                .setStrokeLineWidth(5)
168
                .setScale(1)
169
                .setColor(1,0,1),
170
            nextLeg : m.groupFMS.createChild('path', 'nextLeg')
171
                .setStrokeLineWidth(5)
172
                .setScale(1)
173
                .setStrokeDashArray([25,25])
174
                .setColor(1,0,1),
175
            obsCourse : m.groupOBS.createChild('path', 'obsCourse')
176
                .setStrokeLineWidth(5)
177
                .setScale(1)
178
                .setColor(1,0,1),
179
        };
180
        
181
        m.TOD = FMSIcon.new(m.groupFMS, 'TOD');
182
        m.TOC = FMSIcon.new(m.groupFMS, 'TOC');
183
        m.RTA = FMSIconRTA.new(m.groupFMS, 'RTA');
184
        
185
        m.track = {
186
            cmds  : [],
187
            coords: [],
188
        };
189
        m.currentLeg = {
190
            cmds: [ canvas.Path.VG_MOVE_TO, canvas.Path.VG_LINE_TO ],
191
            coords: [0, 0, 0, 0],
192
            index : -1,
193
        };
194
        m.nextLeg = {
195
            cmds: [ canvas.Path.VG_MOVE_TO, canvas.Path.VG_LINE_TO ],
196
            coords: [0, 0, 0, 0],
197
            index : -1,
198
        };
199
        
200
        m.mapOptions = {
201
            orientation : 0,
202
        };
203
        
204
        m.obsMode = 0;
205
        m.obsCourse = 0;
206
        m.obsWaypoint = RouteItemClass.new(m.groupOBS, 'obs_wp');
207
        m.obsCourseData = {
208
            cmds: [ canvas.Path.VG_MOVE_TO, canvas.Path.VG_LINE_TO ],
209
            coords: [0, 0, 0, 0]};
210

            
211
        m.flightPlan = [];
212
        m.currentWpIndex = getprop('/autopilot/route-manager/current-wp');
213
        
214
        return m;
215
    },
poweroff improved
Sébastien MARQUE authored on 2020-05-16
216
    off: func {
217
        me.setVisible(0);
218
        me.group.setVisible(0);
219
        me.group.removeAllChildren();
220
    },
adds route display on map
Sébastien MARQUE authored on 2017-05-11
221
    update: func {
222
        me.visibility != 0 or return;
close issue with misplacing ...
Sébastien MARQUE authored on 2020-06-22
223
        me.group.setRange(me.device.data['range-nm']/2);
adds route display on map
Sébastien MARQUE authored on 2017-05-11
224
        me.group._node.getNode('ref-lat', 1).setDoubleValue(data.lat);
225
        me.group._node.getNode('ref-lon', 1).setDoubleValue(data.lon);
226
    },
227
    setVisible : func (v) {
228
        if (me.visibility != v) {
229
            me.visibility = v;
230
            me.group.setVisible(v);
231
        }
232
    },
233
    updateOrientation : func (value) {
234
        me.mapOptions.orientation = value;
235
        me.can.obsCourse.setRotation((me.obsCourse - me.mapOptions.orientation) * D2R);
236
    },
237
    onFlightPlanChange : func {
238
        for (var i = size(me.item) - 1; i >= 0; i -= 1) {
239
            me.item[i].del();
240
            pop(me.item);
241
        }
242
        me.itemIndex = 0;
243
        me.flightPlan = [];
244
        var route = props.globals.getNode('/autopilot/route-manager/route');
245
        var planSize = getprop('/autopilot/route-manager/route/num');
246
        for (var i=0; i < planSize - 1; i+=1) {
247
            var wp0  = route.getNode('wp[' ~   i   ~ ']');
248
            var wp1  = route.getNode('wp[' ~ (i+1) ~ ']');
249
            append(me.flightPlan, [
250
                {
251
                    lat : wp0.getNode('latitude-deg').getValue(),
252
                    lon : wp0.getNode('longitude-deg').getValue(),
253
                    name: wp0.getNode('id').getValue(),
254
                },
255
                {
256
                    lat : wp1.getNode('latitude-deg').getValue(),
257
                    lon : wp1.getNode('longitude-deg').getValue(),
258
                    name: wp1.getNode('id').getValue(),
259
                }
260
            ]);
261
            append(me.item, RouteItemClass.new(me.groupTrack, i));
262
        }
263
        me.setVisible(me.device.map.visibility);
264
        me.drawWaypoints();
265
    },
266
    onCurrentWaypointChange : func (n) {
267
        me.currentWpIndex = n.getValue();
268
        me.currentLeg.index = me.currentWpIndex - 1;
269
        me.nextLeg.index = me.currentWpIndex;
270
        if (me.currentWpIndex == 0) {
271
            n.setIntValue(1);
272
            me.currentWpIndex = 1;
273
        }
274
        me.drawLegs();
275
    },
276
    drawWaypoints : func {
277
        me.visibility != 0 or return;
278
        var cmd = canvas.Path.VG_MOVE_TO;
279

            
280
        for (var i=0; i < size(me.flightPlan); i+=1) {
281
#            me.item[me.itemIndex].draw(me.flightPlan[i]);
282
            me.item[me.itemIndex].drawTrack(me.flightPlan[i]);
283
            me.itemIndex +=1;
284
        }
285
        me.groupTrack.setVisible(me.visibility and (me.obsMode == 0));
286
    },
287
    drawLegs : func {
288
        me.visibility != 0 or return;
289
        if (me.currentLeg.index >= 0 and me.currentLeg.index < size(me.flightPlan)) {
290
            var cmd = canvas.Path.VG_MOVE_TO;
291
            me.currentLeg.coords = [];
292
            me.currentLeg.cmds = [];
293
            foreach (var pt; me.flightPlan[me.currentLeg.index]) {
294
                append(me.currentLeg.coords, 'N' ~ pt.lat);
295
                append(me.currentLeg.coords, 'E' ~ pt.lon);
296
                append(me.currentLeg.cmds, cmd);
297
                cmd = canvas.Path.VG_LINE_TO;
298
            }
299
            me.can.currentLeg.setDataGeo(me.currentLeg.cmds, me.currentLeg.coords);
300
            me.can.currentLeg.setVisible(1);
301
        }
302
        else
303
            me.can.currentLeg.setVisible(0);
304
        
305
        if (me.nextLeg.index >= 1 and me.nextLeg.index < size(me.flightPlan)) {
306
            var cmd = canvas.Path.VG_MOVE_TO;
307
            me.nextLeg.coords = [];
308
            me.nextLeg.cmds = [];
309
            foreach (var pt; me.flightPlan[me.nextLeg.index]) {
310
                append(me.nextLeg.coords,'N' ~ pt.lat);
311
                append(me.nextLeg.coords,'E' ~ pt.lon);
312
                append(me.nextLeg.cmds,cmd);
313
                cmd = canvas.Path.VG_LINE_TO;
314
            }
315
            me.can.nextLeg.setDataGeo(me.nextLeg.cmds, me.nextLeg.coords);
316
            me.can.nextLeg.setVisible(1);
317
        }
318
        else
319
            me.can.nextLeg.setVisible(0);
320
    },
321
#    _onVisibilityChange : func {
322
#        me.group.setVisible(me.visibility and (me.obsMode == 0));
323
#        me.groupTrack.setVisible(me.visibility and (me.obsMode == 0));
324
#        me.groupFMS.setVisible(me.visibility and (me.obsMode == 0));
325
#        me.groupOBS.setVisible(me.visibility and (me.obsMode == 1));
326
#        me.TOD.setVisible(fms._dynamicPoint.TOD.visible and me.visibility);
327
#        me.TOC.setVisible(fms._dynamicPoint.TOC.visible and me.visibility);
328
#        me.RTA.setVisible(fms._dynamicPoint.RTA.visible and me.visibility);
329
#    },
330
#    _onFplReadyChange : func (n) {
331
#        me.TOD.setVisible(fms._dynamicPoint.TOD.visible and me.visibility);
332
#        me.TOC.setVisible(fms._dynamicPoint.TOC.visible and me.visibility);
333
#        me.RTA.setVisible(fms._dynamicPoint.RTA.visible and me.visibility);
334
#    },
335
#    _onFplUpdatedChange : func (n) {
336
#        if (fms._dynamicPoint.TOD.visible)
337
#            me.TOD.setGeoPosition(fms._dynamicPoint.TOD.position.lat, fms._dynamicPoint.TOD.position.lon);
338
#        if (fms._dynamicPoint.TOC.visible)
339
#            me.TOC.setGeoPosition(fms._dynamicPoint.TOC.position.lat, fms._dynamicPoint.TOC.position.lon);
340
#        if (fms._dynamicPoint.RTA.visible)
341
#            me.RTA.setGeoPosition(fms._dynamicPoint.RTA.position.lat, fms._dynamicPoint.RTA.position.lon);  
342
#        
343
#        me.TOD.setVisible(fms._dynamicPoint.TOD.visible and me.visibility);
344
#        me.TOC.setVisible(fms._dynamicPoint.TOC.visible and me.visibility);
345
#        me.RTA.setVisible(fms._dynamicPoint.RTA.visible and me.visibility);
346
#    },
347
#    _onObsModeChange : func (n) {
348
#        me.obsMode = n.getValue();
349
#        
350
#        if (me.obsMode==1) {
351
#            var wp = {
352
#                wp_lat : getprop('/instrumentation/gps[0]/scratch/latitude-deg'),
353
#                wp_lon : getprop('/instrumentation/gps[0]/scratch/longitude-deg'),
354
#                wp_name : getprop('/instrumentation/gps[0]/scratch/ident'),
355
#            };
356
#            var acLat = getprop('/position/latitude-deg');
357
#            var acLon = getprop('/position/longitude-deg');
358
#            
359
#            me.groupOBS.setGeoPosition(wp.wp_lat, wp.wp_lon);
360
#            
361
#            me.obsCourseData.coords = [
362
#                0,
363
#                0,
364
#                0,
365
#                5000,
366
#            ];
367
#            
368
#            me.obsWaypoint._can.Label.setText(wp.wp_name);
369
#            me.obsWaypoint.setColor(1,0,1);
370
#            me.obsWaypoint._group.setVisible(1);
371
#            
372
#            me.can.obsCourse.setData(me.obsCourseData.cmds,me.obsCourseData.coords);
373
#        }
374
#        
375
#        me.groupTrack.setVisible(me.visibility and (me.obsMode == 0));
376
#        me.groupFMS.setVisible(me.visibility and (me.obsMode == 0));
377
#        me.groupOBS.setVisible(me.visibility and (me.obsMode == 1));
378
#    },
379
#    _onObsCourseChange : func (n) {
380
#        me.obsCourse = n.getValue();
381
#        me.can.obsCourse.setRotation((me.obsCourse - me.mapOptions.orientation) * global.CONST.DEG2RAD);
382
#    },
383
};
384