Add straight line support to routing

config.template.js

@@ -100,6 +100,18 @@
         nodata: {
             color: 'darkred',
         },
+        beeline: {
+            weight: 5,
+            dashArray: [1, 10],
+            color: 'magenta',
+            opacity: BR.conf.defaultOpacity,
+        },
+        beelineTrailer: {
+            weight: 5,
+            dashArray: [1, 10],
+            opacity: 0.6,
+            color: 'magenta',
+        },
     };
 
     BR.conf.markerColors = {

css/style.css

@@ -443,6 +443,22 @@ button.btn {
     line-height: 30px;
 }
 
+button.activate-beeline-active,
+button.deactivate-beeline-active {
+    transition-duration: 0.3s;
+}
+button.activate-beeline-active.disabled,
+button.deactivate-beeline-active.disabled {
+    height: 0;
+    border-bottom-width: 0px;
+}
+.mdi.active {
+    fill: #2074b6;
+}
+.mdi {
+    width: 18px;
+}
+
 /* smaller tab height */
 .nav > li > a {
     padding: 2px 15px;

index.html

@@ -1131,6 +1131,16 @@ <h1 class="leaflet-sidebar-header">
             </div>
             <div id="stats-container" class="flexrow flexgrow">
                 <ul id="stats">
+                    <li id="beeline-warning" hidden>
+                        <div class="text-muted small d-none d-md-block">&#8239;</div>
+                        <p class="stats-label">
+                            <abbr
+                                class="fa fa-exclamation-triangle"
+                                data-i18n="[title]footer.beeline-warning"
+                                title="Warning: no data for straight lines, values interpolated"
+                            ></abbr>
+                        </p>
+                    </li>
                     <li>
                         <div class="text-muted small d-none d-md-block" data-i18n="footer.distance">Distance</div>
                         <p class="stats-label">

js/Map.js

@@ -12,13 +12,15 @@ BR.Map = {
 
         var maxZoom = 19;
 
+        if (BR.Browser.touch) {
+            L.Draggable.prototype.options.clickTolerance = 10;
+        }
+
         map = new L.Map('map', {
             zoomControl: false, // add it manually so that we can translate it
             worldCopyJump: true,
             minZoom: 0,
             maxZoom: maxZoom,
-            // fix for route drag on mobile (#285), until next Leaflet version released (> 1.6.0)
-            tap: false,
         });
 
         if (BR.Util.getResponsiveBreakpoint() >= '3md') {

js/control/Export.js

@@ -74,7 +74,15 @@ BR.Export = L.Class.extend({
             link.download = (name || 'brouter') + '.' + format;
             link.click();
         } else {
-            var uri = this.router.getUrl(this.latLngs, this.pois.getMarkers(), null, format, nameUri, includeWaypoints);
+            var uri = this.router.getUrl(
+                this.latLngs,
+                null,
+                this.pois.getMarkers(),
+                null,
+                format,
+                nameUri,
+                includeWaypoints
+            );
             var evt = document.createEvent('MouseEvents');
             evt.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
             var link = document.createElement('a');
@@ -284,8 +292,15 @@ BR.Export._concatTotalTrack = function (segments) {
 
         let featureCoordinates = feature.geometry.coordinates;
         if (segmentIndex > 0) {
-            // remove first segment coordinate, same as previous last
-            featureCoordinates = featureCoordinates.slice(1);
+            // remove duplicate coordinate: first segment coordinate same as previous last,
+            // remove the one without ele value (e.g. beeline)
+            const prevLast = coordinates[coordinates.length - 1];
+            const first = featureCoordinates[0];
+            if (prevLast.length < first.length) {
+                coordinates.pop();
+            } else {
+                featureCoordinates = featureCoordinates.slice(1);
+            }
         }
         coordinates = coordinates.concat(featureCoordinates);
     }

js/control/Profile.js

@@ -38,48 +38,41 @@ BR.Profile = L.Evented.extend({
         button.blur();
     },
 
-    update: function (options) {
+    update: function (options, cb) {
         var profileName = options.profile,
             profileUrl,
-            empty = !this.editor.getValue(),
-            clean = this.editor.isClean();
+            loading = false;
 
         if (profileName && BR.conf.profilesUrl) {
-            // only synchronize profile editor/parameters with selection if no manual changes in full editor,
-            // else keep custom profile pinned - to prevent changes in another profile overwriting previous ones
-            if (empty || clean) {
-                this.profileName = profileName;
-                if (!(profileName in this.cache)) {
-                    profileUrl = BR.conf.profilesUrl + profileName + '.brf';
-                    BR.Util.get(
-                        profileUrl,
-                        L.bind(function (err, profileText) {
-                            if (err) {
-                                console.warn('Error getting profile from "' + profileUrl + '": ' + err);
-                                return;
-                            }
-
-                            this.cache[profileName] = profileText;
-
-                            // don't set when option has changed while loading
-                            if (!this.profileName || this.profileName === profileName) {
-                                this._setValue(profileText);
-                            }
-                        }, this)
-                    );
-                } else {
-                    this._setValue(this.cache[profileName]);
-                }
+            this.selectedProfileName = profileName;
+
+            if (!(profileName in this.cache)) {
+                profileUrl = BR.conf.profilesUrl + profileName + '.brf';
+                loading = true;
+                BR.Util.get(
+                    profileUrl,
+                    L.bind(function (err, profileText) {
+                        if (err) {
+                            console.warn('Error getting profile from "' + profileUrl + '": ' + err);
+                            if (cb) cb();
+                            return;
+                        }
 
-                if (!this.pinned.hidden) {
-                    this.pinned.hidden = true;
-                }
+                        this.cache[profileName] = profileText;
+
+                        // don't set when option has changed while loading
+                        if (!this.profileName || this.selectedProfileName === profileName) {
+                            this._updateProfile(profileName, profileText);
+                        }
+                        if (cb) cb();
+                    }, this)
+                );
             } else {
-                if (this.pinned.hidden) {
-                    this.pinned.hidden = false;
-                }
+                this._updateProfile(profileName, this.cache[profileName]);
             }
         }
+
+        if (cb && !loading) cb();
     },
 
     show: function () {
@@ -101,7 +94,7 @@ BR.Profile = L.Evented.extend({
             }
         }
 
-        const profileText = this._getProfileText();
+        const profileText = this._getSelectedProfileText();
         if (!profileText) return value;
 
         const regex = new RegExp(`assign\\s*${name}\\s*=?\\s*([\\w\\.]*)`);
@@ -188,6 +181,26 @@ BR.Profile = L.Evented.extend({
         });
     },
 
+    _updateProfile: function (profileName, profileText) {
+        const empty = !this.editor.getValue();
+        const clean = this.editor.isClean();
+
+        // only synchronize profile editor/parameters with selection if no manual changes in full editor,
+        // else keep custom profile pinned - to prevent changes in another profile overwriting previous ones
+        if (empty || clean) {
+            this.profileName = profileName;
+            this._setValue(profileText);
+
+            if (!this.pinned.hidden) {
+                this.pinned.hidden = true;
+            }
+        } else {
+            if (this.pinned.hidden) {
+                this.pinned.hidden = false;
+            }
+        }
+    },
+
     _setValue: function (profileText) {
         profileText = profileText || '';
 
@@ -363,4 +376,8 @@ BR.Profile = L.Evented.extend({
     _getProfileText: function () {
         return this.editor.getValue();
     },
+
+    _getSelectedProfileText: function () {
+        return this.cache[this.selectedProfileName] ?? this.editor.getValue();
+    },
 });

js/control/TrackAnalysis.js

@@ -470,9 +470,11 @@ BR.TrackAnalysis = L.Class.extend({
                     }
 
                     return typeof parsed.tracktype === 'string' && parsed.tracktype === trackType;
+                } else if (dataName === 'internal-unknown' && typeof parsed.highway !== 'string') {
+                    return true;
                 }
 
-                return parsed.highway === dataName;
+                return typeof parsed.highway === 'string' && parsed.highway === dataName;
             case 'surface':
                 if (dataName === 'internal-unknown' && typeof parsed.surface !== 'string') {
                     return true;

js/control/TrackStats.js

@@ -9,6 +9,9 @@ BR.TrackStats = L.Class.extend({
         $('#stats-container').show();
         $('#stats-info').hide();
 
+        const hasBeeline = segments.filter((line) => line?._routing?.beeline).length > 0;
+        document.getElementById('beeline-warning').hidden = !hasBeeline;
+
         var stats = this.calcStats(polyline, segments),
             length1 = L.Util.formatNum(stats.trackLength / 1000, 1).toLocaleString(),
             length3 = L.Util.formatNum(stats.trackLength / 1000, 3).toLocaleString(undefined, {

js/format/Xml.js

@@ -25,7 +25,11 @@ BR.Xml = {
                 }
             } else {
                 if (singleLineTagList.includes(tag)) {
-                    singleLineTag = tag;
+                    const closeIndex = xml.indexOf('>', match.index + 1);
+                    const selfClosing = xml.charAt(closeIndex - 1) === '/';
+                    if (!selfClosing) {
+                        singleLineTag = tag;
+                    }
                 }
                 let endIndex = match.index + 1;
                 lines.push(xml.substring(startIndex, endIndex));