Show the angle between two connected (or selected) segments — experimental branch adding Junction Box and Path (far turn) support
// ==UserScript== // @name WME Junction Angle Info // @description Show the angle between two connected (or selected) segments — experimental branch adding Junction Box and Path (far turn) support // @namespace https://greasyfork.org/en/users/166843-wazedev // @match *://*.waze.com/*editor* // @exclude *://*.waze.com/user/editor* // @exclude *://*.waze.com/editor/sdk/* // @version 3.2.2 // @grant GM_xmlhttpRequest // @grant GM_info // @connect greasyfork.org // @namespace https://greasyfork.org/scripts/35547-wme-junction-angle-info/ // @require https://greasyfork.org/scripts/24851-wazewrap/code/WazeWrap.js // @require https://update.greasyfork.org/scripts/509664/WME%20Utils%20-%20Bootstrap.js // @require https://cdn.jsdelivr.net/npm/@turf/turf@7/turf.min.js // @author WazeDev / JS55CT // @copyright 2026 JS55CT, 2018 seb-d59, 2016 Michael Wikberg <[email protected]> // @license CC-BY-NC-SA // @icon data:image/png;base64,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 // ==/UserScript== /** * Copyright 2016 Michael Wikberg <[email protected]> * WME Junction Angle Info extension is licensed under a Creative Commons * Attribution-NonCommercial-ShareAlike 3.0 Unported License. * See README.md for full contributor history. * * Original author: * 2013–2019 Michael Wikberg "milkboy" <[email protected]> * Core logic, architecture, Swedish & Finnish translations * * Contributions by: * 2014 Paweł Pyrczak "tkr85" WME update compatibility fixes * 2014 "AlanOfTheBerg" WME update compatibility fixes * 2014 "berestovskyy" WME update compatibility fixes * 2015 "FZ69617" Best-continuation (BC) logic fixes * 2015 "wlodek76" Contributions * 2016 Sergey Kuznetsov "WazeRus" Russian translation * 2016 "MajkiiTelini" Czech translation * 2016 "witoco" Latin-American Spanish translation * 2017 "seb-d59" French translation; override instruction detection * 2019 "Sapozhnik" Ukrainian translation * "ccclxv" British English (UK) translation * 2024 "g1220k" Contributions * 2026 "JS55CT" V3.0.0 Current maintainer; SDK migration, * V3.1.0 - 3.1.5 RoundAbout support, JB and Paths * V3.2.0 Added Continuous scanning for problem angles */ /*global I18n, $, bootstrap, turf, getWmeSdk, SDK_INITIALIZED, GM_info, GM_xmlhttpRequest*/ (async function () { 'use strict'; // ************************************************************************************************************** // IMPORTANT: Update this when releasing a new version of script // ************************************************************************************************************** const SHOW_UPDATE_MESSAGE = true; const SCRIPT_VERSION_CHANGES = [ 'Version 3.2.2', 'Small bug fix', 'Version 3.2.0', 'Experimenmtal: "Scan for Angles to Avoid" feature: background detection of PROBLEM angles replaces the need for the BJAI script!', 'Version 3.1.5', 'Intermediate breadcrumbs inside a JB inherit all the routing logic: road type hierarchy (Primary vs Street), left-hand traffic, best-continuation detection, and Keep/Exit classification.', 'Version 3.1.4', 'More robust marker overlap prevention system', 'Version 3.1.3', 'Roundabout turn restriction detection — exits with local restrictions display as NO_TURN (gray), works for RHT and LHT countries', 'version 3.1.1', 'Experimental: Far-turn angle display for Junction Boxes — breadcrumb trail through complex intersections (disabled by default)', 'Experimental: Far-turn angle display for Paths — complete angle annotations along Path routes (disabled by default)', ]; const SCRIPT_VERSION = GM_info.script.version.toString(); const DOWNLOAD_URL = 'https://update.greasyfork.org/scripts/35547/WME%20Junction%20Angle%20Info.user.js'; // ── Debug & execution state ─────────────────────────────────────────────── // Runtime flags and counters used across the module. var junctionangle_debug = 1; // 0=off, 1=errors+warnings, 2=key decisions (function outcomes), 3=per-segment detail, 4=object dumps+internals — lower to 1 before release var ja_last_restart = 0; // epoch ms timestamp — throttles auto-restart on stale data errors var sdk; // WME SDK instance, assigned by bootstrap() // ── Settings storage ────────────────────────────────────────────────────── // ja_options holds all persisted user preferences (read/written via localStorage). // ja_getOption() / ja_setOption() are the only safe accessors — they apply defaults // and validate values against the ja_settings schema. var ja_options = {}; // ── Cached data model properties ────────────────────────────────────────── // Cached values from SDK to avoid redundant queries during module execution. var ja_is_left_hand_traffic = false; // Cached from Countries.getAll()[0].isLeftHandTraffic (set during bootstrap) // ── Map layer state ─────────────────────────────────────────────────────── // Shared state for the 'junction_angles' SDK map layer. var ja_layer_created = false; // true once sdk.Map.addLayer() has returned var ja_layer_visible = true; // mirrors the current Layer Switcher checkbox state var ja_roundabout_points = []; // GeoJSON Points of RA markers placed this pass (collision detection) var ja_current_features = []; // all features placed this render pass (overlap avoidance) var ja_feature_counter = 0; // monotonic counter; features are named 'ja_' + (++ja_feature_counter) // ── Marker position tracking (for local/far-turn overlap prevention) ───────────────────────── // Maps to track marker positions during a render pass so local and far-turn markers can coordinate. // Structure: map<nodeId, array<{bearing, distance}>> // Reset each render pass at start of testSelectedItem(). var ja_local_markers_by_node = {}; // Local turn markers indexed by node, with bearings and distances var ja_far_turn_bearings_by_node = {}; // Far-turn markers indexed by node, with bearings and distances // ── UI state ────────────────────────────────────────────────────────────── var ja_sidebar_tabPane = null; // SDK tab pane element — retained so setupHtml() can re-render it // ── Continuous Scanning State (Phase 1: Cache + Event Infrastructure) ──────────────────── // Persistent cache survives across render passes (unlike ja_current_features which clears each pass) var ja_continuous_cache = {}; // { nodeId: { timestamp, angles: [] } } — cross-render persistent var ja_continuous_rendered = new Set(); // Track which angle markers already rendered to prevent duplicates var ja_continuous_mode = false; // Feature flag: continuous scanning enabled/disabled var ja_continuous_scan_timer = null; // Debounce timer (100ms, separate from ja_calculation_timer) var ja_continuous_batch_index = 0; // Track progress in batch scan (for incremental processing) var ja_nodes_all = []; // Copy of all viewport nodes (refreshed each scan start) var ja_continuous_enabled = false; // Load from localStorage on init var ja_continuous_needs_batching = []; // Nodes that need cache calculation (misses) // ── Angle classification thresholds ────────────────────────────────────── // Waze routing instruction boundaries derived from map experiments and the Waze wiki. var TURN_ANGLE = 45.5; // degrees — boundary between a Keep and a Turn instruction (wiki: 45.04°) var U_TURN_ANGLE = 168.24; // degrees — boundary above which a turn is classified as a U-Turn var GRAY_ZONE = 1.5; // degrees — margin around TURN_ANGLE to absorb measurement noise // ── Timing configuration for continuous scanning ────────────────────────── var BATCH_PROCESSING_DELAY = 50; // milliseconds — delay between incremental batch processing cycles var CONTINUOUS_SCAN_DEBOUNCE = 100; // milliseconds — debounce window for coalescing rapid pan/zoom/edit events var OVERLAPPING_ANGLE = 0.666; // degrees — two segments closer than this are treated as collinear var MIN_ZOOM_LEVEL = 17; // hide all markers when zoomed out past this level var PERPENDICULAR_TOLERANCE = 15; // degrees — tolerance for ±15° of perpendicular (90° multiple) in roundabouts and angle classification var WAZE_PARALLELISM_TOLERANCE = 5; // degrees — parallelism threshold for A and C segments var WAZE_MEDIAN_LENGTH_DEFAULT = 30; // meters — default median segment length for Waze U-turn qualification var WAZE_MEDIAN_LENGTH_EXTENDED = 50; // meters — extended threshold with lane guidance on incoming segment var WAZE_MEDIAN_LENGTH_THRESHOLD = 15; // meters — strict median threshold for optional Waze restriction (when setting is ON) // Roundabout instruction thresholds (CCW angle ranges for normal roundabouts in right-hand traffic) var ROUNDABOUT_INSTRUCTION_UTURN_THRESHOLD = 45; // < 45° or ≥ 315° → U-Turn var ROUNDABOUT_INSTRUCTION_TURN_RIGHT_THRESHOLD = 135; // 45° – 135° → Turn Right (45 + 90) var ROUNDABOUT_INSTRUCTION_CONTINUE_THRESHOLD = 225; // 135° – 225° → Continue (135 + 90) var ROUNDABOUT_INSTRUCTION_TURN_LEFT_THRESHOLD = 315; // 225° – 315° → Turn Left (225 + 90) // ── Routing instruction type enum ──────────────────────────────────────── // String keys stored in GeoJSON feature properties and matched by SDK styleRules predicates. // BC = "best continuation" — Waze gives no spoken instruction for this turn. // Override* variants are used when a turn has a manually set instruction opcode. var ja_routing_type = { BC: 'junction_none', KEEP: 'junction_keep', KEEP_LEFT: 'junction_keep_left', KEEP_RIGHT: 'junction_keep_right', TURN: 'junction_turn', TURN_LEFT: 'junction_turn_left', TURN_RIGHT: 'junction_turn_right', EXIT: 'junction_exit', EXIT_LEFT: 'junction_exit_left', EXIT_RIGHT: 'junction_exit_right', U_TURN: 'junction_u_turn', PROBLEM: 'junction_problem', NO_TURN: 'junction_no_turn', NO_U_TURN: 'junction_no_u_turn', ROUNDABOUT: 'junction_roundabout', ROUNDABOUT_EXIT: 'junction_roundabout_exit', OverrideBC: 'Override_none', OverrideCONTINUE: 'Override_continue', OverrideKEEP_LEFT: 'Override_keep_left', OverrideKEEP_RIGHT: 'Override_keep_right', OverrideTURN_LEFT: 'Override_turn_left', OverrideTURN_RIGHT: 'Override_turn_right', OverrideEXIT: 'Override_exit', OverrideEXIT_LEFT: 'Override_exit_left', OverrideEXIT_RIGHT: 'Override_exit_right', OverrideU_TURN: 'Override_u_turn', // ── Far turn types (experimental) ───────────────────────────────────── // Far turns (isPathTurn or isJunctionBoxTurn) now use the same ja_routing_type values // as regular node turns (BC, TURN, KEEP, etc.) — classified by ja_guess_routing_instruction // using the instruction-firing angle (entry segment → first intermediate segment at entry node). // // The distinction between Path turns and JB turns is communicated via: // • ja_is_far_turn: true on the GeoJSON feature properties → purple outline ring // // No separate PATH_TURN or JB_TURN type constants are needed. The two SDK flags are // still used to identify far turns during processing in ja_draw_far_turn_markers(): // turn.isPathTurn === true → Path (FL2) far turn // turn.isJunctionBoxTurn === true → Junction Box far turn // Note: these two flags are mutually exclusive. }; // ── Road type enum ──────────────────────────────────────────────────────── // Numeric road-type IDs matching WME data model values. // Used by ja_is_primary_road(), ja_is_ramp(), and routing instruction prediction. var ja_road_type = { //Streets NARROW_STREET: 22, STREET: 1, PRIMARY_STREET: 2, //Highways RAMP: 4, FREEWAY: 3, MAJOR_HIGHWAY: 6, MINOR_HIGHWAY: 7, //Other drivable DIRT_ROAD: 8, FERRY: 14, PRIVATE_ROAD: 17, PARKING_LOT_ROAD: 20, //Non-drivable WALKING_TRAIL: 5, PEDESTRIAN_BOARDWALK: 10, STAIRWAY: 16, RAILROAD: 18, RUNWAY: 19, }; // ── Settings schema ─────────────────────────────────────────────────────── // Each entry describes one user-configurable option: the UI element type/id and // the default value applied when no stored value exists or the stored value is invalid. // Settings with a 'group' key are visually disabled when their parent checkbox is unchecked. // ja_getOption() / ja_setOption() are the only safe accessors — never read ja_options directly. var ja_settings = { angleMode: { elementType: 'select', elementId: '_jaSelAngleMode', defaultValue: 'aDeparture', options: ['aAbsolute', 'aDeparture'] }, angleDisplay: { elementType: 'select', elementId: '_jaSelAngleDisplay', defaultValue: 'displayFancy', options: ['displayFancy', 'displaySimple'] }, angleDisplayArrows: { elementType: 'select', elementId: '_jaSelAngleDisplayArrows', defaultValue: '⇐⇒⇖⇗⇑', options: ['<><>', '⇦⇨⇦⇨⇧', '⇐⇒⇐⇒⇑', '←→←→↑', '⇐⇒⇖⇗⇑', '←→↖↗↑'] }, override: { elementType: 'checkbox', elementId: '_jaCbOverride', defaultValue: true, group: 'guess' }, overrideAngles: { elementType: 'checkbox', elementId: '_jaCboverrideAngles', defaultValue: false, group: 'override' }, guess: { elementType: 'checkbox', elementId: '_jaCbGuessRouting', defaultValue: true }, noInstructionColor: { elementType: 'color', elementId: '_jaTbNoInstructionColor', defaultValue: '#ffffff', group: 'guess' }, continueInstructionColor: { elementType: 'color', elementId: '_jaTbContinueInstructionColor', defaultValue: '#ffffff', group: 'guess' }, keepInstructionColor: { elementType: 'color', elementId: '_jaTbKeepInstructionColor', defaultValue: '#cbff84', group: 'guess' }, exitInstructionColor: { elementType: 'color', elementId: '_jaTbExitInstructionColor', defaultValue: '#6cb5ff', group: 'guess' }, turnInstructionColor: { elementType: 'color', elementId: '_jaTbTurnInstructionColor', defaultValue: '#4cc600', group: 'guess' }, uTurnInstructionColor: { elementType: 'color', elementId: '_jaTbUTurnInstructionColor', defaultValue: '#b66cff', group: 'guess' }, noTurnColor: { elementType: 'color', elementId: '_jaTbNoTurnColor', defaultValue: '#a0a0a0', group: 'guess' }, problemColor: { elementType: 'color', elementId: '_jaTbProblemColor', defaultValue: '#feed40', group: 'guess' }, roundaboutOverlayDisplay: { elementType: 'select', elementId: '_jaSelRoundaboutOverlayDisplay', defaultValue: 'rOverNever', options: ['rOverNever', 'rOverSelected', 'rOverAlways'] }, roundaboutOverlayColor: { elementType: 'color', elementId: '_jaTbRoundaboutOverlayColor', defaultValue: '#aa0000', group: 'roundaboutOverlayDisplay' }, roundaboutColor: { elementType: 'color', elementId: '_jaTbRoundaboutColor', defaultValue: '#ff8000', group: 'roundaboutOverlayDisplay' }, uTurnIncludeStreet: { elementType: 'checkbox', elementId: '_jaCbUTurnIncludeStreet', defaultValue: false }, uTurnIncludeParkingLot: { elementType: 'checkbox', elementId: '_jaCbUTurnIncludeParkingLot', defaultValue: false }, uTurnIncludePrivateRoad: { elementType: 'checkbox', elementId: '_jaCbUTurnIncludePrivateRoad', defaultValue: false }, wazeDoubleUTurnRestriction: { elementType: 'checkbox', elementId: '_jaCbWazeDoubleUTurnRestriction', defaultValue: true }, enableFarTurnJB: { elementType: 'checkbox', elementId: '_jaCbEnableFarTurnJB', defaultValue: false, group: 'experimental' }, enableFarTurnPath: { elementType: 'checkbox', elementId: '_jaCbEnableFarTurnPath', defaultValue: false, group: 'experimental' }, decimals: { elementType: 'number', elementId: '_jaTbDecimals', defaultValue: 2, min: 0, max: 2 }, pointSize: { elementType: 'number', elementId: '_jaTbPointSize', defaultValue: 12, min: 6, max: 20 }, // PHASE 4: Continuous Scanning Settings continuousScanning: { elementType: 'checkbox', elementId: '_jaCbContinuousScanning', defaultValue: false, group: 'experimental' }, }; // ── Direction arrow character sets ──────────────────────────────────────── // Provides named accessors for the currently selected arrow character set. // The actual character set string is stored in ja_options.angleDisplayArrows. var ja_arrow = { get: function (at) { var arrows = ja_getOption('angleDisplayArrows'); return arrows[at % arrows.length]; }, left: function () { return this.get(0); }, right: function () { return this.get(1); }, left_up: function () { return this.get(2); }, right_up: function () { return this.get(3); }, up: function () { return this.get(4); }, }; /** * Returns the current WME editor selection as a flat array of feature descriptors. * * Wraps sdk.Editing.getSelection() and maps each selected item to a plain object * with { id, type } so callers do not need to interact with the SDK selection model * directly. Filters to only segments and nodes (the only types JAI supports). * Returns an empty array when nothing is selected or only unsupported types are selected. * * @returns {Array<{id: number, type: string}>} Selected segments/nodes, or [] if none. */ function getselfeat() { var sel = sdk.Editing.getSelection(); if (!sel) { return []; } // Only return segment and node selections — ignore all other types (bigJunction, venue, etc.) var SUPPORTED_TYPES = { 'segment': true, 'node': true }; if (!SUPPORTED_TYPES[sel.objectType]) { return []; } return sel.ids.map(function (id) { return { type: sel.objectType, id: id }; }); } /** * Returns true if anything is currently selected in the editor. * * @returns {boolean} True if the selection is non-empty. */ function hasSelection() { return getselfeat().length > 0; } /** * Returns true if the given segment ID is currently selected in the editor. * * Uses getselfeat() to read the live selection state. Called during angle * calculation to distinguish the incoming (selected) segment from other segments * at a node so the correct departure angle can be identified. * * @param {number} segmentId - The segment ID to test. * @returns {boolean} True if the segment is part of the current selection. */ function ja_is_segment_selected(segmentId) { var sel = sdk.Editing.getSelection(); return sel != null && sel.objectType === 'segment' && sel.ids.indexOf(segmentId) !== -1; } /** * Computes the base marker offset distance in meters for the current zoom level. * * The distance is looked up from a hard-coded table keyed by WME zoom level * (13–22), then scaled by the configured decimal-places setting so that wider * labels receive more spacing. Returns undefined at unsupported zoom levels and * logs a warning. * * @returns {number} Base label distance in meters. */ function ja_compute_label_distance() { var ja_label_distance; switch (sdk.Map.getZoomLevel()) { case 22: ja_label_distance = 1.2; break; case 21: ja_label_distance = 2.2; break; case 20: ja_label_distance = 4.5; break; case 19: ja_label_distance = 8; break; case 18: ja_label_distance = 16; break; case 17: ja_label_distance = 32; break; case 16: ja_label_distance = 45; break; case 15: ja_label_distance = 50; break; case 14: ja_label_distance = 100; break; case 13: ja_label_distance = 300; break; default: ja_log('Unsupported zoom level: ' + sdk.Map.getZoomLevel() + '!', 1); } ja_label_distance *= 1 + 0.2 * parseInt(ja_getOption('decimals')); ja_log('zoom: ' + sdk.Map.getZoomLevel() + ' -> distance: ' + ja_label_distance, 3); return ja_label_distance; } /** * Scans the given node list for roundabout (junction) membership and builds an * entry/exit map. * * For each node, inspects connected segments for a non-null junctionId. When a * junction is found, records the non-junction segment and node as the entry side * (in_s / in_n). If the same junctionId is encountered a second time (second * selected node on the same RA), the second node is recorded as the exit side * (out_s / out_n). Also stores the junction geometry center point (p). * * @param {number[]} ja_nodes - Array of node IDs from the current selection. * @returns {Object} Map of junctionId → { in_s, in_n, out_s, out_n, p }. */ function ja_find_roundabouts(ja_nodes) { var ja_selected_roundabouts = {}; ja_nodes.forEach(function (node) { var nodeObj = sdk.DataModel.Nodes.getById({ nodeId: node }); ja_log(nodeObj, 3); var tmp_s = null, tmp_n = null, tmp_junctionID = null; if (nodeObj == null || typeof nodeObj.connectedSegmentIds === 'undefined') { return; } nodeObj.connectedSegmentIds.forEach(function (segment) { ja_log(segment, 3); var segObj = sdk.DataModel.Segments.getById({ segmentId: segment }); if (segObj != null && segObj.junctionId != null) { ja_log('Roundabout detected: ' + segObj.junctionId, 3); tmp_junctionID = segObj.junctionId; } else { tmp_s = segment; tmp_n = node; } ja_log('tmp_s: ' + (tmp_s === null ? 'null' : tmp_s), 3); }); ja_log('final tmp_s: ' + (tmp_s === null ? 'null' : tmp_s), 3); if (tmp_junctionID === null) { return; } if (ja_selected_roundabouts.hasOwnProperty(tmp_junctionID)) { ja_selected_roundabouts[tmp_junctionID].out_s = tmp_s; ja_selected_roundabouts[tmp_junctionID].out_n = node; } else { var tmp_junction = sdk.DataModel.Junctions.getById({ junctionId: tmp_junctionID }); ja_selected_roundabouts[tmp_junctionID] = { in_s: tmp_s, in_n: tmp_n, out_s: null, out_n: null, p: tmp_junction ? tmp_junction.geometry : undefined, }; } }); return ja_selected_roundabouts; } /** * Draws center-angle and ±N° deviation markers for all detected roundabouts. * * For each roundabout in the selection map: draws an optional circle overlay * (rOverSelected mode), renders the triangle legs (in_n → center → out_n) as a * LineString feature, calls ja_is_roundabout_normal() for its side effect of * placing ±N° deviation markers at oblique exits, then places the center-angle * marker colored per the specific entry→exit path angle (white = within ±PERPENDICULAR_TOLERANCE° of * perpendicular; orange = non-normal). * * @param {Object} ja_selected_roundabouts - Map from ja_find_roundabouts(). * @param {number} ja_label_distance - Base marker offset distance in meters. */ function ja_draw_roundabout_markers(ja_selected_roundabouts, ja_label_distance) { //Do some fancy painting for the roundabouts... for (var tmp_roundabout in ja_selected_roundabouts) { if (ja_selected_roundabouts.hasOwnProperty(tmp_roundabout)) { // for...in always yields string keys; SDK requires a number type var tmp_roundabout_id = parseInt(tmp_roundabout, 10); ja_log(tmp_roundabout_id, 3); ja_log(ja_selected_roundabouts[tmp_roundabout], 3); //New roundabouts don't have coordinates yet.. if (typeof ja_selected_roundabouts[tmp_roundabout].p === 'undefined') { continue; } // Entry-only selection (no exit node in selection): show all exits relative to entry if (ja_selected_roundabouts[tmp_roundabout].out_n === null) { ja_draw_roundabout_entry_exits(tmp_roundabout_id, ja_selected_roundabouts[tmp_roundabout].in_n, ja_label_distance); continue; } // Roundabout arc selected: use the segment's entry node based on direction of travel. // Show all exits from that entry — same view as selecting an entry segment connected at that node. var _selfeat = getselfeat(); if (_selfeat.length === 1 && _selfeat[0].type === 'segment') { var _selSeg = sdk.DataModel.Segments.getById({ segmentId: _selfeat[0].id }); if (_selSeg && _selSeg.junctionId !== null) { // Determine entry node based on direction of travel (not geometric direction) // isAtoB means traffic flows from fromNodeId to toNodeId; isBtoA means toNodeId to fromNodeId var entryNodeForRA = _selSeg.isAtoB ? _selSeg.fromNodeId : _selSeg.toNodeId; ja_log('[RA] Selected RA arc: isAtoB=' + _selSeg.isAtoB + ', isBtoA=' + _selSeg.isBtoA + ', entry node=' + entryNodeForRA, 2); ja_draw_roundabout_entry_exits(tmp_roundabout_id, entryNodeForRA, ja_label_distance); continue; } } //Draw circle overlay for this roundabout if (ja_getOption('roundaboutOverlayDisplay') === 'rOverSelected') { ja_draw_roundabout_overlay(tmp_roundabout_id); } //Transform LonLat to actual layer projection var tmp_roundabout_center = ja_coordinates_to_point(ja_selected_roundabouts[tmp_roundabout].p.coordinates); var tmp_in_geom = sdk.DataModel.Nodes.getById({ nodeId: ja_selected_roundabouts[tmp_roundabout].in_n }).geometry; var tmp_out_geom = sdk.DataModel.Nodes.getById({ nodeId: ja_selected_roundabouts[tmp_roundabout].out_n }).geometry; var angle = ja_angle_between_points(tmp_in_geom, tmp_roundabout_center, tmp_out_geom); //Draw the two legs of the triangle (in_n → center → out_n) ja_add_feature({ type: 'LineString', coordinates: [tmp_in_geom.coordinates, tmp_roundabout_center.coordinates, tmp_out_geom.coordinates] }, { ja_type: 'arrow_line' }); // Call ja_is_roundabout_normal for its side effect: places ±N° deviation markers // at any exit node that is more than 15° off perpendicular. ja_is_roundabout_normal(tmp_roundabout_id, ja_selected_roundabouts[tmp_roundabout].in_n, ja_label_distance); // Color the center marker based on THIS specific path's angle only. // Per Waze: a roundabout can be normal for one entry and non-normal for another. var ra_path_is_normal = ja_is_angle_normal(angle); ja_add_feature(tmp_roundabout_center, { angle: ja_round(angle) + '°', ja_type: ra_path_is_normal ? ja_routing_type.BC : ja_routing_type.ROUNDABOUT, }); } } } /** * Identifies short connector segments (≤30m, or ≤50m with lane guidance) that create * double-turn or U-turn paths and returns an accumulator object for use during marker drawing. * * A double-turn occurs when a driver enters a short connector segment from one * road and exits onto another road such that the combined heading change is near * 180°. Waze may misclassify such paths; this function flags them as NO_U_TURN * or PROBLEM so ja_draw_node_markers can render warning markers. * * Optional stricter Waze restriction: when the "Disable for <15m and ±5° parallel" * setting is enabled, paths with median ≤15m and parallel arms are blocked. * * Only active in Departure angle mode when more than one node is selected. * * @param {number[]} ja_nodes - Array of selected node IDs. * @returns {{data: Object, collect: Function, forEachItem: Function}} Accumulator. */ function ja_collect_double_turns(ja_nodes, allBigJunctions) { /** * Collect double-turn (inc. U-turn) segments info */ var doubleTurns = { data: {}, //Structure: map<s_id, map<s_out_id, list<{s_in_id, angle, turn_type}>>> farExitMarkers: [], //Markers to draw at the median's far exit node when an arm is selected collect: function (s_id, s_in_id, s_out_id, angle, turn_type) { ja_log('Collecting double-turn path from ' + s_in_id + ' to ' + s_out_id + ' via ' + s_id + ' with angle ' + angle + ' type: ' + turn_type, 2); var info = this.data[s_id]; if (info === undefined) { info = this.data[s_id] = {}; } var list = info[s_out_id]; if (list === undefined) { list = info[s_out_id] = []; } list.push({ s_in_id: s_in_id, angle: angle, turn_type: turn_type }); }, forEachItem: function (s_id, s_out_id, fn) { var info = this.data[s_id]; if (info !== undefined) { var list = info[s_out_id]; if (list !== undefined) { list.forEach(function (item, i) { fn(item, i); }); } } }, }; //Loop through segments <=30 m (always qualifies) or 31-49 m with lane guidance on the incoming segment if (ja_getOption('angleMode') === 'aDeparture' && ja_nodes.length > 1) { getselfeat().forEach(function (selectedSegment) { var segmentId = selectedSegment.id; var segment = sdk.DataModel.Segments.getById({ segmentId: segmentId }); ja_log('Checking ' + segmentId + ' for double turns ...', 3); var len = ja_segment_length(segment); ja_log('Segment ' + segmentId + ' length: ' + len, 3); if (!ja_is_uturn_qualifying_road(segment)) return; // SUPPRESS LOCAL DOUBLE U-TURNS FOR ENTRY SEGMENTS CROSSING INTO JB // When a segment crosses INTO a JB (one endpoint outside, one inside), // JB far-turn logic (with U-TURN instructions) takes over. Local double-turn // markers would duplicate the JB U-TURN marker. var bjCrossing = ja_segment_crosses_bj_boundary(segment, allBigJunctions); if (bjCrossing.crosses) { ja_log('Skip double turns: ' + segmentId + ' crosses JB boundary', 3); return; // Skip double-turn collection for this entry-to-JB segment } var fromNode = sdk.DataModel.Nodes.getById({ nodeId: segment.fromNodeId }); var toNode = sdk.DataModel.Nodes.getById({ nodeId: segment.toNodeId }); var lenRounded = Math.round(len); if (lenRounded <= 49) { var a_from = ja_getAngleMidleSeg(segment.fromNodeId, segment); var a_to = ja_getAngleMidleSeg(segment.toNodeId, segment); fromNode.connectedSegmentIds.forEach(function (fromSegmentId) { if (fromSegmentId === segmentId) return; var fromSegment = sdk.DataModel.Segments.getById({ segmentId: fromSegmentId }); if (!ja_is_uturn_qualifying_road(fromSegment)) return; var from_a = ja_getAngle(segment.fromNodeId, fromSegment); var from_angle = ja_angle_diff(from_a, a_from, false); ja_log('Segment from ' + fromSegmentId + ' angle: ' + from_a + ', turn angle: ' + from_angle, 3); toNode.connectedSegmentIds.forEach(function (toSegmentId) { if (toSegmentId === segmentId) return; var toSegment = sdk.DataModel.Segments.getById({ segmentId: toSegmentId }); if (!ja_is_uturn_qualifying_road(toSegment)) return; var to_a = ja_getAngle(segment.toNodeId, toSegment); var to_angle = ja_angle_diff(to_a, a_to, false); ja_log('Segment to ' + toSegmentId + ' angle: ' + to_a + ', turn angle: ' + to_angle, 3); var angle = Math.abs(to_angle - from_angle); ja_log('Angle from ' + fromSegmentId + ' to ' + toSegmentId + ' is: ' + angle, 3); // Path 1: fromSegment → segment → toSegment (A → B → C) var hasLGFromToMedian = ja_segment_has_lane_guidance(fromSegmentId, fromNode.id, segmentId); var turn_type_path1 = ja_classify_uturn_angle(angle, lenRounded, fromSegment, toSegment, fromNode.id, toNode.id, hasLGFromToMedian); if (turn_type_path1 !== null) { var useWazeRestriction = turn_type_path1 === ja_routing_type.NO_U_TURN; // Collect if turns are allowed (same logic for both paths) if (ja_is_turn_allowed(fromSegment, fromNode, segment) && ja_is_turn_allowed(segment, toNode, toSegment)) { // When Waze restriction applies, always collect; otherwise check length/lane guidance if (useWazeRestriction || lenRounded <= 30 || hasLGFromToMedian) { doubleTurns.collect(segmentId, fromSegmentId, toSegmentId, angle, turn_type_path1); } } } // Path 2: toSegment → segment → fromSegment (C → B → A) var hasLGToToMedian = ja_segment_has_lane_guidance(toSegmentId, toNode.id, segmentId); var turn_type_path2 = ja_classify_uturn_angle(angle, lenRounded, toSegment, fromSegment, toNode.id, fromNode.id, hasLGToToMedian); if (turn_type_path2 !== null) { useWazeRestriction = turn_type_path2 === ja_routing_type.NO_U_TURN; if (ja_is_turn_allowed(toSegment, toNode, segment) && ja_is_turn_allowed(segment, fromNode, fromSegment)) { // When Waze restriction applies, always collect; otherwise check length/lane guidance if (useWazeRestriction || lenRounded <= 30 || hasLGToToMedian) { doubleTurns.collect(segmentId, toSegmentId, fromSegmentId, angle, turn_type_path2); } } } }); }); } }); // Second pass: trigger double-turn detection when an entry/exit arm is selected. // For each selected segment, look at its endpoint nodes for qualifying median neighbors. // Skips any neighbor that is itself a selected segment (already handled by first loop). var selectedIds = {}; getselfeat().forEach(function (s) { selectedIds[s.id] = true; }); getselfeat().forEach(function (selectedSegment) { var armId = selectedSegment.id; var armSeg = sdk.DataModel.Segments.getById({ segmentId: armId }); if (!ja_is_uturn_qualifying_road(armSeg)) return; // SUPPRESS LOCAL DOUBLE U-TURNS FOR ARM SEGMENTS CROSSING INTO JB var armBjCrossing = ja_segment_crosses_bj_boundary(armSeg, allBigJunctions); if (armBjCrossing.crosses) { ja_log('Skip arm double turns: ' + armId + ' crosses JB boundary', 3); return; } [armSeg.fromNodeId, armSeg.toNodeId].forEach(function (armNodeId) { var armNode = sdk.DataModel.Nodes.getById({ nodeId: armNodeId }); armNode.connectedSegmentIds.forEach(function (neighborId) { if (neighborId === armId) return; if (selectedIds[neighborId]) return; // already handled as direct median selection var neighbor = sdk.DataModel.Segments.getById({ segmentId: neighborId }); if (!ja_is_uturn_qualifying_road(neighbor)) return; var nLen = Math.round(ja_segment_length(neighbor)); if (nLen > 49) return; if (nLen > 30 && !ja_segment_has_lane_guidance(armId, armNodeId, neighborId)) return; if (!ja_is_turn_allowed(armSeg, armNode, neighbor)) return; var a_arm_side = ja_getAngleMidleSeg(armNodeId, neighbor); var medianFarNodeId = neighbor.fromNodeId === armNodeId ? neighbor.toNodeId : neighbor.fromNodeId; var a_exit_side = ja_getAngleMidleSeg(medianFarNodeId, neighbor); var medianFarNode = sdk.DataModel.Nodes.getById({ nodeId: medianFarNodeId }); var arm_a = ja_getAngle(armNodeId, armSeg); var arm_angle = ja_angle_diff(arm_a, a_arm_side, false); medianFarNode.connectedSegmentIds.forEach(function (exitId) { if (exitId === neighborId) return; var exitSeg = sdk.DataModel.Segments.getById({ segmentId: exitId }); if (!ja_is_uturn_qualifying_road(exitSeg)) return; if (!ja_is_turn_allowed(neighbor, medianFarNode, exitSeg)) return; var exit_a = ja_getAngle(medianFarNodeId, exitSeg); var exit_angle = ja_angle_diff(exit_a, a_exit_side, false); var combined_angle = Math.abs(exit_angle - arm_angle); ja_log('Entry-arm trigger: ' + armId + ' -> ' + neighborId + ' -> ' + exitId + ' angle: ' + combined_angle, 3); var turn_type = ja_classify_uturn_angle(combined_angle, nLen, armSeg, exitSeg, armNodeId, medianFarNodeId); if (turn_type !== null) { doubleTurns.farExitMarkers.push({ farNodeId: medianFarNodeId, exitBearing: exit_a, angle: combined_angle, turn_type: turn_type, }); } }); }); }); }); } ja_log('Double-turns collected: ' + doubleTurns.data.length + ' total', 3); ja_log(doubleTurns.data, 4); return doubleTurns; } /** * Iterates selected nodes and draws angle markers for all connected segment pairs. * * For each node: computes the bearing of every connected segment, determines * which segments are selected (incoming), then applies either Departure mode * (one marker per exit, placed along that exit's bearing) or Absolute mode (one * marker per adjacent pair, placed in the gap between them). Calls * ja_guess_routing_instruction() to classify each turn and ja_draw_marker() to * place the feature. Also draws double-turn markers for short connector paths. * * @param {number[]} ja_nodes - Array of node IDs to process. * @param {number} ja_label_distance - Base marker offset distance in meters. * @param {{data: Object, collect: Function, forEachItem: Function}} doubleTurns - From ja_collect_double_turns(). * @param {boolean} ja_selected_has_median - True if any selected segment is contained inside a * BigJunction. When true, far-turn markers are suppressed: the regular node-pair logic handles * internal JB segments, and showing far-turn exit markers would be misleading/incorrect. * @param {number[]} ja_selected_seg_ids - IDs of the user-selected segments. Passed through to * ja_draw_far_turn_markers so it only draws far turns from the selected entry segment(s). * Empty when a node (not a segment) is selected — in that case all entries are shown. * @param {boolean} ja_is_pure_node_selection - True if a node is directly selected (not via segment). * When true, far-turn (Path/JB) markers are suppressed — show only the node's absolute angles. * @returns {boolean} True if a data error occurred and the calculation must be retried. */ function ja_draw_node_markers(ja_nodes, ja_label_distance, doubleTurns, ja_selected_has_median, ja_selected_seg_ids, allBigJunctions, ja_is_pure_node_selection) { var restart = false; //Start looping through selected nodes for (var i = 0; i < ja_nodes.length; i++) { var node = sdk.DataModel.Nodes.getById({ nodeId: ja_nodes[i] }); var angles = []; var ja_selected_segments_count = 0; var ja_selected_angles = []; var a; if (node == null) { //Oh oh.. should not happen? We want to use a node that does not exist ja_log('[draw_node_markers] Null node at index ' + i + ' — should not happen', 1); continue; } //check connected segments var ja_current_node_segments = node.connectedSegmentIds; // EPSG:3857 projected units = cos(lat) × true meters; correct so turf distances match OL originals var ja_ld = ja_corrected_ld(ja_label_distance, node.geometry.coordinates); ja_log(node, 4); //ignore of we have less than 2 segments if (ja_current_node_segments.length <= 1) { ja_log('Found only ' + ja_current_node_segments.length + ' connected segments at ' + ja_nodes[i] + ', not calculating anything...', 3); continue; } ja_log('Calculating angles for ' + ja_current_node_segments.length + ' segments', 3); ja_log(ja_current_node_segments, 4); ja_current_node_segments.forEach(function (nodeSegment, j) { var s = sdk.DataModel.Segments.getById({ segmentId: nodeSegment }); if (typeof s === 'undefined') { //Meh. Something went wrong, and we lost track of the segment. This needs a proper fix, but for now // it should be sufficient to just restart the calculation ja_log('Failed to read segment data from model. Restarting calculations.', 1); if (ja_last_restart === 0) { ja_last_restart = new Date().getTime(); setTimeout(function () { ja_calculate(); }, 500); } restart = true; } a = ja_getAngle(ja_nodes[i], s); ja_log('Segment ' + nodeSegment + ' angle: ' + a, 4); angles[j] = [a, nodeSegment, s == null ? false : ja_is_segment_selected(nodeSegment)]; if (s == null ? false : ja_is_segment_selected(nodeSegment)) { ja_selected_segments_count++; } }); if (restart) { return true; } //make sure we have the selected angles in correct order ja_log(ja_current_node_segments, 4); getselfeat().forEach(function (selectedSegment) { var selectedSegmentId = selectedSegment.id; if (ja_current_node_segments.indexOf(selectedSegmentId) >= 0) { //find the angle for (var j = 0; j < angles.length; j++) { if (angles[j][1] === selectedSegmentId) { ja_selected_angles.push(angles[j]); break; } } ja_log('Selected segment ' + selectedSegmentId + ' found', 4); } }); ja_log(angles, 4); var ha, point; //if we have two connected segments selected, do some magic to get the turn angle only =) if (ja_selected_segments_count === 2) { a = ja_angle_diff(ja_selected_angles[0][0], ja_selected_angles[1][0], false); ha = (parseFloat(ja_selected_angles[0][0]) + parseFloat(ja_selected_angles[1][0])) / 2; if ( Math.abs(ja_selected_angles[0][0]) + Math.abs(ja_selected_angles[1][0]) > 180 && ((ja_selected_angles[0][0] < 0 && ja_selected_angles[1][0] > 0) || (ja_selected_angles[0][0] > 0 && ja_selected_angles[1][0] < 0)) ) { ha += 180; } var ja_extra_space_multiplier = ja_compute_extra_space(a, ha); ja_log('Angle: ' + a + '° at ' + ha + '°', 4); //Guess some routing instructions based on segment types, angles etc var ja_junction_type = ja_routing_type.TURN; //Default to old behavior if (ja_getOption('guess')) { ja_log(ja_selected_angles, 4); ja_log(angles, 4); var s_in_seg = ja_selected_angles[0][1]; var s_out_seg = ja_selected_angles[1][1]; ja_junction_type = ja_guess_routing_instruction(node, s_in_seg, s_out_seg, angles); ja_log('Guess result: ' + s_in_seg + ' → ' + s_out_seg + ' = ' + ja_junction_type, 2); } //get the initial marker point point = turf.destination(turf.point(node.geometry.coordinates), (ja_extra_space_multiplier * ja_ld) / 1000, ja_math_to_compass(ha)).geometry; ja_draw_marker(point, node, ja_ld, a, ha, true, ja_junction_type); // Record this local marker for far-turn conflict detection // (Far-turn markers drawn later will check this data and adjust their distance if needed) if (!ja_local_markers_by_node[node.id]) { ja_local_markers_by_node[node.id] = []; } ja_local_markers_by_node[node.id].push({ bearing: ha, distance: ja_extra_space_multiplier * ja_ld }); //draw double turn markers // If there are double-turn markers at this node+bearing, offset them farther out var doubleTurnMultiplier = ja_extra_space_multiplier; doubleTurns.forEachItem(ja_selected_angles[0][1], ja_selected_angles[1][1], function (item) { if (doubleTurnMultiplier === ja_extra_space_multiplier) { // First double-turn found: use larger distance to separate from local marker doubleTurnMultiplier = ja_extra_space_multiplier * 1.4; ja_log('[DOUBLE-TURN] Offset double-turn markers at node ' + node.id + ' by 1.4x', 2); } var doubleTurnPoint = turf.destination(turf.point(node.geometry.coordinates), (doubleTurnMultiplier * ja_ld) / 1000, ja_math_to_compass(ha)).geometry; ja_draw_marker(doubleTurnPoint, node, ja_ld, item.angle, ha, true, item.turn_type); }); } else { //sort angle data (ascending) angles.sort(function (a, b) { return a[0] - b[0]; }); ja_log(angles, 4); ja_log(ja_selected_segments_count, 4); //get all segment angles angles.forEach(function (angle, j) { a = (360 + (angles[(j + 1) % angles.length][0] - angle[0])) % 360; ha = (360 + (a / 2 + angle[0])) % 360; var a_in = angles.filter(function (a) { return !!a[2]; })[0]; //Show only one angle for nodes with only 2 connected segments and a single selected segment // (not on both sides). Skipping the one > 180 if (ja_selected_segments_count === 1 && angles.length === 2 && a >= 180 && ja_getOption('angleMode') !== 'aDeparture') { ja_log('Skipping marker, as we need only one of them', 3); return; } if (ja_getOption('angleMode') === 'aDeparture' && ja_selected_segments_count > 0) { if (a_in[1] === angle[1]) { ja_log('in == out. skipping.', 3); return; } ja_log('Angle in:', 3); ja_log(a_in, 4); var depMarkerType = ja_getOption('guess') ? ja_guess_routing_instruction(node, a_in[1], angle[1], angles) : ja_routing_type.TURN; ja_log('Guess result: ' + a_in[1] + ' → ' + angle[1] + ' = ' + depMarkerType, 3); //FIXME: we might want to try to keep the marker on the segment, instead of just //in the direction of the first part ha = angle[0]; a = ja_angle_diff(a_in[0], angles[j][0], false); point = turf.destination(turf.point(node.geometry.coordinates), (ja_ld * 2) / 1000, ja_math_to_compass(ha)).geometry; // CHECK FOR ENTRY SEGMENT CROSSING INTO JB // If entry is outside JB and exit crosses out of JB boundary, move marker to boundary var markerAnchor = node; var isSquareMarker = false; var entryIsInJB = sdk.DataModel.Segments.isContainedInBigJunction({ segmentId: a_in[1] }); // Only check for boundary crossing if entry is outside JB if (!entryIsInJB) { var exitSegment = sdk.DataModel.Segments.getById({ segmentId: angle[1] }); if (exitSegment) { // Search for JB that the exit segment crosses OUT of for (var bji = 0; bji < allBigJunctions.length; bji++) { var bjPolygon = turf.polygon(allBigJunctions[bji].geometry.coordinates); // Check if current node is inside this JB var nodeIsInside = turf.booleanPointInPolygon(turf.point(node.geometry.coordinates), bjPolygon); if (nodeIsInside) { // Get the far endpoint of exit segment (node that's NOT the current node) var exitCoords = exitSegment.geometry.coordinates; var farEndpoint = Math.abs(exitCoords[0][0] - node.geometry.coordinates[0]) < 0.0001 && Math.abs(exitCoords[0][1] - node.geometry.coordinates[1]) < 0.0001 ? exitCoords[1] : exitCoords[0]; var farIsInside = turf.booleanPointInPolygon(turf.point(farEndpoint), bjPolygon); // If node is inside and far endpoint is outside, this exit crosses out of JB if (!farIsInside) { var closestPt = ja_find_closest_bj_intersection(exitSegment, bjPolygon, node); if (closestPt !== null) { markerAnchor = { geometry: closestPt.geometry }; isSquareMarker = true; // Recalculate point from boundary anchor // Use larger distance (3.5x) to avoid overlapping with WME's turn restriction arrows at the boundary var boundaryLd = ja_corrected_ld(ja_label_distance, markerAnchor.geometry.coordinates); point = turf.destination(turf.point(markerAnchor.geometry.coordinates), (boundaryLd * 3.5) / 1000, ja_math_to_compass(ha)).geometry; ja_log('[JAI] Marker moved to JB boundary (3.5x distance)', 3); break; } } } } } } ja_draw_marker( point, markerAnchor, ja_ld, a, ha, true, depMarkerType, false, isSquareMarker, ); // Record this local marker for far-turn conflict detection // (Far-turn markers drawn later will check this data and adjust their distance if needed) if (!ja_local_markers_by_node[node.id]) { ja_local_markers_by_node[node.id] = []; } ja_local_markers_by_node[node.id].push({ bearing: ha, distance: 2 * ja_ld }); //draw double turn markers // If there are double-turn markers at this node+bearing, offset them farther out // Use larger offset if at JB boundary to avoid WME turn restriction arrows var doubleTurnDepartureMult = isSquareMarker ? 4.2 : 2.7; doubleTurns.forEachItem(a_in[1], angle[1], function (item) { if ((isSquareMarker && doubleTurnDepartureMult === 4.2) || (!isSquareMarker && doubleTurnDepartureMult === 2.7)) { // First double-turn found at this anchor (boundary or node) doubleTurnDepartureMult = isSquareMarker ? 4.9 : 3.3; var boundarySuffix = isSquareMarker ? ' (at JB boundary)' : ''; ja_log('[DOUBLE-TURN] Offset double-turn markers at node ' + node.id + ' by ' + doubleTurnDepartureMult.toFixed(1) + 'x (departure mode)' + boundarySuffix, 2); } var doubleTurnDeparturePoint = turf.destination(turf.point(markerAnchor.geometry.coordinates), (doubleTurnDepartureMult * ja_ld) / 1000, ja_math_to_compass(ha)).geometry; ja_draw_marker(doubleTurnDeparturePoint, markerAnchor, ja_ld, item.angle, ha, true, item.turn_type, false, isSquareMarker); }); } else { ja_log('Angle between ' + angle[1] + ' and ' + angles[(j + 1) % angles.length][1] + ' is ' + a + ' and position for label should be at ' + ha, 3); point = turf.destination(turf.point(node.geometry.coordinates), (ja_ld * 1.25) / 1000, ja_math_to_compass(ha)).geometry; ja_draw_marker(point, node, ja_ld, a, ha); // Record this local marker for far-turn conflict detection // (Far-turn markers drawn later will check this data and adjust their distance if needed) if (!ja_local_markers_by_node[node.id]) { ja_local_markers_by_node[node.id] = []; } ja_local_markers_by_node[node.id].push({ bearing: ha, distance: 1.25 * ja_ld }); } }); } // ── Far turn markers (experimental) ───────────────────────────────── // Draw angle markers for all far turns (Path turns and Junction Box turns) // that originate from THIS node. Placed inside the per-node loop so it runs // once per node with the correct `node` and `ja_ld` values in scope. // // These are turns whose entry and exit segments are NOT directly adjacent — // they cross intermediate segments via segmentPath[]. // // Placed after the regular segment-pair markers so far turn markers render // on top without interfering with the standard angle annotations. // // DEPARTURE MODE ONLY: Far turns (Paths and JB turns) only make sense in // Departure mode where you select an entry segment and see where it goes. // In Absolute mode, we only show geometric gaps between adjacent pairs, // independent of direction of travel, so far turns should not appear. // // Far-turn display is controlled by experimental settings: // - "Enable JAI for Junction Boxes" (enableFarTurnJB) // - "Enable JAI for Paths" (enableFarTurnPath) // Both are disabled by default. Actual filtering happens inside ja_draw_far_turn_markers(). // // Suppressed when any selected segment is a JB median: internal segments are handled // by the regular node-pair loop above; far-turn exit markers would be misleading. // Also suppressed when a pure node is selected: show only absolute angles at that node. if (ja_getOption('angleMode') === 'aDeparture' && !ja_selected_has_median && !ja_is_pure_node_selection) { ja_draw_far_turn_markers(node, ja_label_distance, ja_selected_seg_ids, allBigJunctions); } // ── CACHE WRITE-BACK: Push fresh angles to continuous cache ──────────── // On-demand recalculation has finished for this node. Compute full angle set // with routing types and write to ja_continuous_cache so that when you deselect, // the continuous scanner renders current data (not stale pre-edit data). // // This completes the cache architecture: both on-demand and continuous modes // share the same cache, and on-demand writes back fresh results on every // recalculation (whether for selection changes or turn edits). // // Note: On-demand rendering calculates routing types only for selected pairs, // but continuous rendering needs ALL pairs. So we call ja_calculate_angles_for_node() // to generate the full set with complete routing type information. if (ja_continuous_mode && ja_is_valid_routing_node(node)) { var fullAngles = ja_calculate_angles_for_node(node); ja_write_to_cache(node.id, fullAngles); } } // Draw far-exit double-turn markers triggered by arm selection. // Placed at the median's far node along the exit arm's bearing — matching the // visual position produced when the median itself is selected directly. doubleTurns.farExitMarkers.forEach(function (item) { var farNode = sdk.DataModel.Nodes.getById({ nodeId: item.farNodeId }); if (!farNode) return; var farLd = ja_corrected_ld(ja_label_distance, farNode.geometry.coordinates); // CHECK FOR LOCAL TURN MARKER CONFLICT AT FAR NODE // If a local turn at this far node targets the same direction, move this far-exit marker out farther var hasFarNodeConflict = ja_local_markers_by_node[item.farNodeId] && ja_local_markers_by_node[item.farNodeId].some(function(ltMarker) { return ja_markers_target_same_direction(item.exitBearing, ltMarker.bearing, 30); }); var farExitDist = hasFarNodeConflict ? 3.2 : 2.0; if (hasFarNodeConflict) { ja_log('[MARKER-OVERLAP] Far-exit conflict at node ' + item.farNodeId + ': 3.2x distance', 3); } var pt = turf.destination(turf.point(farNode.geometry.coordinates), (farExitDist * farLd) / 1000, ja_math_to_compass(item.exitBearing)).geometry; ja_draw_marker(pt, farNode, farLd, item.angle, item.exitBearing, true, item.turn_type); }); return false; } // ─── CACHE HELPERS: Reduce duplication in cache operations ──────────────── /** * Store angle data in ja_continuous_cache for both on-demand and continuous modes. * Single source of truth for cache writes; prevents duplication and ensures consistency. * @param {number} nodeId - Node ID to cache * @param {Array} angles - Angle objects array with routing type info */ function ja_write_to_cache(nodeId, angles) { ja_continuous_cache[nodeId] = { timestamp: Date.now(), angles: angles }; ja_log('Cache write: node ' + nodeId + ' (' + angles.length + ' angles)', 4); } /** * Check if cache entry is fresh (within 2-minute TTL). * @param {Object} cached - Cache entry (should have timestamp field) * @returns {boolean} true if entry exists and is < 2min old, false otherwise */ function ja_is_cache_fresh(cached) { if (!cached) return false; return (Date.now() - cached.timestamp) < 2 * 60 * 1000; // 2-min TTL } /** * Filter angle array to PROBLEM type only. * @param {Array} angles - Array of angle objects with type field * @returns {Array} Subset containing only PROBLEM angles */ function ja_filter_problem_angles(angles) { return angles.filter(a => a.type === ja_routing_type.PROBLEM); } /** * Check if node has enough segments for routing analysis (3+ segments). * @param {Object} node - Node object with connectedSegmentIds array * @returns {boolean} true if node has 3+ segments, false otherwise */ function ja_is_valid_routing_node(node) { return node && node.connectedSegmentIds && node.connectedSegmentIds.length >= 3; } // ─── PHASE 2: CONTINUOUS SCANNING - Batch Processing ───────────────────── /** * Process cache-miss nodes in batches to add new markers incrementally. * Only processes nodes in ja_continuous_needs_batching list (pre-filtered by ja_start_continuous_scan). * Calculates angles, caches them, and renders immediately (adds to existing layer, no clearing). * Schedules next batch via setTimeout (50ms delay = non-blocking). */ function ja_scan_nodes_batch_from_list(batchSize) { if (!ja_continuous_mode) return; if (ja_continuous_needs_batching.length === 0) return; var batchStartTime = Date.now(); // Calculate batch end index from the miss list var endIndex = Math.min(ja_continuous_batch_index + batchSize, ja_continuous_needs_batching.length); ja_log('Processing cache misses: batch ' + Math.ceil(ja_continuous_batch_index / batchSize) + ', nodes ' + ja_continuous_batch_index + '-' + endIndex + ' of ' + ja_continuous_needs_batching.length, 2); // Process this batch of cache misses for (var i = ja_continuous_batch_index; i < endIndex; i++) { var node = ja_continuous_needs_batching[i]; if (!ja_is_valid_routing_node(node)) continue; // Recalculate angles for this cache miss ja_log('Calculating angles for new node ' + node.id, 3); var angles = ja_calculate_angles_for_node(node); // Store in cache ja_write_to_cache(node.id, angles); // Render new markers immediately (incrementally add to layer) var problemAngles = ja_filter_problem_angles(angles); for (var j = 0; j < problemAngles.length; j++) { var angle = problemAngles[j]; var markerKey = node.id + '_' + angle.s_in_id + '_' + angle.s_out_id + '_' + Math.round(angle.angle * 10); if (!ja_continuous_rendered.has(markerKey)) { var labelDistance = ja_compute_label_distance(); var pt = turf.destination(turf.point(node.geometry.coordinates), (labelDistance) / 1000, ja_math_to_compass(angle.bearing)).geometry; ja_draw_marker(pt, node, labelDistance, angle.angle, angle.bearing, true, angle.type, false, false); ja_continuous_rendered.add(markerKey); } } } var batchEndTime = Date.now(); ja_continuous_batch_index = endIndex; // If more misses to process, schedule next batch if (ja_continuous_batch_index < ja_continuous_needs_batching.length) { setTimeout(() => ja_scan_nodes_batch_from_list(batchSize), BATCH_PROCESSING_DELAY); ja_log('Batch processing took ' + (batchEndTime - batchStartTime) + 'ms. Next batch in ' + BATCH_PROCESSING_DELAY + 'ms...', 2); } else { var totalCacheSize = Object.keys(ja_continuous_cache).length; var totalAnglePairs = 0; for (var cId in ja_continuous_cache) { if (ja_continuous_cache.hasOwnProperty(cId)) { totalAnglePairs += ja_continuous_cache[cId].angles.length; } } ja_log('All cache misses resolved. Cache: ' + totalCacheSize + ' nodes / ' + totalAnglePairs + ' angle pairs. Total batch time: ~' + (batchEndTime - batchStartTime) + 'ms', 2); ja_continuous_batch_index = 0; ja_continuous_needs_batching = []; } } /** * Process a batch of nodes incrementally (20 at a time) to avoid UI freeze. * Checks cache first: if angle pair cached and fresh (2-min TTL), skips recalculation. * Cache miss: calculates angles via ja_guess_routing_instruction() and caches result. * Markers persist on layer until segment edits invalidate cache for that node. * Schedules next batch via setTimeout (BATCH_PROCESSING_DELAY ms = non-blocking). */ function ja_scan_nodes_batch(batchSize) { if (!ja_continuous_mode) return; // Bail if continuous mode disabled var batchStartTime = Date.now(); var batchCacheHits = 0; var batchCacheMisses = 0; // Calculate batch end index var endIndex = Math.min(ja_continuous_batch_index + batchSize, ja_nodes_all.length); ja_log('Continuous scan batch: nodes ' + ja_continuous_batch_index + '-' + endIndex + ' of ' + ja_nodes_all.length, 2); // Process this batch for (var i = ja_continuous_batch_index; i < endIndex; i++) { var node = ja_nodes_all[i]; if (!ja_is_valid_routing_node(node)) continue; // Skip 2-way roads (no routing ambiguity) // Check cache (2-min TTL) var cached = ja_continuous_cache[node.id]; if (ja_is_cache_fresh(cached)) { batchCacheHits++; ja_log('Cache HIT: node ' + node.id, 4); continue; // Use cached, skip recalculation } // Cache miss or expired: recalculate angles using existing JAI logic batchCacheMisses++; ja_log('Cache MISS: node ' + node.id, 4); var angles = ja_calculate_angles_for_node(node); // Store in cache ja_write_to_cache(node.id, angles); } var batchEndTime = Date.now(); ja_continuous_batch_index = endIndex; // If more nodes to process, schedule next batch with BATCH_PROCESSING_DELAY (keeps editor responsive) if (ja_continuous_batch_index < ja_nodes_all.length) { setTimeout(() => ja_scan_nodes_batch(batchSize), BATCH_PROCESSING_DELAY); ja_log('Batch took ' + (batchEndTime - batchStartTime) + 'ms (' + batchCacheHits + ' hits / ' + batchCacheMisses + ' misses). Next batch in ' + BATCH_PROCESSING_DELAY + 'ms...', 2); } else { var totalCacheSize = Object.keys(ja_continuous_cache).length; var totalAnglePairs = 0; for (var cId in ja_continuous_cache) { if (ja_continuous_cache.hasOwnProperty(cId)) { totalAnglePairs += ja_continuous_cache[cId].angles.length; } } ja_log('Complete scan done: ' + totalCacheSize + ' nodes / ' + totalAnglePairs + ' angle pairs. Final batch: ' + (batchEndTime - batchStartTime) + 'ms (' + batchCacheHits + ' hits / ' + batchCacheMisses + ' misses). Rendering PROBLEM markers...', 2); ja_render_continuous_problems(); ja_continuous_batch_index = 0; // Reset for next scan } } /** * Calculate all angles for a single node using existing JAI logic. * Returns array of angle objects with type (PROBLEM, TURN, KEEP, BC, U_TURN, etc.) * Reuses ja_guess_routing_instruction() which detects gray zones correctly. */ function ja_calculate_angles_for_node(node) { var nodeSegmentIds = node.connectedSegmentIds; if (nodeSegmentIds.length < 3) return []; // Skip 2-way roads // First pass: build complete angles array of [angle, segmentId] pairs // This is what ja_guess_routing_instruction expects var angles_raw = []; for (var i = 0; i < nodeSegmentIds.length; i++) { var seg_i = sdk.DataModel.Segments.getById({ segmentId: nodeSegmentIds[i] }); if (!seg_i) continue; var bearing_i = ja_getAngle(node.id, seg_i); if (bearing_i === null) continue; angles_raw.push([bearing_i, nodeSegmentIds[i]]); } if (angles_raw.length < 3) return []; // Need at least 3 segments for routing ambiguity // Second pass: for each pair of segments in both directions, get routing type using ja_guess_routing_instruction // Evaluate all ordered pairs (A→B and B→A) to catch PROBLEM angles regardless of segment order var angles_with_types = []; for (var i = 0; i < angles_raw.length; i++) { for (var j = 0; j < angles_raw.length; j++) { if (i === j) continue; // Skip same segment var s_in_id = angles_raw[i][1]; var s_out_id = angles_raw[j][1]; var angle = ja_angle_diff(angles_raw[i][0], angles_raw[j][0], false); // Get routing type using existing function (includes gray zone detection) var routingType = ja_guess_routing_instruction(node, s_in_id, s_out_id, angles_raw); ja_log('Angle pair: ' + s_in_id + ' → ' + s_out_id + ' = ' + routingType, 4); // Compute midpoint bearing for marker placement (handles wrap-around at 0°/360°) var b_in = angles_raw[i][0]; var b_out = angles_raw[j][0]; var bearing_diff = b_out - b_in; if (bearing_diff > 180) bearing_diff -= 360; if (bearing_diff < -180) bearing_diff += 360; var bearing_mid = b_in + bearing_diff / 2; if (bearing_mid < 0) bearing_mid += 360; if (bearing_mid >= 360) bearing_mid -= 360; angles_with_types.push({ angle: angle, type: routingType, s_in_id: s_in_id, s_out_id: s_out_id, bearing_in: angles_raw[i][0], bearing_out: angles_raw[j][0], bearing: bearing_mid // Midpoint for marker positioning (corrected for wrap-around) }); } } return angles_with_types; } /** * Render only NEW PROBLEM angles from cache to the junction_angles layer. * Skips if there's an active selection (on-demand markers take priority). * Skips angles already rendered (tracked in ja_continuous_rendered Set). * Markers persist on layer until segment edits invalidate their cache entry. * Filters to PROBLEM type only (like BJAI's optimization). * Reuses ja_draw_marker() for consistent styling. */ function ja_render_continuous_problems() { if (!ja_continuous_mode) return; // Don't render continuous markers if user has a selection active (on-demand markers take priority) if (hasSelection()) { ja_log('Skipping continuous marker render (selection active)', 3); return; } var problemCount = 0; var nodeCount = 0; // Iterate cache for (var nodeId in ja_continuous_cache) { if (!ja_continuous_cache.hasOwnProperty(nodeId)) continue; var entry = ja_continuous_cache[nodeId]; var node = sdk.DataModel.Nodes.getById({ nodeId: parseInt(nodeId) }); if (!node) continue; nodeCount++; // Filter to PROBLEM angles only var problemAngles = ja_filter_problem_angles(entry.angles); for (var i = 0; i < problemAngles.length; i++) { var angle = problemAngles[i]; // Create unique key for this angle: nodeId + segment pair + rounded angle // Prevents duplicate markers if render is called multiple times var markerKey = nodeId + '_' + angle.s_in_id + '_' + angle.s_out_id + '_' + Math.round(angle.angle * 10); // Skip if already rendered if (ja_continuous_rendered.has(markerKey)) { ja_log('Skipping duplicate angle marker: ' + markerKey, 3); continue; } var labelDistance = ja_compute_label_distance(); // Calculate marker position (midpoint bearing, offset from node) var pt = turf.destination(turf.point(node.geometry.coordinates), (labelDistance) / 1000, ja_math_to_compass(angle.bearing)).geometry; // Draw using existing JAI marker function (reuses styling) ja_draw_marker(pt, node, labelDistance, angle.angle, angle.bearing, true, angle.type, false, false); // Mark this angle as rendered ja_continuous_rendered.add(markerKey); problemCount++; } } ja_log('Rendered ' + problemCount + ' PROBLEM markers from cache (' + nodeCount + ' nodes)', 2); } /** * Start a continuous scan: Phase 1 render cached nodes instantly, Phase 2 batch new nodes. * * PHASE 1 (instant): Loop through viewport, render all cached nodes with CURRENT labelDistance. * - Cache contains all angle types (PROBLEM, TURN, KEEP, BC, U_TURN, etc.) * - Filter to PROBLEM only for continuous mode * - Recalculate marker position with new zoom's labelDistance (only position, not angles) * - Add to layer incrementally * * PHASE 2 (background): Batch process nodes NOT in cache * - Calculate all angle pairs, cache them * - Render PROBLEM only, add to layer as batches complete * * Called by pan/zoom/edit event handlers. */ function ja_start_continuous_scan() { if (!ja_continuous_mode) return; // Skip if zoomed out below minimum level if (sdk.Map.getZoomLevel() < MIN_ZOOM_LEVEL) { ja_log('Zoom level ' + sdk.Map.getZoomLevel() + ' < ' + MIN_ZOOM_LEVEL + ', skipping continuous scan', 3); return; } // Skip if user has selection active (on-demand is showing, don't interfere) if (hasSelection()) { ja_log('Selection active, skipping continuous scan', 3); return; } // Clear layer, rendered Set, and feature tracking for fresh collision detection on zoom // ja_current_features holds marker positions used by ja_draw_marker() for collision detection. // If we don't clear it, collision detection will reference old positions from previous zoom level, // causing markers to be nudged further away with each zoom cycle (accumulation drift). sdk.Map.removeAllFeaturesFromLayer({ layerName: 'junction_angles' }); ja_continuous_rendered.clear(); ja_current_features = []; ja_feature_counter = 0; ja_log('Cleared layer and feature tracking for fresh marker positioning at new zoom level', 2); // Snapshot current viewport nodes using modern SDK API var scanStartTime = Date.now(); ja_nodes_all = sdk.DataModel.Nodes.getAll() || []; ja_continuous_batch_index = 0; ja_continuous_needs_batching = []; // Count current cache state before scan var preScanCacheSize = Object.keys(ja_continuous_cache).length; var preScanAnglePairs = 0; for (var cId in ja_continuous_cache) { if (ja_continuous_cache.hasOwnProperty(cId)) { preScanAnglePairs += ja_continuous_cache[cId].angles.length; } } var validRouteNodes = 0; for (var ni = 0; ni < ja_nodes_all.length; ni++) { if (ja_is_valid_routing_node(ja_nodes_all[ni])) validRouteNodes++; } ja_log('SCAN START: ' + ja_nodes_all.length + ' nodes in viewport, ' + validRouteNodes + ' have 3+ segments. Pre-scan cache: ' + preScanCacheSize + ' nodes / ' + preScanAnglePairs + ' angle pairs', 2); var cacheHits = 0; var cacheMisses = 0; // PHASE 1: Render cached nodes immediately (no calculation needed, just reposition with current labelDistance) for (var i = 0; i < ja_nodes_all.length; i++) { var node = ja_nodes_all[i]; if (!ja_is_valid_routing_node(node)) continue; var cached = ja_continuous_cache[node.id]; // Cache hit (fresh): render immediately with current labelDistance, skip batching if (ja_is_cache_fresh(cached)) { cacheHits++; var entry = cached; // Render ALL PROBLEM angles from cache (filter continuous mode) var problemAngles = ja_filter_problem_angles(entry.angles); for (var j = 0; j < problemAngles.length; j++) { var angle = problemAngles[j]; var markerKey = node.id + '_' + angle.s_in_id + '_' + angle.s_out_id + '_' + Math.round(angle.angle * 10); var labelDistance = ja_compute_label_distance(); // Current zoom's distance var pt = turf.destination(turf.point(node.geometry.coordinates), (labelDistance) / 1000, ja_math_to_compass(angle.bearing)).geometry; ja_draw_marker(pt, node, labelDistance, angle.angle, angle.bearing, true, angle.type, false, false); ja_continuous_rendered.add(markerKey); } } else { // Cache miss (expired or new): queue for PHASE 2 batching cacheMisses++; ja_continuous_needs_batching.push(node); } } var phase1EndTime = Date.now(); ja_log('PHASE 1 complete: ' + cacheHits + ' cache hits / ' + cacheMisses + ' misses (' + (phase1EndTime - scanStartTime) + 'ms). Queuing ' + ja_continuous_needs_batching.length + ' nodes for background batching...', 2); // PHASE 2: Batch process cache misses (20-node batches: 6ms calc + 50ms delay = fast & responsive) if (ja_continuous_needs_batching.length > 0) { ja_scan_nodes_batch_from_list(20); } else { var finalCacheSize = Object.keys(ja_continuous_cache).length; ja_log('SCAN COMPLETE: No cache misses, all nodes fresh. Final cache: ' + finalCacheSize + ' nodes. Total time: ' + (phase1EndTime - scanStartTime) + 'ms', 2); } } /** * Debounced continuous scan trigger: prevents redundant scans during rapid events. * Cancels pending timeout if new event fires within 100ms, then reschedules. * Called by zoom/pan/edit event handlers. */ function ja_debounced_continuous_scan() { if (!ja_continuous_mode) return; // Skip if zoomed out below minimum level if (sdk.Map.getZoomLevel() < MIN_ZOOM_LEVEL) { ja_log('Zoom level ' + sdk.Map.getZoomLevel() + ' < ' + MIN_ZOOM_LEVEL + ', skipping debounced scan', 3); return; } // Cancel any pending timeout if (ja_continuous_scan_timer) { clearTimeout(ja_continuous_scan_timer); ja_log('Cancelled pending continuous scan', 3); } // Schedule new scan CONTINUOUS_SCAN_DEBOUNCE from now (allows batching of rapid events) ja_continuous_scan_timer = setTimeout(() => { ja_start_continuous_scan(); ja_continuous_scan_timer = null; }, CONTINUOUS_SCAN_DEBOUNCE); } /** * Main entry point for junction angle calculation and marker rendering. * * Triggered by every selection-change, zoom, or map-move event. Clears the * junction_angles layer, collects the selected nodes, computes label distances, * identifies roundabouts, draws roundabout markers, identifies double-turn * connector segments, then draws per-node angle markers. * * Selection handling: * - 1 feature (segment or node): standard single-selection mode — all connected angles shown. * - Exactly 2 segments that share a node: two-segment mode — one turn-angle marker is drawn * at the shared junction node, color-coded with routing instruction prediction. * - 2 segments with no shared node, 2 mixed types, or 3+ features: no markers drawn. * * Exits early if the data model returns stale data that requires a deferred retry. */ function testSelectedItem() { // Always clear the layer first to stay in sync with selection state sdk.Map.removeAllFeaturesFromLayer({ layerName: 'junction_angles' }); ja_roundabout_points = []; ja_current_features = []; ja_feature_counter = 0; // If continuous scanning is active, mark all rendered markers as cleared (so they'll be re-rendered after on-demand markers) if (ja_continuous_mode) { ja_continuous_rendered.clear(); ja_log('Cleared rendered marker tracking for on-demand refresh', 3); } // Clear marker position tracking maps so local/far-turn conflict detection starts fresh ja_local_markers_by_node = {}; ja_far_turn_bearings_by_node = {}; // Cache traffic handedness for this render pass (used in ja_guess_routing_instruction and ja_draw_roundabout_entry_exits) ja_is_left_hand_traffic = (sdk.DataModel.Countries.getAll()[0] || {}).isLeftHandTraffic || false; // Early exit if nothing is selected (after cleanup) var ja_selfeat = getselfeat(); if (ja_selfeat.length === 0 || ja_selfeat.length > 2) { // Nothing selected — re-render continuous markers if enabled and zoom is sufficient if (ja_continuous_mode && sdk.Map.getZoomLevel() >= MIN_ZOOM_LEVEL) { ja_log('No selection active. Re-rendering continuous markers (deselect/no-op call)...', 2); ja_render_continuous_problems(); } return; } if (sdk.Map.getZoomLevel() < MIN_ZOOM_LEVEL) { return; } if (ja_getOption('roundaboutOverlayDisplay') === 'rOverAlways') { ja_draw_roundabout_overlay(); } var ja_start_time = Date.now(); var ja_nodes = []; if (ja_selfeat.length === 2) { // Two-segment mode: only supported when both selected features are segments if (ja_selfeat[0].type !== 'segment' || ja_selfeat[1].type !== 'segment') { return; } var seg0 = sdk.DataModel.Segments.getById({ segmentId: ja_selfeat[0].id }); var seg1 = sdk.DataModel.Segments.getById({ segmentId: ja_selfeat[1].id }); if (!seg0 || !seg1) { return; } // Find the node shared by both segments — this is the junction to measure var seg0Nodes = [seg0.fromNodeId, seg0.toNodeId]; var seg1Nodes = [seg1.fromNodeId, seg1.toNodeId]; var sharedNodeId = seg0Nodes.filter(function (id) { return seg1Nodes.indexOf(id) >= 0; })[0]; if (sharedNodeId == null) { return; } // segments not connected — nothing to show ja_nodes.push(sharedNodeId); } else { // Single feature — extract endpoint nodes from segment, or push node id directly ja_selfeat.forEach(function (element) { if (element.type === 'node') { ja_nodes.push(element.id); } else if (element.type === 'segment') { var seg = sdk.DataModel.Segments.getById({ segmentId: element.id }); if (seg && seg.fromNodeId != null && ja_nodes.indexOf(seg.fromNodeId) === -1) { ja_nodes.push(seg.fromNodeId); } if (seg && seg.toNodeId != null && ja_nodes.indexOf(seg.toNodeId) === -1) { ja_nodes.push(seg.toNodeId); } } ja_log(ja_nodes, 4); }); } var ja_label_distance = ja_compute_label_distance(); // Cache BigJunctions for the entire render pass — eliminates 5 separate .getAll() calls var allBigJunctions = sdk.DataModel.BigJunctions.getAll(); // When a node is directly selected (not via segment selection), suppress roundabout/path/junction // markers — show only the node's absolute angle markers (angles at that specific node). var ja_is_pure_node_selection = ja_selfeat.length === 1 && ja_selfeat[0].type === 'node'; // Only draw roundabout and path/junction markers if NOT a pure node selection if (!ja_is_pure_node_selection) { var ja_selected_roundabouts = ja_find_roundabouts(ja_nodes); ja_draw_roundabout_markers(ja_selected_roundabouts, ja_label_distance); } // When a single roundabout arc is selected, ja_draw_roundabout_entry_exits already shows // all exit info relative to the arc's fromNode. Suppress ja_draw_node_markers so the // regular intersection-style angles don't fire on the roundabout's own nodes. var ja_marker_nodes = ja_nodes; if (ja_selfeat.length === 1 && ja_selfeat[0].type === 'segment') { var _arcSeg = sdk.DataModel.Segments.getById({ segmentId: ja_selfeat[0].id }); if (_arcSeg && _arcSeg.junctionId !== null) { ja_marker_nodes = []; } } var doubleTurns = ja_collect_double_turns(ja_marker_nodes, allBigJunctions); // True if any selected segment is contained inside a BigJunction (a median/intermediate // segment). In that case ja_draw_node_markers suppresses far-turn markers: the regular // node-pair loop handles internal angles, and far-turn exit markers would be misleading. var ja_selected_has_median = ja_selfeat.some(function (feat) { return feat.type === 'segment' && sdk.DataModel.Segments.isContainedInBigJunction({ segmentId: feat.id }); }); // IDs of the segments explicitly selected by the user. Used to restrict far-turn marker // drawing to only the selected entry segment(s), matching how regular departure-mode // markers work (angles shown FROM the selected segment, not FROM all segments at the node). // // When a node is selected directly (no segment in ja_selfeat), this array is empty — in // that case ja_draw_far_turn_markers shows far turns from ALL connected non-median segments. var ja_selected_seg_ids = ja_selfeat .filter(function (feat) { return feat.type === 'segment'; }) .map(function (feat) { return feat.id; }); if (ja_draw_node_markers(ja_marker_nodes, ja_label_distance, doubleTurns, ja_selected_has_median, ja_selected_seg_ids, allBigJunctions, ja_is_pure_node_selection)) { return; } ja_last_restart = 0; var ja_end_time = Date.now(); ja_log('Calculation took ' + String(ja_end_time - ja_start_time) + ' ms', 3); // After on-demand rendering completes, only re-render continuous markers if NO selection active // When user has something selected, on-demand markers take priority (continuous would clutter the view) // When user deselects, continuous markers reappear to show background problems if (ja_continuous_mode && !hasSelection()) { ja_log('No selection active. Re-rendering continuous markers...', 2); ja_render_continuous_problems(); } } /** * Alias for testSelectedItem used by deferred callers (ja_apply, ja_calculation_timer). * * Some paths need to schedule a recalculation after an async delay (e.g. after * settings change). They call ja_calculate_real() by reference captured before * the alias is established. Both names refer to the same function. */ // Alias so ja_calculate_real() calls (from timer/ja_apply) work var ja_calculate_real = testSelectedItem; /* * Drawing functions */ /** * Predicts the Waze routing instruction for a turn from one segment to another. * * Implements a multi-step decision tree: * 1. Checks for a manually overridden turn instruction (instructionOpCode). * 2. Classifies by angle: BC (best continuation / no instruction), Keep Left/Right, * Turn Left/Right, U-Turn, or gray-zone PROBLEM. * 3. Refines Keep vs BC using street name continuity, road type hierarchy, and * segment count to determine which exit is the "straight-through" road. * 4. Handles ramp and exit-road special cases. * * @param {Object} node - SDK Node object at the junction. * @param {number} s_in_id - Segment ID of the incoming road. * @param {number} s_out_id - Segment ID of the candidate exit. * @param {Array} angles - All bearing/segmentId/isSelected triples at this node. * @param {boolean} [logRestrictions=true] - If false, suppresses logging of turn blocks (used to reduce redundant logs during batch processing and far-turn evaluations). * @returns {string} A ja_routing_type value string (e.g., 'junction_turn', 'junction_keep_left', 'junction_problem'). */ function ja_guess_routing_instruction(node, s_in_a, s_out_a, angles, logRestrictions) { if (typeof logRestrictions === 'undefined') logRestrictions = true; // Default: log turn blocks var s_n = {}, s_in = null, s_out = {}, street_n = {}, street_in = null, angle; var s_in_id = s_in_a; var s_out_id = s_out_a; s_in_a = angles.filter(function (element) { return element[1] === s_in_a; }); s_out_a = angles.filter(function (element) { return element[1] === s_out_a; }); node.connectedSegmentIds.forEach(function (element) { if (element === s_in_id) { s_in = sdk.DataModel.Segments.getById({ segmentId: element }); street_in = ja_get_streets(element); if (street_in.primary == null) { street_in.primary = { name: '' }; } else if (street_in.primary.name == null) { street_in.primary.name = ''; } } else { if (element === s_out_id) { s_out[element] = sdk.DataModel.Segments.getById({ segmentId: element }); if (typeof s_out[element].primary === 'undefined') { s_out[element].primary = { name: '' }; } } s_n[element] = sdk.DataModel.Segments.getById({ segmentId: element }); street_n[element] = ja_get_streets(element); if (street_n[element].primary == null) { street_n[element].primary = { name: '' }; } } }); if (s_in === null || street_in === null) { return ja_routing_type.PROBLEM; } angle = ja_angle_diff(s_in_a[0], s_out_a[0], false); ja_log('Angle: ' + angle.toFixed(1) + '°', 4); if (!ja_is_turn_allowed(s_in, node, s_out[s_out_id])) { if (logRestrictions) { ja_log('Turn blocked: ' + s_in_id + ' → ' + s_out_id + ' via ' + node.id, 2); } return ja_routing_type.NO_TURN; } //seb-d59: Check override instruction if (ja_getOption('override')) { var turns = sdk.DataModel.Turns.getTurnsThroughNode({ nodeId: node.id }); var overrideTurn = turns.find(function (t) { return t.fromSegmentId === s_in_id && t.toSegmentId === s_out_id; }); var opcode = overrideTurn ? overrideTurn.instructionOpCode : null; if (opcode !== null) { var opcodeType = ja_opcode_to_routing_type(opcode, true); if (opcodeType !== null) { return opcodeType; } } } //Roundabout - no true instruction guessing here! if (s_in.junctionId) { if (s_out[s_out_id].junctionId) { ja_log('Roundabout continuation (BC)', 3); return ja_routing_type.BC; } else { ja_log('Roundabout exit', 3); return ja_routing_type.ROUNDABOUT_EXIT; } } else if (s_out[s_out_id].junctionId) { ja_log('Roundabout entry (BC)', 3); return ja_routing_type.BC; } if (Math.abs(angle) > U_TURN_ANGLE + GRAY_ZONE) { ja_log('U-TURN: ' + s_in_id + ' → ' + s_out_id + ' (' + angle.toFixed(1) + '°)', 2); return ja_routing_type.U_TURN; } else if (Math.abs(angle) > U_TURN_ANGLE - GRAY_ZONE) { ja_log('U-TURN gray zone: ' + s_in_id + ' → ' + s_out_id + ' (' + angle.toFixed(1) + '°)', 3); return ja_routing_type.PROBLEM; } if (node.connectedSegmentIds.length <= 2) { ja_log('Only 2 segments at node ' + node.id + ': BC (no instruction)', 2); return ja_routing_type.BC; } if (Math.abs(angle) < TURN_ANGLE - GRAY_ZONE) { ja_log('Angle < 44° (BC eval zone)', 4); angles = angles.filter(function (a) { if (s_out_id === a[1] || (typeof s_n[a[1]] !== 'undefined' && ja_is_turn_allowed(s_in, node, s_n[a[1]]) && Math.abs(ja_angle_diff(s_in_a, a[0], false)) < TURN_ANGLE)) { return true; } else { if (street_n[a[1]]) { delete s_n[a[1]]; delete street_n[a[1]]; } return false; } }); if (angles.length <= 1) { return ja_routing_type.BC; } var bc_matches = {}, bc_prio = 0, bc_count = 0; /** * Accumulates a BC candidate into `bc_matches` using a priority-wins strategy. * * If `prio` is higher than the current best priority, the candidate set is reset and * only this candidate is kept. Candidates at the same priority are added alongside * existing ones. Lower-priority candidates are silently ignored. The final `bc_matches` * map contains only the highest-priority candidates, used to decide whether to assign a * BC instruction or fall through to Keep/Turn classification. * * @param {Array} a - Candidate angle tuple (format: `[angle, segmentId, ...]`). * @param {number} prio - Priority level; higher values win (e.g. name-match > road-type). */ var bc_collect = function (a, prio) { if (prio > bc_prio) { bc_matches = {}; bc_prio = prio; bc_count = 0; } if (prio === bc_prio) { bc_matches[a[1]] = a; bc_count++; } }; for (var k = 0; k < angles.length; k++) { var a = angles[k]; var tmp_s_out = {}; tmp_s_out[a[1]] = s_n[a[1]]; var tmp_street_out = {}; tmp_street_out[a[1]] = street_n[a[1]]; var name_match = ja_primary_name_match(street_in, tmp_street_out) || ja_alt_name_match(street_in, tmp_street_out) || ja_cross_name_match(street_in, tmp_street_out); if (name_match && ja_segment_type_match(s_in, tmp_s_out)) { bc_collect(a, 3); } else if (name_match) { bc_collect(a, 2); } else if (ja_segment_type_match(s_in, tmp_s_out)) { bc_collect(a, 1); } } if (bc_matches[s_out_id] !== undefined && bc_count === 1) { ja_log('BC found: ' + s_in_id + ' → ' + s_out_id + ' via ' + node.id + ' (straight)', 2); return ja_routing_type.BC; } angles.sort(function (a, b) { return ja_angle_dist(a[0], s_in_a[0][0]) - ja_angle_dist(b[0], s_in_a[0][0]); }); if (!ja_is_left_hand_traffic) { //RHT if (angles[0][1] === s_out_id && !ja_overlapping_angles(angles[0][0], angles[1][0])) { ja_log('BC → KEEP_LEFT (leftmost <45°)', 3); return ja_routing_type.KEEP_LEFT; } } else { //LHT if (angles[angles.length - 1][1] === s_out_id && !ja_overlapping_angles(angles[angles.length - 1][0], angles[angles.length - 2][0])) { ja_log('BC → KEEP_RIGHT (rightmost <45°)', 3); return ja_routing_type.KEEP_RIGHT; } } var overlap_i = 1; while (overlap_i < angles.length && ja_overlapping_angles(angles[0][0], angles[overlap_i][0])) { ++overlap_i; } if (overlap_i > 1 && overlap_i === angles.length) { return ja_routing_type.BC; } if (ja_is_primary_road(s_in) && !ja_is_primary_road(s_out[s_out_id])) { ja_log('Primary→non-primary = EXIT', 3); return ja_is_left_hand_traffic ? ja_routing_type.EXIT_LEFT : ja_routing_type.EXIT_RIGHT; } if (ja_is_ramp(s_in) && !ja_is_primary_road(s_out[s_out_id]) && !ja_is_ramp(s_out[s_out_id])) { ja_log('Ramp→non-primary = EXIT', 3); return ja_is_left_hand_traffic ? ja_routing_type.EXIT_LEFT : ja_routing_type.EXIT_RIGHT; } return ja_is_left_hand_traffic ? ja_routing_type.KEEP_LEFT : ja_routing_type.KEEP_RIGHT; } else if (Math.abs(angle) < TURN_ANGLE + GRAY_ZONE) { ja_log('PROBLEM gray zone: ' + s_in_id + ' → ' + s_out_id + ' via ' + node.id + ' (' + angle.toFixed(1) + '°)', 2); return ja_routing_type.PROBLEM; } else { // Use centralized angle classification for consistency return ja_classify_turn_angle(angle); } } /** * Places a single angle marker feature on the junction_angles layer. * * Handles label text formatting for both Fancy (arrow on own line) and Simple * (arrow inline) display styles, then checks for overlap with already-placed * markers (ja_current_features). If the candidate point overlaps an existing * marker, nudges it outward in the direction of ha until clear. Adds the feature * via sdk.Map.addFeatureToLayer with properties that drive the styleRules. * * @param {GeoJSON.Point} point - Initial candidate geometry for the marker. * @param {Object} node - SDK Node object at the junction. * @param {number} ja_label_distance - Base offset distance in meters. * @param {number} a - Signed turn angle in degrees to display. * @param {number} ha - Bearing from the node to the marker (for nudge direction). * @param {boolean} [withRouting=false] - True: include routing instruction type and arrow. * @param {string} [ja_junction_type] - ja_routing_type value; required when withRouting is true. * @param {boolean} [isFarTurn=false] - True for far-turn markers (path/JB breadcrumbs). * @param {boolean} [isSquareMarker=false] - True to render as square; false for round (intermediate breadcrumb). */ function ja_draw_marker(point, node, ja_label_distance, a, ha, withRouting, ja_junction_type, isFarTurn, isSquareMarker) { //Try to estimate of the point is "too close" to another point //(or maybe something else in the future; like turn restriction arrows or something) //FZ69617: Exctract initial label distance from point var ja_tmp_distance = turf.distance(turf.point(node.geometry.coordinates), turf.point(point.coordinates)) * 1000; // meters ja_log('Starting distance estimation', 3); while ( ja_current_features.some(function (feat) { if (feat.ja_type !== 'roundaboutOverlay') { var dist = turf.distance(turf.point(feat.coordinates), turf.point(point.coordinates)) * 1000; if (ja_label_distance / 1.4 > dist) { ja_log(ja_label_distance / 1.5 > dist + ' is kinda close..', 3); return true; } } return false; }) ) { //add 1/4 of the original distance and hope for the best =) ja_tmp_distance += ja_label_distance / 4; ja_log('setting distance to ' + ja_tmp_distance, 3); point = turf.destination(turf.point(node.geometry.coordinates), ja_tmp_distance / 1000, ja_math_to_compass(ha)).geometry; } ja_log('Distance estimation done', 3); var angleString = ja_round(Math.abs(a)) + '°'; //FZ69617: Add direction arrows for turn instructions only if (ja_getOption('angleDisplay') === 'displaySimple') { switch (ja_junction_type) { case ja_routing_type.TURN: angleString = a > 0 ? ja_arrow.left() + angleString : angleString + ja_arrow.right(); break; case ja_routing_type.TURN_LEFT: angleString = ja_arrow.left() + angleString; break; case ja_routing_type.TURN_RIGHT: angleString = angleString + ja_arrow.right(); break; case ja_routing_type.EXIT: case ja_routing_type.KEEP: angleString = a > 0 ? ja_arrow.left_up() + angleString : angleString + ja_arrow.right_up(); break; case ja_routing_type.EXIT_LEFT: case ja_routing_type.KEEP_LEFT: angleString = ja_arrow.left_up() + angleString; break; case ja_routing_type.EXIT_RIGHT: case ja_routing_type.KEEP_RIGHT: angleString += ja_arrow.right_up(); break; //Override case ja_routing_type.OverrideBC: angleString = ja_getOption('overrideAngles') ? angleString : ''; break; case ja_routing_type.OverrideCONTINUE: angleString = ja_arrow.up() + (ja_getOption('overrideAngles') ? angleString : ''); break; case ja_routing_type.OverrideTURN_LEFT: angleString = ja_arrow.left() + (ja_getOption('overrideAngles') ? angleString : ''); break; case ja_routing_type.OverrideTURN_RIGHT: angleString = (ja_getOption('overrideAngles') ? angleString : '') + ja_arrow.right(); break; case ja_routing_type.OverrideEXIT_LEFT: case ja_routing_type.OverrideKEEP_LEFT: angleString = ja_arrow.left_up() + (ja_getOption('overrideAngles') ? angleString : ''); break; case ja_routing_type.OverrideEXIT_RIGHT: case ja_routing_type.OverrideKEEP_RIGHT: angleString = (ja_getOption('overrideAngles') ? angleString : '') + ja_arrow.right_up(); default: ja_log('No extra format for junction type: ' + ja_junction_type, 3); } } else { switch (ja_junction_type) { case ja_routing_type.TURN: angleString = (a > 0 ? ja_arrow.left() : ja_arrow.right()) + '\n' + angleString; break; case ja_routing_type.TURN_LEFT: angleString = ja_arrow.left() + '\n' + angleString; break; case ja_routing_type.TURN_RIGHT: angleString = ja_arrow.right() + '\n' + angleString; break; case ja_routing_type.EXIT: case ja_routing_type.KEEP: angleString = (a > 0 ? ja_arrow.left_up() : ja_arrow.right_up()) + '\n' + angleString; break; case ja_routing_type.EXIT_LEFT: case ja_routing_type.KEEP_LEFT: angleString = ja_arrow.left_up() + '\n' + angleString; break; case ja_routing_type.EXIT_RIGHT: case ja_routing_type.KEEP_RIGHT: angleString = ja_arrow.right_up() + '\n' + angleString; break; case ja_routing_type.PROBLEM: angleString = '?\n' + angleString; break; //Override case ja_routing_type.OverrideBC: angleString = ja_getOption('overrideAngles') ? angleString : ''; break; case ja_routing_type.OverrideCONTINUE: angleString = ja_arrow.up() + (ja_getOption('overrideAngles') ? '\n' + angleString : ''); break; case ja_routing_type.OverrideTURN_LEFT: angleString = ja_arrow.left() + (ja_getOption('overrideAngles') ? '\n' + angleString : ''); break; case ja_routing_type.OverrideTURN_RIGHT: angleString = ja_arrow.right() + (ja_getOption('overrideAngles') ? '\n' + angleString : ''); break; case ja_routing_type.OverrideEXIT_LEFT: case ja_routing_type.OverrideKEEP_LEFT: angleString = ja_arrow.left_up() + (ja_getOption('overrideAngles') ? '\n' + angleString : ''); break; case ja_routing_type.OverrideEXIT_RIGHT: case ja_routing_type.OverrideKEEP_RIGHT: angleString = ja_arrow.right_up() + (ja_getOption('overrideAngles') ? '\n' + angleString : ''); break; default: ja_log('No extra format for junction type: ' + ja_junction_type, 3); } } var angleProps = withRouting ? { angle: angleString, ja_type: ja_junction_type, ja_is_far_turn: !!isFarTurn, ja_is_square_marker: !!isSquareMarker } : { angle: ja_round(a) + '°', ja_type: 'generic', ja_is_square_marker: !!isSquareMarker }; ja_log(angleProps, 4); //Don't paint points inside an overlaid roundabout if ( ja_roundabout_points.some(function (roundaboutPolygon) { return turf.booleanPointInPolygon(turf.point(point.coordinates), roundaboutPolygon); }) ) { return; } //Draw a line to the point ja_add_feature({ type: 'LineString', coordinates: [node.geometry.coordinates, point.coordinates] }, { ja_type: 'arrow_line' }); //push the angle point ja_current_features.push({ coordinates: point.coordinates, ja_type: angleProps.ja_type }); ja_add_feature(point, angleProps); } /** * Draws a circle polygon overlay on the junction_angles layer for one or all roundabouts. * * When called with a junctionId, draws a single circle for that junction. * When called without arguments, draws circles for every junction in the data model * (used for the 'rOverAlways' display mode). * * The circle radius is the mean distance from the WME junction center point to all * of its arc nodes, giving an approximate fit to the physical road ring. Drawn as a * 40-step Turf.js polygon feature styled by the roundaboutOverlayColor setting. * * @param {number} [junctionId] - Optional. If provided, draws only this junction's circle. */ function ja_draw_roundabout_overlay(junctionId) { (junctionId === undefined ? sdk.DataModel.Junctions.getAll() : (function (junction) { return junction === undefined ? [] : [junction]; })(sdk.DataModel.Junctions.getById({ junctionId: junctionId })) ).forEach(function (element) { ja_log(element, 3); var nodes = {}; element.segmentIds.forEach(function (s) { var seg = sdk.DataModel.Segments.getById({ segmentId: s }); ja_log(seg, 3); // Guard against null node IDs (can happen with unsaved segments) if (seg.fromNodeId) nodes[seg.fromNodeId] = sdk.DataModel.Nodes.getById({ nodeId: seg.fromNodeId }); if (seg.toNodeId) nodes[seg.toNodeId] = sdk.DataModel.Nodes.getById({ nodeId: seg.toNodeId }); }); ja_log(nodes, 3); var center = element.geometry; // GeoJSON Point ja_log(center, 3); var distances = []; Object.getOwnPropertyNames(nodes).forEach(function (name) { ja_log('Checking ' + name + ' distance', 3); // Skip if node is null or doesn't have geometry (unsaved segments can cause this) if (nodes[name] && nodes[name].geometry) { var dist = turf.distance(turf.point(nodes[name].geometry.coordinates), turf.point(center.coordinates)) * 1000; distances.push(dist); } }); ja_log(distances, 3); // Skip circle drawing if no valid nodes (all were null due to unsaved segments) if (distances.length === 0) { ja_log('No valid nodes for roundabout overlay (unsaved segments?)', 2); return; } var meanDistM = distances.reduce(function (a, b) { return a + b; }) / distances.length; ja_log('Mean distance is ' + meanDistM, 3); var circleGeom = turf.circle(turf.point(center.coordinates), meanDistM / 1000, { steps: 40 }).geometry; ja_roundabout_points.push(circleGeom); ja_add_feature(circleGeom, { ja_type: 'roundaboutOverlay' }); }); } /* * Segment and routing helpers */ /** * Returns true if the road type of segment_in matches any road type in the segments array. * * Used by ja_guess_routing_instruction() to compare incoming and outgoing road type * hierarchies when deciding between Keep and BC (best continuation) instructions. * * @param {Object} segment_in - SDK Segment object whose road type to test. * @param {Object[]} segments - Array of SDK Segment objects to match against. * @returns {boolean} True if any segment in the array shares segment_in's road type. */ function ja_segment_type_match(segment_in, segments) { ja_log(segment_in, 4); ja_log(segments, 4); return Object.getOwnPropertyNames(segments).some(function (segment_n_id, index) { var segment_n = segments[segment_n_id]; ja_log('[segment_type_match] Checking element ' + index, 3); ja_log(segment_n, 4); if (segment_n.id === segment_in.id) { return false; } ja_log('[segment_type_match] roadType ' + segment_n.roadType + ' vs ' + segment_in.roadType, 3); return segment_n.roadType === segment_in.roadType; }); } /** * Returns true if the segment is a primary street or major/minor highway. * * @param {Object} seg - SDK Segment object. * @returns {boolean} */ function ja_is_primary_road(seg) { var t = seg.roadType; return t === ja_road_type.FREEWAY || t === ja_road_type.MAJOR_HIGHWAY || t === ja_road_type.MINOR_HIGHWAY; } /** * Returns true if the segment qualifies for double U-turn detection. * Primary Street and above are always included. Street, Parking Lot Road, and * Private Road are opt-in via the U-Turn detection settings. * @param {Object} seg - SDK Segment object. * @returns {boolean} */ function ja_is_uturn_qualifying_road(seg) { var t = seg.roadType; if (t === ja_road_type.FREEWAY || t === ja_road_type.RAMP || t === ja_road_type.MAJOR_HIGHWAY || t === ja_road_type.MINOR_HIGHWAY || t === ja_road_type.PRIMARY_STREET) return true; if (t === ja_road_type.STREET && ja_getOption('uTurnIncludeStreet')) return true; if (t === ja_road_type.PARKING_LOT_ROAD && ja_getOption('uTurnIncludeParkingLot')) return true; if (t === ja_road_type.PRIVATE_ROAD && ja_getOption('uTurnIncludePrivateRoad')) return true; return false; } /** * Returns true if the segment is classified as a ramp. * * @param {Object} seg - SDK Segment object. * @returns {boolean} */ function ja_is_ramp(seg) { var t = seg.roadType; return t === ja_road_type.RAMP; } /** * Returns true if the turn from segmentId at nodeId toward toSegmentId has * lane guidance configured (turn.lanes !== null). * * Per the Waze U-turn spec, a median 31–49 m long qualifies for double-turn * detection only when the incoming segment has lane guidance set up on its * approach to the median junction node. * * @param {number} segmentId - ID of the incoming segment. * @param {number} nodeId - ID of the junction node shared with the median. * @param {number} toSegmentId - ID of the median segment. * @returns {boolean} */ function ja_segment_has_lane_guidance(segmentId, nodeId, toSegmentId) { var turns = sdk.DataModel.Turns.getTurnsFromSegment({ segmentId: segmentId, nodeId: nodeId }); if (!turns) return false; for (var i = 0; i < turns.length; i++) { if (turns[i].toSegmentId === toSegmentId && turns[i].lanes !== null) { return true; } } return false; } /** * Checks if two segments (A and C) are within a specified parallelism tolerance. * * Computes the bearing of segment A at its exit node and the bearing of segment C * at its entry node, then calculates the absolute angular difference. Returns true * if the difference is within the specified tolerance. * * @param {Object} segA - SDK Segment object for the incoming segment (A). * @param {Object} segC - SDK Segment object for the outgoing segment (C). * @param {number} nodeA_exit - Node ID at the exit of segment A (where A connects to B). * @param {number} nodeC_entry - Node ID at the entry of segment C (where B connects to C). * @param {number} toleranceDegrees - Maximum angular difference in degrees to consider parallel. * @returns {boolean} True if segments are within tolerance; false otherwise. */ function ja_is_segments_parallel(segA, segC, nodeA_exit, nodeC_entry, toleranceDegrees) { var bearingA = ja_getAngle(nodeA_exit, segA); var bearingC = ja_getAngle(nodeC_entry, segC); if (bearingA === null || bearingC === null) { return false; } var diff = Math.abs(ja_angle_diff(bearingA, bearingC, true)); ja_log('Parallelism check: A=' + ja_round(bearingA) + '° C=' + ja_round(bearingC) + '° diff=' + ja_round(diff) + '° tolerance=' + toleranceDegrees + '°', 3); return diff <= toleranceDegrees; } /** * Adds a GeoJSON feature to the junction_angles layer with an auto-incremented ID. * @param {Object} geometry - GeoJSON geometry object. * @param {Object} properties - Feature properties (must include ja_type). */ function ja_add_feature(geometry, properties) { sdk.Map.addFeatureToLayer({ layerName: 'junction_angles', feature: { id: 'ja_' + ++ja_feature_counter, type: 'Feature', geometry: geometry, properties: properties, }, }); } /** * Checks if a roundabout angle is "normal" per Waze normality criterion. * An angle is normal if it's within ±PERPENDICULAR_TOLERANCE° of a 90° multiple (0°, 90°, 180°, 270°). * * @param {number} angle - Triangle angle in degrees (0–180°). * @returns {boolean} */ function ja_is_angle_normal(angle) { var mod = Math.abs(angle % 90); return mod <= PERPENDICULAR_TOLERANCE || mod >= 90 - PERPENDICULAR_TOLERANCE; } /** * Corrects a base label distance for EPSG:3857 latitude distortion. * EPSG:3857 projected units equal true meters only at the equator; at latitude φ * they are stretched by 1/cos(φ). Multiplying by cos(φ) converts back to true meters * so that turf.destination offsets match the original OpenLayers distances. * @param {number} labelDistance - Base label offset in meters. * @param {number[]} coordinates - GeoJSON [lon, lat] coordinate pair. * @returns {number} Latitude-corrected label distance in meters. */ function ja_corrected_ld(labelDistance, coordinates) { return labelDistance * Math.cos((coordinates[1] * Math.PI) / 180); } /** * Checks if a segment crosses any BigJunction boundary (one endpoint inside, one outside). * * Centralizes the duplicated boundary-crossing detection logic that appears in: * - ja_collect_double_turns() (2 passes for median & arm segments) * - ja_draw_node_markers() (exit marker relocation) * - ja_draw_far_turn_markers() (fallback JB detection) * * @param {Object} seg - SDK Segment object to check. * @param {Array} allBigJunctions - Array from sdk.DataModel.BigJunctions.getAll(). * @returns {Object|null} If segment crosses a boundary, returns * `{ crosses: true, insideNodeId: number, outsideNodeId: number, bjPolygon: object }`. * If no crossing, returns `{ crosses: false, insideNodeId: null, outsideNodeId: null, bjPolygon: null }`. */ function ja_segment_crosses_bj_boundary(seg, allBigJunctions) { if (!seg || !allBigJunctions || allBigJunctions.length === 0) { return { crosses: false, insideNodeId: null, outsideNodeId: null, bjPolygon: null }; } var fromCoords = { id: seg.fromNodeId, coordinates: seg.geometry.coordinates[0] }; var toCoords = { id: seg.toNodeId, coordinates: seg.geometry.coordinates[seg.geometry.coordinates.length - 1] }; for (var bji = 0; bji < allBigJunctions.length; bji++) { var bjPolygon = turf.polygon(allBigJunctions[bji].geometry.coordinates); var fromInside = turf.booleanPointInPolygon(turf.point(fromCoords.coordinates), bjPolygon); var toInside = turf.booleanPointInPolygon(turf.point(toCoords.coordinates), bjPolygon); // If one endpoint inside and one outside, segment crosses JB boundary if ((fromInside && !toInside) || (!fromInside && toInside)) { return { crosses: true, insideNodeId: fromInside ? seg.fromNodeId : seg.toNodeId, outsideNodeId: toInside ? seg.fromNodeId : seg.toNodeId, bjPolygon: bjPolygon, }; } } return { crosses: false, insideNodeId: null, outsideNodeId: null, bjPolygon: null }; } /** * Returns true if a legal turn exists from s_from through via_node onto s_to. * * Delegates to sdk.DataModel.Turns.isTurnAllowed() for the base restriction check, * then applies additional filtering for time- and vehicle-restricted turns (date * ranges, vehicle type bitmasks) to reflect real-world drivability rather than * just the static restriction flag. * * @param {Object} s_from - SDK Segment object for the incoming road. * @param {Object} via_node - SDK Node object at the junction. * @param {Object} s_to - SDK Segment object for the outgoing road. * @returns {boolean} True if the turn is allowed for a typical passenger vehicle. */ function ja_is_turn_allowed(s_from, via_node, s_to) { if (!sdk.DataModel.Turns.isTurnAllowedBySegmentDirections({ fromSegmentId: s_from.id, nodeId: via_node.id, toSegmentId: s_to.id })) { ja_log('Turn ' + s_from.id + ' → ' + s_to.id + ' via ' + via_node.id + ': blocked (direction)', 3); return false; } var allowed = sdk.DataModel.Turns.isTurnAllowed({ fromSegmentId: s_from.id, nodeId: via_node.id, toSegmentId: s_to.id }); ja_log('Turn ' + s_from.id + ' → ' + s_to.id + ' via ' + via_node.id + ': ' + (allowed ? 'allowed' : 'blocked'), 3); return allowed; } /** * From wiki: * A Cross-match is when the primary name of one segment is identical to the alternate name of an adjacent segment. * It had the same priory as a Primary name match. In order for a Cross match to work there must be at least one * alt name on both involved segments (even though they don't necessarily match each other). It will work even if * the are no Primary names on those segments. It will not work if all three segments at a split have a matching * Primary name or a matching Alternate name. * @param street_in * @param streets * @returns {boolean} */ function ja_cross_name_match(street_in, streets) { ja_log('[cross_name_match] checking exit streets', 3); ja_log(street_in, 4); ja_log(streets, 4); return Object.getOwnPropertyNames(streets).some(function (street_n_id, index) { var street_n_element = streets[street_n_id]; ja_log('[cross_name_match] Checking element ' + index, 3); ja_log(street_n_element, 4); return ( street_in.secondary.some(function (street_in_secondary) { ja_log('CN2a: checking n.p: ' + street_n_element.primary.name + ' vs in.s: ' + street_in_secondary.name, 3); //wlodek76: CROSS-MATCH works when two compared segments contain at least one ALT NAME //when alt name is empty cross-match does not work //FZ69617: This no longer seems to be needed //if (street_n_element.secondary.length === 0) { return false; } return street_n_element.primary.name === street_in_secondary.name; }) || street_n_element.secondary.some(function (street_n_secondary) { ja_log('CN2b: checking in.p: ' + street_in.primary.name + ' vs n.s: ' + street_n_secondary.name, 3); //wlodek76: CROSS-MATCH works when two compared segments contain at least one ALT NAME //when alt name is empty cross-match does not work //FZ69617: This no longer seems to be needed //if (street_in.secondary.length === 0) { return false; } //wlodek76: missing return from checking primary name with alternate names return street_in.primary.name === street_n_secondary.name; }) ); }); } /** * Returns true if any segment in `streets` shares at least one alternate (secondary) name * with `street_in`. * * Both sides must have at least one alternate name — if either is empty the check short-circuits * to false, matching the WME routing behaviour (cross-match only works when both sides carry an * alt name). * * @param {{ primary: object, secondary: Array }} street_in - Street info of the inbound segment. * @param {Object.<string, { primary: object, secondary: Array }>} streets - Street info keyed by * segment id for all candidate exit segments at the junction. * @returns {boolean} True if an alt-name match is found. */ function ja_alt_name_match(street_in, streets) { return Object.getOwnPropertyNames(streets).some(function (street_n_id, index) { var street_n_element = streets[street_n_id]; ja_log('[alt_name_match] Checking element ' + index, 3); ja_log(street_n_element, 4); if (street_in.secondary.length === 0) { return false; } if (street_n_element.secondary.length === 0) { return false; } return street_in.secondary.some(function (street_in_secondary, index2) { ja_log('[alt_name_match] Nested check element ' + index2, 3); ja_log(street_in_secondary, 4); return street_n_element.secondary.some(function (street_n_secondary_element, index3) { ja_log('[alt_name_match] in.secondary: ' + street_in_secondary.name + ' vs n.secondary[' + index3 + ']: ' + street_n_secondary_element.name, 3); return street_in_secondary.name === street_n_secondary_element.name; }); }); }); } /** * Returns true if any segment in `streets` has the same primary name as `street_in`. * * Used as the first-pass name check in BC (best-continuation) routing logic: if the * incoming road name continues on an exit, that exit is a strong BC candidate. * * @param {{ primary: { name: string }, secondary: Array }} street_in - Street info of the * inbound segment. * @param {Object.<string, { primary: { name: string }, secondary: Array }>} streets - Street * info keyed by segment id for all candidate exit segments at the junction. * @returns {boolean} True if a primary-name match is found. */ function ja_primary_name_match(street_in, streets) { ja_log('[primary_name_match] checking candidates', 3); ja_log(street_in, 4); ja_log(streets, 4); return Object.getOwnPropertyNames(streets).some(function (id, index, array) { var element = streets[id]; ja_log('[primary_name_match] Checking element ' + index + ' of ' + array.length, 3); ja_log(element, 4); return element.primary.name === street_in.primary.name; }); } /** * Returns the primary and alternate street names for a segment. * * Looks up the segment's `primaryStreetId` and `alternateStreetIds` via the SDK Streets model * and returns them in a shape that `ja_primary_name_match`, `ja_cross_name_match`, and * `ja_alt_name_match` can consume directly. * * @param {number} segmentId - WME segment id. * @returns {{ primary: object|undefined, secondary: Array }} Object with `primary` set to the * SDK Street object (or undefined if none) and `secondary` as an array of SDK Street objects * for each alternate street. */ function ja_get_streets(segmentId) { var segment = sdk.DataModel.Segments.getById({ segmentId: segmentId }); var primary = segment && segment.primaryStreetId != null ? sdk.DataModel.Streets.getById({ streetId: segment.primaryStreetId }) : undefined; var secondary = []; if (segment) { segment.alternateStreetIds.forEach(function (element) { var street = sdk.DataModel.Streets.getById({ streetId: element }); if (street != null) { secondary.push(street); } }); } ja_log(primary, 3); ja_log(secondary, 3); return { primary: primary, secondary: secondary }; } /** * Computes segment's length in meters * @param segment Segment to compute the length of * @returns {number} */ function ja_segment_length(segment) { ja_log('segment: ' + segment.id + ' len: ' + segment.length, 3); return segment.length; } /** * Checks whether the two segments (connected at the same node) overlap each other. * @param a1 Angle of the 1st segment * @param a2 Angle of the 2nd segment */ function ja_overlapping_angles(a1, a2) { // If two angles are close < 2 degree they are overlapped. // Method of recognizing overlapped segment by server is unknown for me yet, I took this from WME Validator // information about this. // TODO: verify overlapping check on the side of routing server. return Math.abs(ja_angle_diff(a1, a2, true)) < OVERLAPPING_ANGLE; } /* * Misc math and map element functions */ /** * * @param p0 From point * @param p1 Center point * @param p2 To point * @returns {number} */ function ja_angle_between_points(p0, p1, p2) { ja_log('p0 ' + p0, 3); ja_log('p1 ' + p1, 3); ja_log('p2 ' + p2, 3); // Uses turf.distance for accurate WGS84 distances (inputs are GeoJSON Point geometries) var a2 = Math.pow(turf.distance(turf.point(p1.coordinates), turf.point(p0.coordinates)) * 1000, 2); var b2 = Math.pow(turf.distance(turf.point(p1.coordinates), turf.point(p2.coordinates)) * 1000, 2); var cc2 = Math.pow(turf.distance(turf.point(p2.coordinates), turf.point(p0.coordinates)) * 1000, 2); var angle = Math.acos((a2 + b2 - cc2) / Math.sqrt(4 * a2 * b2)) / (Math.PI / 180); ja_log('angle is ' + angle, 3); return angle; } /** * get absolute (or turn) angle between 2 inputs. * 0,90,true -> 90 0,90,false -> -90 * 0,170,true -> 170 0,170,false -> -10 * @param aIn absolute s_in angle (from node) * @param aOut absolute s_out angle (from node) * @param absolute return absolute or turn angle? * @returns {number} */ function ja_angle_diff(aIn, aOut, absolute) { var a = parseFloat(aOut) - parseFloat(aIn); if (a > 180) { a -= 360; } if (a < -180) { a += 360; } return absolute ? a : a > 0 ? a - 180 : a + 180; } /** * Returns the clockwise angular distance from `a` to `s_in_angle` (0–360°). * * Used to sort exit segments by how far they are from the incoming road's direction. * Wraps negative differences by adding 360 so the result is always non-negative. * * @param {number} a - The outbound segment angle (math degrees, 0=East CCW). * @param {number} s_in_angle - The inbound segment angle (math degrees, 0=East CCW). * @returns {number} Clockwise distance in degrees [0, 360). */ function ja_angle_dist(a, s_in_angle) { ja_log('Computing out-angle ' + a + ' distance to in-angle ' + s_in_angle, 4); var diff = ja_angle_diff(a, s_in_angle, true); ja_log('Diff is ' + diff + ', returning: ' + (diff < 0 ? diff + 360 : diff), 4); return diff < 0 ? diff + 360 : diff; } /** * Checks whether every exit of a roundabout is within ±PERPENDICULAR_TOLERANCE° of perpendicular (i.e. "normal"). * * For each valid exit node (a `toNodeId` of a junction arc that has at least one drivable * outbound non-junction segment), the triangle angle `n_in → roundabout-center → exit-node` * is computed. An exit is non-normal when `angle % 90` falls outside the [0°, PERPENDICULAR_TOLERANCE°] and * [90-PERPENDICULAR_TOLERANCE°, 90°] bands. For every non-normal exit a `±N°` deviation marker is placed just * outside the roundabout ring at that node. * * Side-effect: adds GeoJSON Point features to the `junction_angles` layer for each non-normal * exit. * * @param {number} junctionID - WME Junction id. * @param {number} n_in - Node id of the roundabout entry node (excluded from comparison so * the entry road is not mistaken for an exit). * @param {number} label_distance - Current label-distance in meters (used to offset the * deviation marker beyond the ring node). * @returns {boolean} True if all exits are within ±PERPENDICULAR_TOLERANCE° of perpendicular; false otherwise. */ function ja_is_roundabout_normal(junctionID, n_in, label_distance) { ja_log('Check normal roundabout', 3); var junction = sdk.DataModel.Junctions.getById({ junctionId: junctionID }); var nodes = {}; var numValidExits = 0; junction.segmentIds.forEach(function (element, index) { var s = sdk.DataModel.Segments.getById({ segmentId: element }); ja_log('index: ' + index, 3); //ja_log(s, 3); if (!nodes.hasOwnProperty(s.toNodeId)) { ja_log('Adding node id: ' + s.toNodeId, 3); //Check if node has allowed exits var allowed = false; var currNode = sdk.DataModel.Nodes.getById({ nodeId: s.toNodeId }); ja_log(currNode, 3); currNode.connectedSegmentIds.forEach(function (element2) { var s_exit = sdk.DataModel.Segments.getById({ segmentId: element2 }); ja_log(s_exit, 3); if (s_exit.junctionId === null) { ja_log('Checking: ' + s_exit.id, 3); if (sdk.DataModel.Turns.isTurnAllowedBySegmentDirections({ fromSegmentId: s.id, nodeId: currNode.id, toSegmentId: s_exit.id })) { //Exit possibly allowed ja_log('Exit allowed', 3); allowed = true; } else { ja_log('Exit not allowed', 3); } } else { //part of the junction.. Ignoring ja_log(s_exit.id + ' is in the roundabout. ignoring', 3); } }); if (allowed) { numValidExits++; nodes[s.toNodeId] = sdk.DataModel.Nodes.getById({ nodeId: s.toNodeId }); } } }); var is_normal = true; ja_log(n_in, 3); ja_log(junction, 3); ja_log(nodes, 3); for (var n in nodes) { if (nodes.hasOwnProperty(n)) { // for...in always yields string keys; SDK requires a number type var n_id = parseInt(n, 10); ja_log('Checking ' + n_id, 3); if (String(n) === String(n_in)) { ja_log('Not comparing to n_in ;)', 3); } else { var angle = ja_angle_between_points( sdk.DataModel.Nodes.getById({ nodeId: n_in }).geometry, ja_coordinates_to_point(junction.geometry.coordinates), sdk.DataModel.Nodes.getById({ nodeId: n_id }).geometry, ); ja_log('Angle is: ' + angle, 3); ja_log('Normalized angle is: ' + (angle % 90), 3); ja_log('Angle is: ' + angle, 3); // 90 +/- 15 is considered "normal" if (ja_is_angle_normal(angle)) { ja_log('turn is normal', 3); } else { ja_log('turn is NOT normal', 3); is_normal = false; //Push a marker outside the ring to show which exit is "not normal". //Offset 1× label_distance beyond the node along the radial (center→node) bearing. //Departure markers on the same exit road sit at 2× label_distance from the node, //so this leaves a full label_distance gap between the two markers. var n_geom = nodes[n].geometry; var center_coord = junction.geometry.coordinates; var bearing_out = turf.bearing(turf.point(center_coord), turf.point(n_geom.coordinates)); var ring_radius_km = turf.distance(turf.point(center_coord), turf.point(n_geom.coordinates)); var ja_ld = ja_corrected_ld(label_distance, n_geom.coordinates); var angleMod = Math.abs(angle % 90); var marker_geom = turf.destination(turf.point(center_coord), ring_radius_km + ja_ld / 1000, bearing_out).geometry; ja_add_feature(marker_geom, { angle: '±' + ja_round(Math.min(angleMod, 90 - angleMod)), ja_type: ja_routing_type.ROUNDABOUT, }); } } } } return is_normal; } /** * Draws exit-angle markers for all valid exits of a roundabout when only the entry segment * is selected (no specific exit node in the selection). * * Applies the full Waze Normal / Non-Normal roundabout instruction rules: * * Normal (all three criteria must be met for this entry): * 1. All exit angles within ±PERPENDICULAR_TOLERANCE° of a multiple of 90° (perpendicular exits) * 2. Total junction node count is 2–4 * 3. Roundabout radius ≤ 25 m * → Each exit is classified as Turn Right / Continue Straight / Turn Left / U-Turn * based on the counterclockwise angle from the entry bearing to the exit bearing * (measured at the roundabout center). Colors use the matching ja_routing_type. * * Non-Normal (any criterion fails): * → All exits are labeled "1st", "2nd", "3rd" … in the order they are encountered * when travelling counterclockwise from the entry, using ja_routing_type.ROUNDABOUT (the * "Non-Normal Exit Color" setting — roundaboutColor). * * CCW angle (degrees, 0–360) from entry to exit, measured at center: * ~90° → Turn Right (first exit encountered going CCW in right-hand traffic) * ~180° → Continue Straight * ~270° → Turn Left * ~0°/360° → U-Turn * * Also draws triangle-leg LineStrings (entry→center and center→each exit) for context. * * @param {number} junctionId - WME Junction id. * @param {number} entryNodeId - Node id where the selected entry segment meets the roundabout. * @param {number} label_distance - Current label-distance in meters (used to offset markers). */ function ja_draw_roundabout_entry_exits(junctionId, entryNodeId, label_distance) { ja_log('[RA-ENTRY] Called with junctionId=' + junctionId + ', entryNodeId=' + entryNodeId, 2); var junction = sdk.DataModel.Junctions.getById({ junctionId: junctionId }); if (!junction) { ja_log('[RA-ENTRY] Junction not found!', 2); return; } // Skip if entry node ID is null (can happen with unsaved segments) if (!entryNodeId) { ja_log('[RA-ENTRY] Entry node ID is null (unsaved segment?)', 2); return; } var entryNode = sdk.DataModel.Nodes.getById({ nodeId: entryNodeId }); if (!entryNode) { ja_log('[RA-ENTRY] Entry node not found!', 2); return; } var center = ja_coordinates_to_point(junction.geometry.coordinates); var centerPt = turf.point(center.coordinates); var entryPt = turf.point(entryNode.geometry.coordinates); // In LHT countries roundabouts flow clockwise (CW); RHT countries flow CCW. // This affects the order exits are encountered (and therefore ordinal numbering) // but NOT the instruction classification, which is purely geometric. // Compass bearing from roundabout center to the entry node. // Used to compute the CCW angle from entry to each exit. var bearingToEntry = turf.bearing(centerPt, entryPt); // Helper: English ordinal suffix for exit numbering ("1st", "2nd", "3rd", …) function ordinal(n) { var s = ['th', 'st', 'nd', 'rd']; var v = n % 100; return n + (s[(v - 20) % 10] || s[v] || s[0]); } // Draw circle overlay if configured if (ja_getOption('roundaboutOverlayDisplay') === 'rOverSelected') { ja_draw_roundabout_overlay(junctionId); } // Draw entry-leg: entry node → roundabout center ja_add_feature({ type: 'LineString', coordinates: [entryNode.geometry.coordinates, center.coordinates] }, { ja_type: 'arrow_line' }); // ── Step 1: Collect all valid exits ────────────────────────────────────── var processedNodes = {}; var exits = []; ja_log('[RA-ENTRY] Roundabout has ' + junction.segmentIds.length + ' segments', 2); junction.segmentIds.forEach(function (segId) { ja_log('[RA-ENTRY] Processing segment ' + segId, 3); var juncSeg = sdk.DataModel.Segments.getById({ segmentId: segId }); if (!juncSeg) return; var exitNodeId = juncSeg.toNodeId; // Skip segments with null node IDs (can happen with unsaved segments) if (!exitNodeId) return; // Allow the entry node once (U-turn arc) but deduplicate everything else. // We track with a count so a second arc returning to the same node is still skipped. if (processedNodes.hasOwnProperty(String(exitNodeId))) return; processedNodes[String(exitNodeId)] = true; var exitNode = sdk.DataModel.Nodes.getById({ nodeId: exitNodeId }); if (!exitNode) return; // Find the first exit segment at this node (not part of THIS roundabout, but may be part of another junction). // Validate that traffic can actually LEAVE the roundabout node (not one-way INTO it). var exitSeg = null; exitNode.connectedSegmentIds.forEach(function (connSegId) { if (exitSeg) return; var s = sdk.DataModel.Segments.getById({ segmentId: connSegId }); if (!s) return; // Skip segments that are part of THIS roundabout. Allow segments in other junctions or standalone. if (s.junctionId === junctionId) { ja_log('[RA-ENTRY] Skipping ' + connSegId + ' (part of this RA)', 3); return; } // Accept exit if it can leave this node. Reject only if it's explicitly one-way INTO the node. // Two-way segments (isAtoB !== isBtoA is false, meaning both true or both false) are always valid. // One-way FROM this node: (isAtoB && fromNodeId=this) OR (isBtoA && toNodeId=this) // One-way INTO this node (reject): (isAtoB && toNodeId=this) OR (isBtoA && fromNodeId=this) var isOneWayInto = (s.isAtoB && s.toNodeId === exitNodeId && !s.isBtoA) || (s.isBtoA && s.fromNodeId === exitNodeId && !s.isAtoB); if (isOneWayInto) { ja_log('[RA-ENTRY] Skipping ' + connSegId + ' (one-way INTO roundabout only)', 2); return; } // Check for locally-set turn restrictions at this exit. // Query all turns ending at the exit segment — if any are marked as not allowed, mark the exit as restricted. var arcPath = ja_get_roundabout_arc_path(junctionId, entryNodeId, exitNodeId); var isRestricted = false; if (arcPath) { isRestricted = ja_check_roundabout_arc_restricted(arcPath, s); } if (isRestricted) { ja_log('[RA-ENTRY] Exit ' + connSegId + ' has turn restriction, will display as NO_TURN', 2); s._isRestricted = true; } ja_log('[RA-ENTRY] Accepting exit ' + connSegId + (isRestricted ? ' (RESTRICTED)' : ''), 3); exitSeg = s; }); if (!exitSeg) { var debugSegs = 'connected segs: '; exitNode.connectedSegmentIds.forEach(function (cid) { var cs = sdk.DataModel.Segments.getById({ segmentId: cid }); if (cs) { debugSegs += cid + '(jID=' + (cs.junctionId || 'null') + ') '; } }); ja_log('[RA-ENTRY] Node ' + exitNodeId + ' has no valid exit. ' + debugSegs, 2); return; } // CCW angle (0–360°) from entry to this exit, measured at the roundabout center. // In right-hand traffic (CCW roundabout): ~90° = Turn Right, ~180° = Straight, ~270° = Turn Left. // U-turn arc returns to the entry node — assign 360 so it sorts last and falls in the ≥315 U-turn bucket. var ccwAngle; if (exitNodeId === entryNodeId) { ccwAngle = 360; } else { var bearingToExit = turf.bearing(centerPt, turf.point(exitNode.geometry.coordinates)); ccwAngle = (bearingToEntry - bearingToExit + 360) % 360; ja_log( '[RA-DEBUG] exitNodeId=' + exitNodeId + ', bearingToEntry=' + ja_round(bearingToEntry) + '°, bearingToExit=' + ja_round(bearingToExit) + '°, ccwAngle=' + ja_round(ccwAngle) + '° (LHT=' + ja_is_left_hand_traffic + ')', 2, ); } // Triangle angle at center: entry_node → center → exit_node (always 0–180°). // U-turn arc: entry and exit are the same node so the triangle is degenerate (0°). // Use 180° instead — the driver exits back along the same road in the opposite direction. var triAngle = exitNodeId === entryNodeId ? 180 : ja_angle_between_points(entryNode.geometry, center, exitNode.geometry); var isExitAngleNormal = ja_is_angle_normal(triAngle); // Skip exits with invalid angles (can happen with unsaved segments) if (isNaN(ccwAngle) || isNaN(triAngle)) { ja_log('[RA-ENTRY] Skipping exit with NaN angle: ccwAngle=' + ccwAngle + ', triAngle=' + triAngle, 2); return; } exits.push({ exitNodeId: exitNodeId, exitNode: exitNode, exitSeg: exitSeg, juncSeg: juncSeg, ccwAngle: ccwAngle, triAngle: triAngle, isExitAngleNormal: isExitAngleNormal, }); }); ja_log('[RA-ENTRY] Collected ' + exits.length + ' exits', 2); if (exits.length === 0) { ja_log('[RA-ENTRY] No exits found, returning', 2); return; } // ── Step 2: Determine overall roundabout normality for this entry ───────── // Criterion 1 – All exits within ±PERPENDICULAR_TOLERANCE° of a 90° multiple var allAnglesNormal = exits.every(function (e) { return e.isExitAngleNormal; }); // Criterion 2 – Total junction node count 2–4 var junctionNodeSet = {}; junction.segmentIds.forEach(function (segId) { var s = sdk.DataModel.Segments.getById({ segmentId: segId }); // Skip segments with null node IDs (unsaved segments) if (s && s.toNodeId) junctionNodeSet[String(s.toNodeId)] = true; }); var totalJunctionNodes = Object.keys(junctionNodeSet).length; var isNodeCountNormal = totalJunctionNodes >= 2 && totalJunctionNodes <= 4; // Criterion 3 – Maximum distance from center to any junction node ≤ 25 m var maxRadius = 0; Object.keys(junctionNodeSet).forEach(function (nid) { var n = sdk.DataModel.Nodes.getById({ nodeId: parseInt(nid, 10) }); if (!n) return; var r = turf.distance(centerPt, turf.point(n.geometry.coordinates)) * 1000; // km→m if (r > maxRadius) maxRadius = r; }); var isRadiusNormal = maxRadius <= 25; var isRoundaboutNormal = allAnglesNormal && isNodeCountNormal && isRadiusNormal; ja_log('Roundabout normal: ' + isRoundaboutNormal + ' (angles:' + allAnglesNormal + ' nodes:' + totalJunctionNodes + ' radius:' + ja_round(maxRadius) + 'm)', 2); ja_log('[RA-DEBUG] All exits before sorting:', 4); exits.forEach(function (e, idx) { ja_log('[RA-DEBUG] Exit ' + idx + ': nodeId=' + e.exitNodeId + ', ccwAngle=' + ja_round(e.ccwAngle) + '°, triAngle=' + ja_round(e.triAngle) + '°', 2); }); // ── Center diameter marker ───────────────────────────────────────────────── // Shows the roundabout's diameter (maxRadius × 2) at the center point. // White = radius ≤ 25 m (Normal criterion met); Orange = radius > 25 m (Non-Normal). var diameterM = ja_round(maxRadius * 2); var diameterLabel = ja_getOption('angleDisplay') === 'displaySimple' ? '\u00d8' + diameterM + 'm' : '\u00d8\n' + diameterM + 'm'; ja_add_feature(center, { angle: diameterLabel, ja_type: isRadiusNormal ? ja_routing_type.BC : ja_routing_type.ROUNDABOUT, }); // ── Step 3: Sort exits by CCW angle (order encountered going CCW from entry) ── // RHT (CCW roundabout): first exit encountered has smallest ccwAngle → sort ascending. // LHT (CW roundabout): first exit encountered has largest ccwAngle → sort descending. exits.sort( ja_is_left_hand_traffic ? function (a, b) { return b.ccwAngle - a.ccwAngle; } : function (a, b) { return a.ccwAngle - b.ccwAngle; }, ); // For LHT, after descending sort, the U-turn (ccwAngle=360) sorts first but should be last. // Move it to the end if it's at index 0. if (ja_is_left_hand_traffic && exits.length > 0 && exits[0].ccwAngle === 360) { var uTurnExit = exits.shift(); // Remove from front exits.push(uTurnExit); // Add to back ja_log('[RA-DEBUG] Moved U-turn from index 0 to end (LHT handling)', 2); } ja_log('[RA-DEBUG] After sort (LHT=' + ja_is_left_hand_traffic + '):', 2); exits.forEach(function (e, idx) { ja_log('[RA-DEBUG] Exit ' + idx + ': nodeId=' + e.exitNodeId + ', ccwAngle=' + ja_round(e.ccwAngle) + '°', 2); }); // ── Step 4: Draw exit legs and markers ─────────────────────────────────── var validExitOrdinal = 0; // Counter for non-normal roundabouts (skips restricted exits) exits.forEach(function (exit, index) { // Draw exit leg: roundabout center → exit node ja_add_feature({ type: 'LineString', coordinates: [center.coordinates, exit.exitNode.geometry.coordinates] }, { ja_type: 'arrow_line' }); var exitBearing = ja_getAngle(exit.exitNodeId, exit.exitSeg); var exitLd = ja_corrected_ld(label_distance, exit.exitNode.geometry.coordinates); var point = turf.destination(turf.point(exit.exitNode.geometry.coordinates), (exitLd * 2) / 1000, ja_math_to_compass(exitBearing)).geometry; // Check if this exit has a turn restriction var isRestricted = exit.exitSeg._isRestricted === true; var markerType; if (isRestricted) { // Restricted exit: always display as NO_TURN (gray) markerType = ja_routing_type.NO_TURN; ja_log('[RA-DEBUG] Drawing restricted exit ' + index + ': nodeId=' + exit.exitNodeId + ', markerType=NO_TURN', 2); ja_draw_marker(point, exit.exitNode, exitLd, exit.triAngle, exitBearing, true, markerType); } else if (isRoundaboutNormal) { // Normal roundabout with allowed exit: classify by CCW angle from entry // ~90° → Turn Right (first exit going CCW) // ~180° → Continue Straight // ~270° → Turn Left (last exit before U-turn) // ~0°/360° → U-Turn var ccw = exit.ccwAngle; if (ccw < ROUNDABOUT_INSTRUCTION_UTURN_THRESHOLD || ccw >= ROUNDABOUT_INSTRUCTION_TURN_LEFT_THRESHOLD) { markerType = ja_routing_type.U_TURN; } else if (ccw < ROUNDABOUT_INSTRUCTION_TURN_RIGHT_THRESHOLD) { markerType = ja_routing_type.TURN_RIGHT; } else if (ccw < ROUNDABOUT_INSTRUCTION_CONTINUE_THRESHOLD) { markerType = ja_routing_type.BC; // Continue Straight } else { markerType = ja_routing_type.TURN_LEFT; } ja_log('[RA-DEBUG] Drawing exit ' + index + ': nodeId=' + exit.exitNodeId + ', ccw=' + ja_round(ccw) + '°, markerType=' + markerType, 2); // ja_draw_marker handles arrow characters and display-mode formatting, // exactly as it does for regular turn markers at intersections. ja_draw_marker(point, exit.exitNode, exitLd, exit.triAngle, exitBearing, true, markerType); } else { // Non-normal roundabout: ordinal exit numbers in encounter order (skipping restricted exits) // Only increment counter for allowed exits; restricted exits get NO_TURN marker validExitOrdinal++; ja_log('[RA-DEBUG] Drawing non-normal exit ' + index + ': nodeId=' + exit.exitNodeId + ', ordinal=' + validExitOrdinal, 2); // Direct feature add — ordinal string can't pass through ja_draw_marker's numeric 'a'. ja_add_feature(point, { angle: ja_getOption('angleDisplay') === 'displaySimple' ? ordinal(validExitOrdinal) + ' ' + ja_round(exit.triAngle) + '°' : ordinal(validExitOrdinal) + '\n' + ja_round(exit.triAngle) + '°', ja_type: ja_routing_type.ROUNDABOUT, // "Non-Normal Exit Color" (roundaboutColor) setting }); } }); } /** * Constructs the sequence of roundabout arc segments from entry node to exit node. * * Walks through the junction's arc segments starting at entryNodeId and following * connected nodes until reaching exitNodeId. Returns the ordered list of segments * that comprise the arc path (used for path traversal restriction checking). * * @param {number} junctionId - WME Junction ID (roundabout). * @param {number} entryNodeId - Starting node ID. * @param {number} exitNodeId - Ending node ID. * @returns {Object[]|null} Array of SDK Segment objects forming the path, or null if path cannot be constructed. */ function ja_get_roundabout_arc_path(junctionId, entryNodeId, exitNodeId) { var junction = sdk.DataModel.Junctions.getById({ junctionId: junctionId }); if (!junction) return null; var path = []; var currentNodeId = entryNodeId; var visited = {}; var maxSteps = junction.segmentIds.length + 1; // Prevent infinite loops for (var step = 0; step < maxSteps && currentNodeId !== exitNodeId; step++) { var nextSeg = null; // Find the next unvisited segment connected to currentNodeId for (var i = 0; i < junction.segmentIds.length; i++) { var segId = junction.segmentIds[i]; if (visited[String(segId)]) continue; var seg = sdk.DataModel.Segments.getById({ segmentId: segId }); if (!seg) continue; if (seg.fromNodeId === currentNodeId) { nextSeg = seg; currentNodeId = seg.toNodeId; break; } else if (seg.toNodeId === currentNodeId) { nextSeg = seg; currentNodeId = seg.fromNodeId; break; } } if (!nextSeg) break; visited[String(nextSeg.id)] = true; path.push(nextSeg); } return currentNodeId === exitNodeId ? path : null; } /** * Checks for explicit local turn restrictions at a junction node. * * For roundabout arc segments, we check ONLY for explicit turn restrictions * without performing direction calculation (which has LHT quirks for arc segments). * This checks the Turn object's restrictions array to see if an editor set a local TR. * * @param {Object} s_from - SDK Segment object for the incoming road. * @param {Object} via_node - SDK Node object at the junction. * @param {Object} s_to - SDK Segment object for the outgoing road. * @returns {boolean} True if a turn restriction explicitly blocks this turn. */ function ja_is_turn_restricted(s_to) { try { // Query all turns ending at the exit segment and check if ANY are restricted. // This avoids depending on exact arc path construction — we just need to know // if there's a restricted turn to this exit from ANY arc segment. var turnsTo = sdk.DataModel.Turns.getTurnsToSegment({ segmentId: s_to.id }); if (turnsTo && turnsTo.length > 0) { for (var j = 0; j < turnsTo.length; j++) { var turn = turnsTo[j]; // If ANY turn to this exit is restricted (isAllowed=false or has restrictions), mark the whole exit as restricted if (!turn.isAllowed || (turn.restrictions && turn.restrictions.length > 0)) { ja_log('[RA-PATH-RESTRICT] Exit ' + s_to.id + ' is restricted (turn ' + turn.id + ')', 3); return true; } } } return false; // No restricted turns found } catch (e) { ja_log('[RA-PATH-RESTRICT] Error checking exit ' + s_to.id + ': ' + e.message, 2); return false; } } /** * Validates turn restrictions along a roundabout arc path by checking each intermediate node. * * Replicates the far-turn path validation pattern: walks through arc segments and validates * that a turn is allowed at each connecting node. If ANY intermediate turn is restricted, * the entire arc path is marked as restricted. * * @param {Object[]} arcPath - Array of arc segments (from ja_get_roundabout_arc_path). * @param {Object} exitSegment - The exit segment (where traffic leaves the roundabout). * @returns {boolean} true if ANY step in the path is restricted, false if all steps allowed. */ function ja_check_roundabout_arc_restricted(arcPath, exitSegment) { if (!arcPath || arcPath.length === 0 || !exitSegment) { ja_log('[RA-PATH-CHECK] Invalid input: arcPath=' + (arcPath ? arcPath.length : 'null') + ', exitSeg=' + (exitSegment ? 'yes' : 'null'), 2); return false; } // Build the full sequence: [arcSeg1, ..., arcSegN, exitSeg] var fullPath = arcPath.concat([exitSegment]); // For roundabout arcs, we only check the FINAL step (arc→exit) for restrictions. // Intermediate arc→arc turns are structural and don't have explicit restrictions that affect traffic flow. // The only place an editor would set a local restriction is at the exit point. var finalStepIndex = fullPath.length - 2; if (finalStepIndex >= 0) { var stepFrom = fullPath[finalStepIndex]; var stepTo = fullPath[finalStepIndex + 1]; // Find the connecting node between these two segments var stepConnectingNodeId = ja_get_connecting_node(stepFrom, stepTo); if (stepConnectingNodeId === null) { return true; // Segments not adjacent } // Fetch the node (defensive check) var stepConnectingNode = sdk.DataModel.Nodes.getById({ nodeId: stepConnectingNodeId }); if (!stepConnectingNode) { return true; // Node not found } // Check for explicit turn restrictions at this exit return ja_is_turn_restricted(stepTo); } return false; } /** * Wraps a raw `[lon, lat]` coordinate pair into a minimal GeoJSON Point geometry object. * * The WME Junction geometry stores coordinates as a plain array, but Turf.js helper functions * like `turf.distance()` and `turf.bearing()` require GeoJSON geometry objects. This avoids * the overhead of `turf.point()` when only the geometry (not the full Feature wrapper) is * needed. * * @param {number[]} coordinates - `[longitude, latitude]` pair (WGS84). * @returns {{ type: 'Point', coordinates: number[] }} GeoJSON Point geometry. */ function ja_coordinates_to_point(coordinates) { return { type: 'Point', coordinates: [coordinates[0], coordinates[1]] }; } /** * Returns the first `[lon, lat]` coordinate of a segment's GeoJSON LineString geometry. * Used with `ja_get_second_point` to compute the bearing at the segment's start end. * @param {object} segment - SDK Segment object with a GeoJSON `geometry` property. * @returns {number[]} `[longitude, latitude]` WGS84 pair. */ function ja_get_first_point(segment) { return segment.geometry.coordinates[0]; } /** * Returns the last `[lon, lat]` coordinate of a segment's GeoJSON LineString geometry. * Used with `ja_get_next_to_last_point` to compute the bearing at the segment's end end. * @param {object} segment - SDK Segment object with a GeoJSON `geometry` property. * @returns {number[]} `[longitude, latitude]` WGS84 pair. */ function ja_get_last_point(segment) { return segment.geometry.coordinates[segment.geometry.coordinates.length - 1]; } /** * Returns the second `[lon, lat]` coordinate of a segment's GeoJSON LineString geometry. * Used together with `ja_get_first_point` to get the initial bearing leaving the start node. * @param {object} segment - SDK Segment object with a GeoJSON `geometry` property. * @returns {number[]} `[longitude, latitude]` WGS84 pair. */ function ja_get_second_point(segment) { return segment.geometry.coordinates[1]; } /** * Returns the second-to-last `[lon, lat]` coordinate of a segment's GeoJSON LineString. * Used together with `ja_get_last_point` to get the final bearing arriving at the end node. * @param {object} segment - SDK Segment object with a GeoJSON `geometry` property. * @returns {number[]} `[longitude, latitude]` WGS84 pair. */ function ja_get_next_to_last_point(segment) { return segment.geometry.coordinates[segment.geometry.coordinates.length - 2]; } /** * Returns the absolute departure angle for a segment end connected at a given node. * * Picks the first two coordinates (from-end) or last two (to-end) depending on which node * is the query node, then converts the Turf.js compass bearing (0=N, clockwise) into the * math-convention angle (0=East, counter-clockwise) used throughout this script. * * Uses the first/second or next-to-last/last vertex pair so the angle reflects the immediate * direction of the road as it leaves the node rather than the straight-line segment direction. * * @param {number|null} ja_node - WME Node id of the junction being measured. * @param {object|null} ja_segment - SDK Segment object whose departure bearing is needed. * @returns {number|null} Angle in math degrees (0=East CCW), or null if either argument is * null. */ function ja_getAngle(ja_node, ja_segment) { ja_log('[getAngle] node: ' + ja_node, 3); ja_log('[getAngle] segment: ' + ja_segment, 3); if (ja_node == null || ja_segment == null) { return null; } var p1, p2; if (ja_segment.fromNodeId === ja_node) { p1 = ja_get_first_point(ja_segment); p2 = ja_get_second_point(ja_segment); } else { p1 = ja_get_last_point(ja_segment); p2 = ja_get_next_to_last_point(ja_segment); } // turf.bearing returns compass bearing (0=N, CW); convert to math angle (0=E, CCW) var bearing = turf.bearing(turf.point(p1), turf.point(p2)); return (90 - bearing + 360) % 360; } /** * Returns the overall bearing of a segment (first vertex → last vertex) as a math angle. * * Unlike `ja_getAngle` which uses the immediate endpoint-adjacent vertex pair, * `ja_getAngleMidleSeg` uses the full start-to-end chord. This prevents false-positive * overlapping-angle matches on curved segments whose start bearing closely parallels an * adjacent segment even though the roads diverge over their full length. * * @param {number|null} ja_node - WME Node id used to determine direction of travel (from-end * or to-end). * @param {object|null} ja_segment - SDK Segment object. * @returns {number|null} Angle in math degrees (0=East CCW), or null if either argument is * null. */ function ja_getAngleMidleSeg(ja_node, ja_segment) { ja_log('[getAngleMidleSeg] node: ' + ja_node, 3); ja_log('[getAngleMidleSeg] segment: ' + ja_segment, 3); if (ja_node == null || ja_segment == null) { return null; } var p1, p2; if (ja_segment.fromNodeId === ja_node) { p1 = ja_get_first_point(ja_segment); p2 = ja_get_last_point(ja_segment); } else { p1 = ja_get_last_point(ja_segment); p2 = ja_get_first_point(ja_segment); } // turf.bearing returns compass bearing (0=N, CW); convert to math angle (0=E, CCW) var bearing = turf.bearing(turf.point(p1), turf.point(p2)); return (90 - bearing + 360) % 360; } // ── Far turn support (experimental) ────────────────────────────────────────────────────────── // // The two functions below add support for "far turns" — turns that cross one or more // intermediate segments rather than connecting directly across a single junction node. // // Waze exposes far turns on the SDK Turn interface via: // turn.isPathTurn — true when created with the Paths (FL2) tool // turn.isJunctionBoxTurn — true when inside a Junction Box (BigJunction) // turn.segmentPath[] — array of intermediate segment IDs (excludes entry & exit segments) // // The two types are mutually exclusive: a segment cannot be part of both a Junction Box // and a Path simultaneously. /** * Finds the junction node shared between two adjacent segments. * * This helper is needed specifically for far turn angle calculation: the exit segment * of a far turn is NOT directly connected to the entry node. Instead the path runs: * * entrySegment → [segmentPath[0] ... segmentPath[N]] → exitSegment * * To get the correct departure bearing of exitSegment we need the node where the last * intermediate segment (segmentPath[N]) hands off to exitSegment. That node is the * shared endpoint between those two segments — which is what this function finds. * * Usage: * var lastPathSeg = sdk.DataModel.Segments.getById({ segmentId: turn.segmentPath[turn.segmentPath.length - 1] }); * var connectingNode = ja_get_connecting_node(lastPathSeg, exitSeg); * var exitAngle = ja_getAngle(connectingNode, exitSeg); * * If the two segments do not share a node (e.g. bad data or disconnected path), returns null. * ja_getAngle() safely handles null and returns null in that case too. * * @param {object} segA - SDK Segment object (the last intermediate segment in segmentPath[]). * @param {object} segB - SDK Segment object (the exit segment of the far turn). * @returns {number|null} The shared node ID, or null if no shared node exists. */ function ja_get_connecting_node(segA, segB) { if (segA == null || segB == null) return null; // Each segment has exactly two endpoint nodes (fromNodeId, toNodeId). // One of segA's endpoints must equal one of segB's endpoints where they connect. if (segA.fromNodeId === segB.fromNodeId || segA.fromNodeId === segB.toNodeId) return segA.fromNodeId; if (segA.toNodeId === segB.fromNodeId || segA.toNodeId === segB.toNodeId) return segA.toNodeId; return null; // segments are not adjacent — should not happen with valid SDK data } /** * Maps a turn.instructionOpCode to a ja_routing_type Override* value. * Returns null if the opcode is unrecognised — callers fall through to angle-based classification. * * @param {string} opcode - The turn.instructionOpCode value (e.g., 'TURN_LEFT', 'NONE', 'UTURN'). * @param {boolean} logOpcode - If true, log the recognized opcode (default: true). * @returns {string|null} The mapped ja_routing_type value (OverrideTURN_LEFT, OverrideBC, etc.) or null if unrecognised. */ function ja_opcode_to_routing_type(opcode, logOpcode) { if (typeof logOpcode === 'undefined') logOpcode = true; var result = null; switch (opcode) { case 'NONE': result = ja_routing_type.OverrideBC; break; case 'CONTINUE': result = ja_routing_type.OverrideCONTINUE; break; case 'TURN_LEFT': result = ja_routing_type.OverrideTURN_LEFT; break; case 'TURN_RIGHT': result = ja_routing_type.OverrideTURN_RIGHT; break; case 'KEEP_LEFT': result = ja_routing_type.OverrideKEEP_LEFT; break; case 'KEEP_RIGHT': result = ja_routing_type.OverrideKEEP_RIGHT; break; case 'EXIT_LEFT': result = ja_routing_type.OverrideEXIT_LEFT; break; case 'EXIT_RIGHT': result = ja_routing_type.OverrideEXIT_RIGHT; break; case 'UTURN': result = ja_routing_type.OverrideU_TURN; break; } // Single log: opcode recognized or not if (logOpcode) { ja_log('Turn opcode override: ' + (result ? opcode : 'none'), 3); } return result; } /** * Classifies a potential U-turn angle, applying Waze double-turn restrictions. * Used in ja_collect_double_turns to identify U-turns with or without Waze restrictions. * * Checks conditions in order: * 1. DEFAULT: Median qualifies (≤30m OR 31-50m with lane guidance) AND segments are parallel (±5°) * 2. OPTIONAL STRICTER: If setting is ON and median ≤15m, blocks the turn * * If angle is NOT in U-turn range (175 ± 1.5°), returns null (not a U-turn). * * @param {number} angle - The turn angle in degrees. * @param {number} medianLen - The length of the median segment (meters). * @param {object} segA - First connecting segment (SDK Segment). * @param {object} segC - Second connecting segment (SDK Segment). * @param {number} nodeA_id - Node ID at start of median. * @param {number} nodeC_id - Node ID at end of median. * @param {boolean} hasLaneGuidanceOnA - True if incoming segment A has lane guidance toward the median. * @returns {string|null} ja_routing_type.NO_U_TURN, ja_routing_type.U_TURN, or ja_routing_type.PROBLEM; null if not in U-turn range or doesn't qualify. */ function ja_classify_uturn_angle(angle, medianLen, segA, segC, nodeA_id, nodeC_id, hasLaneGuidanceOnA) { // Check if angle is in U-turn range (175 ± 1.5°) if (angle < 175 - GRAY_ZONE || angle > 185 + GRAY_ZONE) { return null; // Not a U-turn angle } // Check if median qualifies by length (default or extended with lane guidance) var medianQualifies = medianLen <= WAZE_MEDIAN_LENGTH_DEFAULT || (medianLen <= WAZE_MEDIAN_LENGTH_EXTENDED && hasLaneGuidanceOnA); if (!medianQualifies) { return null; // Median too long to qualify as U-turn } // Check if segments A and C are parallel (±5°) var segmentsParallel = ja_is_segments_parallel(segA, segC, nodeA_id, nodeC_id, WAZE_PARALLELISM_TOLERANCE); if (!segmentsParallel) { return null; // Not parallel; doesn't qualify as U-turn } var turn_type; // Apply optional stricter Waze restriction (≤15m threshold; parallelism already verified above) if (ja_getOption('wazeDoubleUTurnRestriction') && medianLen <= WAZE_MEDIAN_LENGTH_THRESHOLD) { turn_type = ja_routing_type.NO_U_TURN; ja_log('Waze restriction: median ≤' + WAZE_MEDIAN_LENGTH_THRESHOLD + 'm and parallel within ' + WAZE_PARALLELISM_TOLERANCE + '°, flagged as NO_U_TURN', 2); } else { // Qualifies as U-turn by default rules (≤30m or 31-50m with LG, and parallel); angle determines the exact type turn_type = angle >= 175 + GRAY_ZONE && angle <= 185 - GRAY_ZONE ? ja_routing_type.U_TURN : ja_routing_type.PROBLEM; } return turn_type; } /** * Finds the intersection point between a segment and a BigJunction polygon boundary, * returning the point closest to a reference node. * Used in ja_draw_node_markers and ja_draw_far_turn_markers to reposition markers * when an exit segment crosses a JB boundary. * * @param {object} segment - The SDK Segment object (has geometry.coordinates). * @param {object} bjPolygon - The BigJunction polygon GeoJSON object. * @param {object|number[]} refPoint - Reference point (SDK Node with .geometry.coordinates or raw coordinates array [lon, lat]). * @returns {object|null} GeoJSON Point feature of the closest intersection, or null if no intersection found. */ function ja_find_closest_bj_intersection(segment, bjPolygon, refPoint) { var exitLine = turf.lineString(segment.geometry.coordinates); var intersections = turf.lineIntersect(exitLine, bjPolygon); if (intersections.features.length === 0) { return null; } // Determine reference coordinates var refCoords; if (refPoint.geometry && refPoint.geometry.coordinates) { // refPoint is a Node object refCoords = refPoint.geometry.coordinates; } else if (Array.isArray(refPoint)) { // refPoint is raw [lon, lat] array refCoords = refPoint; } else { // refPoint is assumed to have coordinates refCoords = refPoint.coordinates || refPoint; } var referencePt = turf.point(refCoords); var closestPt = intersections.features.reduce(function (best, candidate) { return turf.distance(candidate, referencePt) < turf.distance(best, referencePt) ? candidate : best; }); return closestPt; } /** * Determines if two compass bearings point in similar directions within a tolerance. * * Used to detect when local turn markers and far-turn markers target the same direction * at a node, allowing the positioning system to layer them (local closer, far-turn farther). * * Accounts for 360° wraparound: e.g., 10° vs 350° differ by 20°, not 340°. * * @param {number} bearing1 - First compass bearing (0–360°, 0=North, CW). * @param {number} bearing2 - Second compass bearing (0–360°). * @param {number} tolerance - Maximum angle difference in degrees (suggested: 30–45°). * @returns {boolean} True if bearings are within tolerance of each other. */ function ja_markers_target_same_direction(bearing1, bearing2, tolerance) { var diff = Math.abs(bearing1 - bearing2); if (diff > 180) { diff = 360 - diff; // Account for 360° wraparound } return diff <= tolerance; } /** * Converts a math angle (0=East, CCW) to a compass bearing (0=North, CW) for use with Turf.js. * Turf functions like turf.destination() expect compass bearings, not math angles. * Used in marker positioning throughout ja_draw_node_markers and ja_draw_far_turn_markers. * * @param {number} angle - The math angle in degrees (0=East, increases CCW). * @returns {number} Compass bearing in degrees (0=North, increases CW). */ function ja_math_to_compass(angle) { return (90 - angle + 360) % 360; } /** * Computes the extra-space multiplier for marker visibility based on angle and bearing. * Returns 2 (double distance) when angle is sharp (>120°) or bearing points upward (40-120°). * Used in marker positioning to avoid overlap with bridge/bridge icons. * * @param {number} angle - The angle measurement (turn angle or step angle in degrees). * @param {number} bearing - The compass or reference bearing for visibility (degrees). * @returns {number} Multiplier: 1 (normal spacing) or 2 (double spacing for visibility). */ function ja_compute_extra_space(angle, bearing) { // Double spacing if angle is sharp (>120°) if (Math.abs(angle) > 120) { return 2; } // Double spacing if bearing points upward (40-120°) to avoid bridge icon if (bearing > 40 && bearing < 120) { return 2; } return 1; } /** * Classifies a turn angle into a routing instruction type using angle-based thresholds. * Does NOT apply TIO/VIO overrides — used for intermediate step classification where * local node angles determine turn type. * * @param {number} angle - The turn angle in degrees (can be negative or >360). * @returns {string} A ja_routing_type value (BC, TURN, U_TURN, PROBLEM). */ function ja_classify_turn_angle(angle) { if (angle == null) return ja_routing_type.TURN; var absAngle = Math.abs(angle); if (absAngle > U_TURN_ANGLE + GRAY_ZONE) { return ja_routing_type.U_TURN; } else if (absAngle > U_TURN_ANGLE - GRAY_ZONE) { return ja_routing_type.PROBLEM; } else if (absAngle >= TURN_ANGLE - GRAY_ZONE) { return ja_routing_type.TURN; } else { return ja_routing_type.BC; } } /** * Determines the routing instruction type for the FINAL step of a far turn (JB or Path). * Applies turn.instructionOpCode override (if present), checks exit restriction, and * falls back to angle-based classification. * * Used only for the final marker in a breadcrumb trail for both Junction Box and Path turns; * intermediate steps use ja_classify_turn_angle() directly without override. * * @param {object} turn - The SDK Turn object (contains instructionOpCode, fromSegmentId, toSegmentId). * @param {object} connectingNode - The SDK Node where lastPathSeg hands off to exitSeg. * @param {number} lastPathSegId - ID of the last intermediate segment. * @param {object} lastPathSeg - The SDK Segment object for lastPathSegId. * @param {object} exitSeg - The SDK Segment object for the exit segment (turn.toSegmentId). * @param {number} localStepAngle - The angle at the connecting node (fallback if guess fails). * @returns {string} A ja_routing_type value for styling/display. */ function ja_get_final_step_type(turn, connectingNode, lastPathSegId, lastPathSeg, exitSeg, localStepAngle) { // Step 1: Check for TIO/VIO override (turn.instructionOpCode) var opcode = turn.instructionOpCode || null; if (opcode) { var opcodeType = ja_opcode_to_routing_type(opcode, false); if (opcodeType !== null) { return opcodeType; } } // Step 2: Check if exit is restricted (local node turn restriction) if (!ja_is_turn_allowed(lastPathSeg, connectingNode, exitSeg)) { ja_log('[FAR-TURNS] Final step blocked by turn restriction', 2); return ja_routing_type.NO_TURN; } // Step 3: Use ja_guess_routing_instruction at connecting node (full classification) if (connectingNode) { // Build angles array for ja_guess_routing_instruction var guessAngles = []; connectingNode.connectedSegmentIds.forEach(function (cSegId) { var cSeg = sdk.DataModel.Segments.getById({ segmentId: cSegId }); var cAngle = ja_getAngle(connectingNode.id, cSeg); if (cAngle != null) { guessAngles.push([cAngle, cSegId, false]); } }); var guessed = ja_guess_routing_instruction(connectingNode, lastPathSegId, exitSeg.id, guessAngles); if (guessed !== ja_routing_type.NO_TURN) { return guessed; } } // Step 4: Fallback to angle-based classification return ja_classify_turn_angle(localStepAngle); } /** * Draws angle markers for "far turns" — turns that cross multiple segments rather than * connecting directly at a single junction node. * * This function handles two Waze feature types that both appear as far turns in the SDK: * * PATH TURNS (turn.isPathTurn === true) * ────────────────────────────────────── * Created by editors using the Paths tool (also known as "far lanes phase 2" / FL2). * Paths exist solely to provide better lane guidance and turn instructions to drivers. * They CANNOT affect routing — the routing server ignores them entirely. * They CAN be restricted (new feature in WME). Restricted Path turns display as gray (NO_TURN). * Controlled by: enableFarTurnPath experimental setting (disabled by default). * * JUNCTION BOX TURNS (turn.isJunctionBoxTurn === true) * ───────────────────────────────────────────────────── * Created when a Junction Box (BigJunction polygon) is drawn over a complex intersection. * Junction Box turns CAN be restricted (red/yellow arrows in WME editor). * They DO affect routing and collect per-path speed data. * This function checks turn.isAllowed and displays restricted JB paths as gray (NO_TURN). * Controlled by: enableFarTurnJB experimental setting (disabled by default). * * ANGLE CALCULATION APPROACH * ────────────────────────── * The angle shown is the INSTRUCTION-FIRING angle — the local heading change at the first * node along the path where the turn is NOT Best Continuation (straight). * * Algorithm (see "INSTRUCTION-FIRING ANGLE SEARCH" block inside the forEach below): * * Step 1: Compute angle at entry node (fromSeg → segmentPath[0]) * Step 2: Compute angle at connecting node (lastPathSeg → toSeg) * • Use step 1 if |step1| > BC_THRESHOLD (10°) — instruction fires at entry node * • Else use step 2 if |step2| > BC_THRESHOLD — instruction fires at connecting node * • Fall back to step 1 if both are below threshold (both straight) * * Why not the net entry→exit angle? * The net angle across the entire path is geometrically correct but is NOT what Waze uses for the * voice prompt. Waze fires at the first meaningful turn node, which typically produces a clearer, * more actionable turn angle. * * Why not always use the entry node? * When the entry segment continues STRAIGHT onto the first intermediate segment (straight geometry, * ~0-5°), the instruction fires further along at the connecting node where the real heading change * occurs. This produces more accurate turn angles than using the entry node alone. * * LABEL PLACEMENT * ─────────────── * Marker placement (the ★ boundary point and ha direction) always uses the connecting node * and the exit segment's departure bearing — this is unchanged regardless of which node * the instruction fires at. The angle VALUE changes; the position does not. * * @param {object} node - The SDK Node object at which far turns originate. * We query turns from each segment connected to this * node and filter to those whose fromSegment touches it. * @param {number} ja_label_distance - Label placement distance in metres, computed by * ja_compute_label_distance() based on zoom level. * @param {number[]} ja_selected_seg_ids - IDs of the currently selected segments. Far turns * are only drawn for entry segments in this list. When * empty (node selection), all entry segments are shown. * @param {Array} angles - The angles array from ja_draw_node_markers() for this node. * Format: [[bearing, segmentId, isSelected], ...] for all * segments connected to node. Passed to * ja_guess_routing_instruction() so far-turn classification * uses the same KEEP/EXIT/TURN thresholds as regular turns. */ function ja_draw_far_turn_markers(node, ja_label_distance, ja_selected_seg_ids, allBigJunctions) { ja_log('[FAR-TURNS] Processing node ' + node.id + ' (' + node.connectedSegmentIds.length + ' segments)', 4); // WHY getTurnsFromSegment instead of getTurnsThroughNode: // getTurnsThroughNode only returns turns where BOTH the entry and exit segment connect // at the same node — i.e., standard direct turns. Far turns (JB turns, path turns) have // an exit segment that is NOT directly connected to the entry node, so they are not // returned by getTurnsThroughNode. // // Instead we query getTurnsFromSegment for every segment connected to this node, which // returns ALL turns (including far turns) that originate from that segment. We then filter // to only far turns whose fromSegment actually touches our node (to avoid processing the // same far turn again when we reach the node at the other end of the segment). var seenTurnIds = {}; // deduplicate in case two connected segments share a far turn var drawnIntermediateSteps = {}; // key: "nodeId_angleRounded", prevents duplicate intermediate-step markers when multiple paths share the same median segment node.connectedSegmentIds.forEach(function (segId) { // Only draw far turns FROM the user-selected entry segment(s). // // When a segment is selected, regular departure-mode markers show angles FROM that // segment only — not from every other segment at the same node. Far turns follow the // same principle: we only want to see "if I came in on THIS segment, what are my JB/ // path exits and at what angle?" // // Without this filter, every entry segment at the node produces its own set of far-turn // markers. When two different entries share the same exit segment, their markers land at // the same boundary point — producing visually duplicate circles at the exit arrow. // // When ja_selected_seg_ids is empty (user selected a node, not a segment) we skip this // filter and show far turns from all connected non-median segments, since there is no // single "incoming" segment to anchor the perspective. if (ja_selected_seg_ids.length > 0 && ja_selected_seg_ids.indexOf(segId) === -1) { ja_log('Skip segment ' + segId + ' (not selected)', 4); return; } // Skip segments that are contained within a BigJunction (median/intermediate segments). if (sdk.DataModel.Segments.isContainedInBigJunction({ segmentId: segId })) { ja_log('Skip segment ' + segId + ' (median)', 4); return; } // Get direct turns from this segment var turnsFromSeg = sdk.DataModel.Turns.getTurnsFromSegment({ segmentId: segId }); if (!turnsFromSeg || turnsFromSeg.length === 0) return; // Check if this segment has far turns (JB or Path) via the normal method var jbFarTurnsCount = turnsFromSeg.filter(function (t) { return t.isJunctionBoxTurn || t.isPathTurn; }).length; // FALLBACK: If no far turns (JB or Path) found, try getAllPossibleTurns() as alternative if (jbFarTurnsCount === 0) { // Check if this segment crosses into a BigJunction and if we're at the correct entry node var seg = sdk.DataModel.Segments.getById({ segmentId: segId }); if (seg) { var fromNode = sdk.DataModel.Nodes.getById({ nodeId: seg.fromNodeId }); var toNode = sdk.DataModel.Nodes.getById({ nodeId: seg.toNodeId }); if (fromNode && toNode) { var isJBSegment = false; var entryNodeForTurns = null; // Determine if segment crosses JB boundary and which node is the entry node for (var bji = 0; bji < allBigJunctions.length; bji++) { var bj = allBigJunctions[bji]; var bjPolygon = turf.polygon(bj.geometry.coordinates); var fromInside = turf.booleanPointInPolygon(turf.point(fromNode.geometry.coordinates), bjPolygon); var toInside = turf.booleanPointInPolygon(turf.point(toNode.geometry.coordinates), bjPolygon); // Check if segment crosses JB boundary (entry: outside→inside, exit: inside→outside) if ((!fromInside && toInside) || (fromInside && !toInside)) { isJBSegment = true; // The entry node is where the turn originates (inside the JB) entryNodeForTurns = toInside ? seg.toNodeId : seg.fromNodeId; break; // Only check the first matching JB } } // Only query getAllPossibleTurns when we're at the correct entry node if (isJBSegment && entryNodeForTurns === node.id) { try { var allTurns = sdk.DataModel.BigJunctions.getAllPossibleTurns({ bigJunctionId: bj.id }); ja_log('[FAR-TURNS] Fallback getAllPossibleTurns: ' + allTurns.length + ' turns found', 3); // Filter for turns from this entry segment that have intermediate segments (far turns through JB) // CRITICAL: getAllPossibleTurns() returns ALL path combinations through a JB, including // traversals of median segments in BOTH directions. We must reject nonsensical paths. var fallbackTurns = allTurns.filter(function (t) { if (!(t.fromSegmentId === segId && t.segmentPath && t.segmentPath.length > 0)) { return false; } // REJECT: paths that traverse the same segment multiple times // These are backtrack/loop paths and geometrically invalid var pathSegIds = t.segmentPath; for (var psi = 0; psi < pathSegIds.length - 1; psi++) { if (pathSegIds[psi] === pathSegIds[psi + 1]) { ja_log('[FAR-TURNS] Rejecting turn ' + t.id + ' — same segment ' + pathSegIds[psi] + ' appears consecutively in path', 3); return false; } } var tFromSeg = sdk.DataModel.Segments.getById({ segmentId: t.fromSegmentId }); var tFirstPathSeg = sdk.DataModel.Segments.getById({ segmentId: t.segmentPath[0] }); if (tFromSeg == null || tFirstPathSeg == null) return false; var tEntryNode = ja_get_connecting_node(tFromSeg, tFirstPathSeg); if (tEntryNode !== entryNodeForTurns) return false; // Determine which node of firstPathSeg is the "exit" (not the entry) var firstPathExitNode = null; if (tFirstPathSeg.fromNodeId === entryNodeForTurns) { firstPathExitNode = tFirstPathSeg.toNodeId; // traverse toward toNodeId } else if (tFirstPathSeg.toNodeId === entryNodeForTurns) { firstPathExitNode = tFirstPathSeg.fromNodeId; // traverse toward fromNodeId } else { return false; // doesn't touch entry node } // Now check: if there's a second segment in the path, it should connect // from firstPathExitNode. If it doesn't, this traversal direction is wrong. if (t.segmentPath.length > 1) { var tSecondPathSeg = sdk.DataModel.Segments.getById({ segmentId: t.segmentPath[1] }); if (tSecondPathSeg == null) return false; // Check if secondPathSeg connects to firstPathExitNode if (tSecondPathSeg.fromNodeId !== firstPathExitNode && tSecondPathSeg.toNodeId !== firstPathExitNode) { // Second segment doesn't connect to exit of first segment // This indicates wrong traversal direction through first segment ja_log('[FAR-TURNS] Rejecting turn ' + t.id + ' — path breaks at first→second segment connection', 3); return false; } } return true; }); ja_log('[FAR-TURNS] Filtered to ' + fallbackTurns.length + ' far turns FROM entry segment ' + segId, 2); if (fallbackTurns.length > 0) { turnsFromSeg = fallbackTurns; ja_log('[FAR-TURNS] Using getAllPossibleTurns() results as fallback', 3); } } catch (e) { ja_log('[FAR-TURNS] getAllPossibleTurns(' + bj.id + ') threw error: ' + e.message, 1); } } else if (isJBSegment && entryNodeForTurns !== node.id) { ja_log('[FAR-TURNS] Segment ' + segId + ' is a JB segment, but entry node is ' + entryNodeForTurns + ', not current node ' + node.id + ' — skipping', 3); return; // Skip this segment at this node } } } } turnsFromSeg.forEach(function (turn) { ja_log('[FAR-TURNS] Turn ' + turn.id + ': isPathTurn=' + turn.isPathTurn + ', isJunctionBoxTurn=' + turn.isJunctionBoxTurn, 3); // Only process far turns (Path turns or Junction Box turns). // Regular turns (isPathTurn=false, isJunctionBoxTurn=false) are already handled // by the existing ja_draw_node_markers() loop and should not be duplicated here. // Also accept turns with intermediate segments (from getAllPossibleTurns fallback) // even if they don't have the isJunctionBoxTurn flag set. var isFarTurn = turn.isPathTurn || turn.isJunctionBoxTurn || (turn.segmentPath && turn.segmentPath.length > 0); if (!isFarTurn) { ja_log('[FAR-TURNS] Skipping turn ' + turn.id + ' — not a far turn', 3); return; } // segmentPath[] contains the IDs of the intermediate segments connecting // fromSegmentId to toSegmentId. It excludes the entry and exit segments themselves. // For a valid far turn segmentPath should always have at least one entry — if it is // somehow empty we cannot determine the entry node, so skip. if (!turn.segmentPath || turn.segmentPath.length === 0) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — segmentPath is empty', 1); return; } // Fetch the entry segment for this far turn. var fromSeg = sdk.DataModel.Segments.getById({ segmentId: turn.fromSegmentId }); if (fromSeg == null) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — fromSegment not found', 1); return; } // For fallback turns from getAllPossibleTurns(): verify path orientation. // getAllPossibleTurns() returns paths using median segments in both forward and // reverse directions. We must skip paths that traverse median segments backward. var isFallbackTurn = !turn.isJunctionBoxTurn && turn.segmentPath && turn.segmentPath.length > 0; if (isFallbackTurn) { var firstPathSegId = turn.segmentPath[0]; var firstPathSeg = sdk.DataModel.Segments.getById({ segmentId: firstPathSegId }); if (firstPathSeg == null) { ja_log('[FAR-TURNS] Skipping fallback turn ' + turn.id + ' — firstPathSeg not found', 1); return; } // Check if fromSeg actually connects to firstPathSeg. If no connection exists, // it means the path uses a segment in the wrong (backward) orientation. var testConnectNode = ja_get_connecting_node(fromSeg, firstPathSeg); if (testConnectNode == null) { ja_log('[FAR-TURNS] Skipping fallback turn ' + turn.id + ' — cannot connect to first path segment (wrong orientation)', 3); return; } } // CRITICAL: Verify the current node is the actual JB/path entry node. // // Problem: getTurnsFromSegment returns the same far turn when called from EITHER // endpoint of the fromSegment. A selected segment A→B only enters the JB at B, // but we process both node A and node B. Without this check, markers appear at A too. // // For fallback turns from getAllPossibleTurns(), they are indexed to a specific // entry node. We must validate before marking as seen, otherwise the turn won't // be processed when we reach the correct node. // // Fix: The true entry node is the node shared between fromSegment and the FIRST // segment in segmentPath[]. That is the point where the segment physically hands off // into the JB or path. If the current node is not that shared node, skip this turn. var firstPathSeg = sdk.DataModel.Segments.getById({ segmentId: turn.segmentPath[0] }); if (firstPathSeg == null) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — firstPathSeg not found', 1); return; } var entryNodeId = ja_get_connecting_node(fromSeg, firstPathSeg); if (entryNodeId !== node.id) { // This node is not the JB/path entry — the far turn belongs to the other end. ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' at node ' + node.id + ' — entry is at node ' + entryNodeId, 3); return; } // Deduplicate: a far turn may appear in results for multiple connected segments. // Only draw it once per node visit. This is checked AFTER node validation so that // fallback turns (which are node-specific) can be processed from their correct node // even if they were encountered and skipped from a different node first. if (seenTurnIds[turn.id]) return; seenTurnIds[turn.id] = true; // Check if this turn type is enabled via experimental settings if (turn.isJunctionBoxTurn && !ja_getOption('enableFarTurnJB')) { ja_log('[FAR-TURNS] Skipping JB turn ' + turn.id + ' — enableFarTurnJB is disabled', 3); return; } if (turn.isPathTurn && !ja_getOption('enableFarTurnPath')) { ja_log('[FAR-TURNS] Skipping Path turn ' + turn.id + ' — enableFarTurnPath is disabled', 3); return; } // Fetch the exit segment (NOT connected to this node — it is at the far end of the path). var toSeg = sdk.DataModel.Segments.getById({ segmentId: turn.toSegmentId }); if (toSeg == null) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — toSegment not found', 1); return; } // Skip JB turns whose exit segment is itself contained inside a BigJunction. // // In a multi-segment JB path (E → M1 → M2 → Exit), the JB model can emit // separate turns for sub-routes where a median segment (M1 or M2) appears as // the toSegmentId. These represent internal routing steps, not the full path to // the real outside-exit segment. Drawing a marker for one of them would: // 1. Place the marker inside the JB polygon (at an internal node). // 2. Produce a duplicate alongside the correct marker at the real exit. // // Only turns where toSeg is a genuine external exit segment should generate markers. // // Note: this check is only applied to JB turns (isJunctionBoxTurn) because Path // turns (isPathTurn) do not use BigJunctions and their exit segments are always // external by definition. if (turn.isJunctionBoxTurn && sdk.DataModel.Segments.isContainedInBigJunction({ segmentId: turn.toSegmentId })) { ja_log('[FAR-TURNS] Skipping JB turn ' + turn.id + ' — toSegment ' + turn.toSegmentId + ' is a median (isContainedInBigJunction)', 1); return; } // To get the correct departure bearing of the exit segment we need to know which // of its two endpoint nodes connects to the path. That is the node shared between // the last intermediate segment (segmentPath[last]) and the exit segment. var lastPathSegId = turn.segmentPath[turn.segmentPath.length - 1]; var lastPathSeg = sdk.DataModel.Segments.getById({ segmentId: lastPathSegId }); if (lastPathSeg == null) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — lastPathSeg not found', 1); return; } // The connecting node is where the path "hands off" to the exit segment. // ja_getAngle() uses this to know which end of the exit segment faces the path. var connectingNodeId = ja_get_connecting_node(lastPathSeg, toSeg); if (connectingNodeId == null) { ja_log('[FAR-TURNS] Skipping far turn ' + turn.id + ' — could not find connecting node between lastPathSeg and toSeg', 1); return; } // BUILD PATH SEGMENTS ARRAY // ────────────────────────────────────────────────────────────────── // pathSegs = [fromSeg, segmentPath[0], ..., segmentPath[last], toSeg] var pathSegs = [fromSeg]; var pathSegFetchOk = true; for (var pi = 0; pi < turn.segmentPath.length; pi++) { var pSeg = sdk.DataModel.Segments.getById({ segmentId: turn.segmentPath[pi] }); if (pSeg == null) { pathSegFetchOk = false; break; } pathSegs.push(pSeg); } pathSegs.push(toSeg); if (!pathSegFetchOk) { ja_log('[FAR-TURNS] Skipping turn ' + turn.id + ' — could not fetch all path segments', 1); return; } // BREADCRUMB TRAIL: Draw a marker for each step in the path // ─────────────────────────────────────────────────────────────────── // For both JB and Path turns: show round markers for intermediate steps, square for final exit // Deduplication prevents duplicate intermediate markers when multiple paths share median segments // Each marker shows the LOCAL turn angle at its connecting node. // Check restriction state: can be blocked at turn level (JB/Path) or at intermediate nodes // Track this so we can display gray marker instead of skipping entirely (for consistency with local turns) var isPathRestricted = false; var isFallbackJBTurn = !turn.isJunctionBoxTurn && !turn.isPathTurn && turn.segmentPath && turn.segmentPath.length > 0; // First check: Turn restriction set directly on the turn (JB or Path turns) // Both turn types now support restrictions if (turn.isJunctionBoxTurn && !turn.isAllowed) { ja_log('[FAR-TURNS] JB turn ' + turn.id + ' restricted: turn.isAllowed=false', 3); isPathRestricted = true; } if (turn.isPathTurn && !turn.isAllowed) { ja_log('[FAR-TURNS] Path turn ' + turn.id + ' restricted: turn.isAllowed=false', 3); isPathRestricted = true; } // For fallback JB turns (from getAllPossibleTurns): treat as restricted if not explicitly allowed // This is because JB turns are controlled by JB logic, and a missing "allowed" indicator likely means restriction if (isFallbackJBTurn) { // Show as restricted unless it clearly has an explicit "allowed" status from SDK // Since getAllPossibleTurns may not fully reflect WME-set restrictions, be conservative ja_log('[FAR-TURNS] Fallback JB turn ' + turn.id + ' marked as restricted (JB-controlled path)', 3); isPathRestricted = true; } // Build blockedSteps map for JB turns and fallback JB turns (check local node restrictions) var blockedSteps = {}; var pathHasBlockedStep = false; // Track if ANY step is blocked if (turn.isJunctionBoxTurn || isFallbackJBTurn) { for (var si = 0; si < pathSegs.length - 1; si++) { var stepFrom = pathSegs[si]; var stepTo = pathSegs[si + 1]; var stepNodeId = ja_get_connecting_node(stepFrom, stepTo); if (stepNodeId == null) { blockedSteps[si] = true; pathHasBlockedStep = true; ja_log('[FAR-TURNS] Step ' + si + ' blocked: no connecting node', 3); continue; } var stepNode = sdk.DataModel.Nodes.getById({ nodeId: stepNodeId }); if (stepNode == null) { blockedSteps[si] = true; pathHasBlockedStep = true; ja_log('[FAR-TURNS] Step ' + si + ' blocked: stepNode is null', 3); } else { var isAllowed = ja_is_turn_allowed(stepFrom, stepNode, stepTo); if (!isAllowed) { blockedSteps[si] = true; pathHasBlockedStep = true; ja_log('[FAR-TURNS] Step ' + si + ' blocked: turn restriction', 3); } // For fallback turns on final step: check JB turn instructions at entry node // JB turn instructions are stored at the first node inside the JB (toNodeId of entry segment) var isFinalStep = si === pathSegs.length - 2; if (isFallbackJBTurn && isFinalStep) { // Entry node is toNodeId of the entry segment (where it crosses INTO JB) var entryNodeId = fromSeg.toNodeId; var jbTurnsAtEntry = sdk.DataModel.Turns.getTurnsThroughNode({ nodeId: entryNodeId }); var hasJBRestriction = jbTurnsAtEntry.some(function (t) { // Check if this turn matches our path AND has a restriction return t.fromSegmentId === turn.fromSegmentId && t.toSegmentId === turn.toSegmentId && (!t.isAllowed || t.instructionOpCode !== null); }); if (hasJBRestriction) { ja_log('[FAR-TURNS] Step ' + si + ' blocked by JB turn instruction at node ' + entryNodeId, 1); blockedSteps[si] = true; pathHasBlockedStep = true; } } } } // If ANY intermediate step is blocked, mark path as restricted but continue to draw gray marker if (pathHasBlockedStep) { var turnTypeStr = turn.isJunctionBoxTurn ? 'JB' : 'fallback JB'; ja_log('[FAR-TURNS] ' + turnTypeStr + ' turn ' + turn.id + ' restricted: internal node restriction blocks this path', 3); isPathRestricted = true; } } // U-TURN TOTAL ANGLE ACCUMULATION // ──────────────────────────────── // For U-TURN paths (instructionOpCode='UTURN'), accumulate all turn angles // through the path. The final marker will display the total heading change // (sum of all intermediate turns), not just the final step's local angle. // This is more robust for non-parallel/irregular geometries. var isUTurnPath = turn.instructionOpCode === 'UTURN'; var uTurnAccumulatedAngle = 0; // Loop through each step and draw markers for (var stepIndex = 0; stepIndex < pathSegs.length - 1; stepIndex++) { var stepFrom = pathSegs[stepIndex]; var stepTo = pathSegs[stepIndex + 1]; var isFinalStep = stepIndex === pathSegs.length - 2; // Skip blocked steps (JB only) if (blockedSteps[stepIndex]) { ja_log('[FAR-TURNS] Skipping step ' + stepIndex + ' — local restriction', 3); continue; } // Get connecting node for this step var stepConnectingNodeId = ja_get_connecting_node(stepFrom, stepTo); if (stepConnectingNodeId == null) { ja_log('[FAR-TURNS] Step ' + stepIndex + ': no connecting node', 3); continue; } var stepConnectingNode = sdk.DataModel.Nodes.getById({ nodeId: stepConnectingNodeId }); if (stepConnectingNode == null) { ja_log('[FAR-TURNS] Step ' + stepIndex + ': connecting node not found', 3); continue; } // Calculate angle at this step's connecting node var stepInAngle = ja_getAngle(stepConnectingNodeId, stepFrom); var stepOutAngle = ja_getAngle(stepConnectingNodeId, stepTo); if (stepInAngle == null || stepOutAngle == null) { ja_log('[FAR-TURNS] Step ' + stepIndex + ': could not compute angles', 3); continue; } var stepAngle = ja_angle_diff(stepInAngle, stepOutAngle, false); // Accumulate for U-TURN total (regardless of whether this step is drawn) if (isUTurnPath) { uTurnAccumulatedAngle += stepAngle; } // DEDUPLICATION: For intermediate steps, skip if already drawn if (!isFinalStep) { // Skip stepIndex 0 (entry node angle): already drawn by ja_draw_node_markers() // ja_draw_node_markers processes this node and draws all connected segment angles, // including entry→firstMedianSegment. Drawing it again here as the first breadcrumb // would create a duplicate marker. if (stepIndex === 0) { ja_log('[FAR-TURNS] Skip step 0 (already drawn by ja_draw_node_markers)', 4); continue; } // Skip if another path already drew this node+angle pair // Multiple paths may traverse the same median segment pair (e.g., A→M1→B and C→M1→B). // We only need to show the marker once. var stepKey = stepConnectingNodeId + '_' + ja_round(Math.abs(stepAngle)); if (drawnIntermediateSteps[stepKey]) { ja_log('[FAR-TURNS] Skip step ' + stepIndex + ' (already drawn)', 4); continue; } drawnIntermediateSteps[stepKey] = true; } // Determine marker type var stepMarkerType; if (isFinalStep) { // FINAL STEP: apply turn.instructionOpCode override and check exit restriction stepMarkerType = ja_getOption('guess') ? ja_get_final_step_type(turn, stepConnectingNode, lastPathSegId, lastPathSeg, toSeg, stepAngle) : ja_routing_type.TURN; } else { // INTERMEDIATE STEP: use full routing instruction logic to match local turn colors // Build angles array for this node (all connected segments with their bearings) var stepAngles = []; stepConnectingNode.connectedSegmentIds.forEach(function (connSegId) { var connSeg = sdk.DataModel.Segments.getById({ segmentId: connSegId }); if (connSeg) { var connBearing = ja_getAngle(stepConnectingNodeId, connSeg); if (connBearing != null) { stepAngles.push([connBearing, connSegId, false]); } } }); // Apply full routing instruction logic, matching regular departure-mode turns // Pass false to suppress "Turn blocked" logs since they're redundant with on-demand evaluation stepMarkerType = ja_getOption('guess') ? ja_guess_routing_instruction(stepConnectingNode, stepFrom.id, stepTo.id, stepAngles, false) : ja_routing_type.TURN; } // If path is restricted (JB turn level or intermediate node), override to NO_TURN (gray marker) // This applies to both final and intermediate steps so the entire path appears gray if (isPathRestricted) { stepMarkerType = ja_routing_type.NO_TURN; } // Determine marker placement anchor var stepMarkerAnchor = stepConnectingNode; var stepExitBearing = stepOutAngle; // For final step, place at JB boundary crossing (not at node) if it's a JB or fallback JB turn // This applies to: // A) Turns with isJunctionBoxTurn flag (normal SDK behavior) // B) Fallback turns from getAllPossibleTurns() that cross JB boundaries // (these have segmentPath but not the JB flag set) var shouldRepositionToBoundary = isFinalStep && (turn.isJunctionBoxTurn || isFallbackJBTurn); if (shouldRepositionToBoundary) { var bigJunction = null; var firstPathSegId = turn.segmentPath[0]; // Find the BigJunction containing the first path segment (median segment) for (var bji = 0; bji < allBigJunctions.length; bji++) { if (allBigJunctions[bji].segmentIds.indexOf(firstPathSegId) !== -1) { bigJunction = allBigJunctions[bji]; break; } } if (bigJunction != null) { var bjPolygon = turf.polygon(bigJunction.geometry.coordinates); var closestPt = ja_find_closest_bj_intersection(toSeg, bjPolygon, stepConnectingNode); if (closestPt !== null) { stepMarkerAnchor = { geometry: closestPt.geometry }; ja_log('[FAR-TURNS] Step ' + stepIndex + ': repositioned to JB boundary (isFallback=' + isFallbackJBTurn + ')', 2); } } } // Compute label distance corrected for latitude var stepJaLd = ja_corrected_ld(ja_label_distance, stepMarkerAnchor.geometry.coordinates); // Apply extra-space multiplier for visibility var stepExtraSpace = ja_compute_extra_space(stepAngle, stepExitBearing); // CHECK FOR LOCAL TURN MARKER CONFLICT // If a local turn at this node targets the same direction, move this far-turn marker farther out var hasLocalConflict = ja_local_markers_by_node[stepConnectingNodeId] && ja_local_markers_by_node[stepConnectingNodeId].some(function(ltMarker) { return ja_markers_target_same_direction(stepExitBearing, ltMarker.bearing, 30); }); // Check if we repositioned to JB boundary (stepMarkerAnchor !== stepConnectingNode) var isAtBoundary = stepMarkerAnchor !== stepConnectingNode; // Determine distance multiplier: prioritize boundary distance, then local conflict distance var stepDistanceMultiplier = stepExtraSpace; if (isAtBoundary) { // At JB boundary: use larger distance to avoid overlapping with WME turn restriction arrows stepDistanceMultiplier = 2.5; if (hasLocalConflict) { ja_log('[MARKER-OVERLAP] Far-turn + local conflict at node ' + stepConnectingNodeId + ': 2.5x distance', 3); } else { ja_log('[MARKER-OVERLAP] Far-turn at JB boundary: 2.5x distance', 3); } } else if (hasLocalConflict) { stepDistanceMultiplier = 1.5; ja_log('[MARKER-OVERLAP] Far-turn conflict: 1.5x distance', 3); } // Calculate marker position var stepPoint = turf.destination(turf.point(stepMarkerAnchor.geometry.coordinates), (stepDistanceMultiplier * stepJaLd) / 1000, ja_math_to_compass(stepExitBearing)).geometry; // Determine marker shape: round for intermediate, square for final var stepIsSquareMarker = isFinalStep; // For U-TURN paths on final step, use accumulated total angle instead of local step angle var angleToDisplay = stepAngle; var angleLogDetail = ''; if (isUTurnPath && isFinalStep) { angleToDisplay = uTurnAccumulatedAngle; angleLogDetail = ' (U-TURN: ' + uTurnAccumulatedAngle.toFixed(1) + '° accumulated)'; } ja_log('[FAR-TURNS] Step ' + stepIndex + ': angle=' + angleToDisplay.toFixed(1) + '° type=' + stepMarkerType + angleLogDetail, 2); // Draw the marker (isFarTurn=true, isSquareMarker=stepIsSquareMarker) ja_draw_marker(stepPoint, stepMarkerAnchor, stepJaLd, angleToDisplay, stepExitBearing, true, stepMarkerType, true, stepIsSquareMarker); // Record this far-turn marker for local turn conflict detection if (!ja_far_turn_bearings_by_node[stepConnectingNodeId]) { ja_far_turn_bearings_by_node[stepConnectingNodeId] = []; } ja_far_turn_bearings_by_node[stepConnectingNodeId].push({ bearing: stepExitBearing, distance: stepDistanceMultiplier * stepJaLd }); } }); }); } // ── End far turn support ────────────────────────────────────────────────────────────────────── /** * Decimal adjustment of a number. Borrowed (with some modifications) from * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round * ja_round(55.55); with 1 decimal // 55.6 * ja_round(55.549); with 1 decimal // 55.5 * ja_round(55); with -1 decimals // 60 * ja_round(54.9); with -1 decimals // 50 * * @param {Number} value The number. * @returns {Number} The adjusted value. */ function ja_round(value) { var ja_rounding = -parseInt(ja_getOption('decimals')); var valueArray; if (typeof ja_rounding === 'undefined' || +ja_rounding === 0) { return Math.round(value); } value = +value; // If the value is not a number or the exp is not an integer... if (isNaN(value) || !(typeof ja_rounding === 'number' && ja_rounding % 1 === 0)) { return NaN; } // Shift valueArray = value.toString().split('e'); value = Math.round(+(valueArray[0] + 'e' + (valueArray[1] ? +valueArray[1] - ja_rounding : -ja_rounding))); // Shift back valueArray = value.toString().split('e'); return +(valueArray[0] + 'e' + (valueArray[1] ? +valueArray[1] + ja_rounding : ja_rounding)); } // ── Settings I/O ────────────────────────────────────────────────────────────── /** * Returns the current value of a user setting, falling back to its default if missing or * invalid. * * **Important:** `name` must be a key that exists in `ja_settings`. Calling this with an * arbitrary key (e.g. `'lastVersion'`) will throw because `ja_settings[name]` is undefined. * For bookkeeping values not in the settings schema, read `ja_options[key]` directly. * * Validation rules per element type: * - `select` — value must appear in `ja_settings[name].options` * - `color` — value must match `/#[0-9a-f]{6}/` * - `number` — value must be within `[min, max]` and not NaN * - `checkbox` — value must be a boolean * * @param {string} name - Key from the `ja_settings` schema. * @returns {*} The stored (or default) setting value. */ function ja_getOption(name) { ja_log('Loading option: ' + name, 3); if (!ja_options.hasOwnProperty(name) || typeof ja_options[name] === 'undefined') { ja_options[name] = ja_settings[name].defaultValue; } //Check for invalid values //Select values if (ja_settings[name].elementType === 'select' && ja_settings[name].options.lastIndexOf(ja_options[name]) < 0) { ja_log(ja_settings[name].options, 4); ja_log('Found invalid value for setting ' + name + ': ' + ja_options[name] + '. Using default.', 3); ja_options[name] = ja_settings[name].defaultValue; } //Color values else if (ja_settings[name].elementType === 'color' && String(ja_options[name]).match(/#[0-9a-f]{6}/) == null) { ja_log('Found invalid value for setting ' + name + ': "' + ja_options[name] + '". Using default.', 3); ja_options[name] = ja_settings[name].defaultValue; } //Numeric values else if (ja_settings[name].elementType === 'number') { var minValue = typeof ja_settings[name].min === 'undefined' ? Number.MIN_VALUE : ja_settings[name].min; var maxValue = typeof ja_settings[name].max === 'undefined' ? Number.MAX_VALUE : ja_settings[name].max; if (isNaN(ja_options[name]) || ja_options[name] < minValue || ja_options[name] > maxValue) { ja_log('Found invalid value for setting ' + name + ': "' + ja_options[name] + '". Using default.', 3); ja_options[name] = ja_settings[name].defaultValue; } } //Checkboxes else if (ja_settings[name].elementType === 'checkbox' && ja_options[name] !== true && ja_options[name] !== false) { ja_log('Found invalid value for setting ' + name + ': "' + ja_options[name] + '". Using default.', 3); ja_options[name] = ja_settings[name].defaultValue; } ja_log('Got value: ' + ja_options[name], 3); return ja_options[name]; } /** * Persists a single setting value to `ja_options` and immediately writes the entire options * object to `localStorage` under the key `wme_ja_options`. * * @param {string} name - Key from the `ja_settings` schema (or a raw `ja_options` key for * bookkeeping values like `lastVersion`). * @param {*} val - New value to store. */ function ja_setOption(name, val) { ja_options[name] = val; if (localStorage) { localStorage.setItem('wme_ja_options', JSON.stringify(ja_options)); } ja_log(ja_options, 3); } /** * `onchange` handler attached to every settings control in the sidebar form. * * Checks whether the new control value actually differs from the stored value; if so it * sets `applyPending = true` and schedules `ja_save()` after a 500 ms debounce. * * Also handles enabling/disabling dependent controls: * - `override` checkbox — enables/disables the override sub-group * - `guess` checkbox — enables/disables the guess group and, transitively, the override * sub-group * - `roundaboutOverlayDisplay` select — enables/disables the overlay color pickers * * Contains the inner helper `disable_input(element, disable)` which toggles `element.disabled` * and adds/removes the `disabled` CSS class on the parent node so the CSS overlay covers the * control visually. * * @param {HTMLInputElement|HTMLSelectElement} e - The DOM element that fired the `change` * event (passed as `this` from the inline `onchange` handler in `setupHtml`). */ var ja_onchange = function (e) { var applyPending = false; var settingName = Object.getOwnPropertyNames(ja_settings).filter(function (a) { ja_log(ja_settings[a], 4); return ja_settings[a].elementId === e.id; })[0]; ja_log(e, 4); ja_log(settingName, 4); switch (ja_settings[settingName].elementType) { case 'checkbox': ja_log('Checkbox setting ' + e.id + ': stored value is: ' + ja_options[settingName] + ', new value: ' + e.checked, 3); if (ja_options[settingName] !== e.checked) { applyPending = true; } break; case 'select': case 'color': case 'number': ja_log('Setting ' + e.id + ': stored value is: ' + ja_options[settingName] + ', new value: ' + e.value, 3); if (String(ja_options[settingName]) !== String(e.value)) { applyPending = true; } break; default: ja_log('Unknown setting ' + e.id + ': stored value is: ' + ja_options[settingName] + ', new value: ' + e.value, 3); } /** * Toggles the disabled state of a settings control and its parent container's `disabled` * CSS class, which triggers the translucent overlay defined in the sidebar stylesheet. * * @param {HTMLElement} element - The input or select element to enable/disable. * @param {boolean} disable - True to disable and show the overlay; false to enable. */ function disable_input(element, disable) { element.disabled = disable; var row = element.closest('.ja-row'); if (row) { if (disable) { row.classList.add('disabled'); } else { row.classList.remove('disabled'); } } } //Enable|disable certain dependent settings switch (e.id) { case ja_settings.override.elementId: Object.getOwnPropertyNames(ja_settings).forEach(function (a) { var setting = ja_settings[a]; if (setting.group && setting.group === 'override') { ja_log(a + ': ' + !e.checked, 3); disable_input(document.getElementById(setting.elementId), !e.checked || e.disabled); } }); break; case ja_settings.guess.elementId: Object.getOwnPropertyNames(ja_settings).forEach(function (a) { var setting = ja_settings[a]; if (setting.group && (setting.group === 'guess' || setting.group === 'override')) { ja_log(a + ': ' + !e.checked, 3); var overrideCb = document.getElementById(ja_settings.override.elementId); var shouldDisable = !e.checked || (setting.group === 'override' && (!overrideCb.checked || overrideCb.disabled)); disable_input(document.getElementById(setting.elementId), shouldDisable); } }); break; case ja_settings.roundaboutOverlayDisplay.elementId: Object.getOwnPropertyNames(ja_settings).forEach(function (a) { var setting = ja_settings[a]; if (setting.group && setting.group === 'roundaboutOverlayDisplay') { ja_log(a + ': ' + e.value, 3); disable_input(document.getElementById(setting.elementId), e.value === 'rOverNever'); } }); break; // PHASE 4: Continuous Scanning toggle handler case ja_settings.continuousScanning.elementId: ja_log('Continuous scanning toggle: ' + e.checked, 2); ja_continuous_enabled = e.checked; if (e.checked) { // Enable: only start if layer is visible; otherwise just set flag and wait for layer to be shown if (ja_layer_visible) { ja_continuous_mode = true; ja_start_continuous_scan(); ja_log('Continuous scanning enabled. Markers persist until segment edits.', 2); } else { ja_continuous_mode = false; ja_log('Continuous scanning enabled (setting saved) but layer is hidden. Will activate when layer is shown.', 2); } } else { // Disable: stop scanning, clear timer and state (markers stay on layer) ja_continuous_mode = false; if (ja_continuous_scan_timer) { clearTimeout(ja_continuous_scan_timer); ja_continuous_scan_timer = null; } // Note: we DON'T clear cache or rendered markers when disabled. // They persist and won't update until user re-enables scanning. // This allows user to review markers without continuous background scanning. ja_continuous_batch_index = 0; ja_log('Continuous scanning disabled. Markers remain visible; scanning paused.', 2); } break; default: ja_log('Nothing to do for ' + e.id, 3); } ja_log('Apply pending configuration changes? ' + applyPending, 3); if (applyPending) { ja_log('Applying new settings now', 3); setTimeout(function () { ja_save(); }, 500); } else { ja_log('No new settings to apply', 3); } }; /** * Loads saved settings from `localStorage` into `ja_options` at startup. * * If `localStorage` is unavailable or the stored JSON is malformed, falls back to * `ja_reset()` which clears `ja_options` and calls `ja_apply()` with all defaults. * On a successful load, schedules `ja_apply()` after 500 ms to let the sidebar DOM * finish rendering before populating form controls. */ var ja_load = function loadJAOptions() { ja_log('Should load settings now.', 3); if (localStorage != null) { ja_log('We have local storage! =)', 3); try { ja_options = JSON.parse(localStorage.getItem('wme_ja_options')); } catch (e) { ja_log('Loading settings failed.. ' + e.message, 1); ja_options = null; } } if (ja_options == null) { ja_reset(); } else { ja_log(ja_options, 4); setTimeout(function () { ja_apply(); }, 500); } }; /** * Reads every settings control from the sidebar DOM and writes the values to `ja_options` * via `ja_setOption` (which also persists to `localStorage`). * * Color inputs with invalid hex are silently reverted to the schema default. Number inputs * outside their `[min, max]` range are similarly reverted. After saving, calls `ja_apply()` * to push the new values back into the style context and redraw markers. * * @returns {boolean} Always returns false (used as the form `onsubmit` handler to prevent * page reload). */ var ja_save = function saveJAOptions() { ja_log('Saving settings', 2); Object.getOwnPropertyNames(ja_settings).forEach(function (a) { var setting = ja_settings[a]; ja_log(setting, 4); switch (setting.elementType) { case 'checkbox': ja_setOption(a, document.getElementById(setting.elementId).checked); break; case 'color': var re = /^#[0-9a-f]{6}$/; if (re.test(document.getElementById(setting.elementId).value)) { ja_setOption(a, document.getElementById(setting.elementId).value); } else { ja_setOption(a, ja_settings[a]['default']); } break; case 'number': var val = parseInt(document.getElementById(setting.elementId).value); if (!isNaN(val) && val === parseInt(val) && setting.min <= val && val <= setting.max) { ja_setOption(a, document.getElementById(setting.elementId).value); } else { ja_setOption(a, ja_settings[a]['default']); } break; case 'text': case 'select': ja_setOption(a, document.getElementById(setting.elementId).value); break; default: ja_log('Unknown setting type ' + setting.elementType, 1); } }); ja_apply(); return false; }; /** * Pushes all stored settings back into the sidebar DOM controls and triggers a map redraw. * * If the SDK layer isn't ready yet (`ja_layer_created === false`) the function reschedules * itself after 400 ms and returns early. Similarly, if the `#sidepanel-ja` element doesn't * exist yet, the DOM-population step is skipped (the settings will be applied on the next * call once the sidebar has rendered). * * After populating controls it calls `ja_calculate_real()` to refresh angle markers using * the updated style context — this is the mechanism by which color-setting changes take * effect immediately without a page reload. */ var ja_apply = function applyJAOptions() { ja_log('Applying stored (or default) settings', 2); if (!ja_layer_created) { ja_log('Layer not ready yet, trying again in 400 ms', 3); setTimeout(function () { ja_apply(); }, 400); return; } if (document.getElementById('sidepanel-ja') == null) { ja_log('WME not ready (no settings tab)', 3); } else { ja_log(Object.getOwnPropertyNames(ja_settings), 4); Object.getOwnPropertyNames(ja_settings).forEach(function (a) { var setting = ja_settings[a]; ja_log(a, 4); ja_log(setting, 4); ja_log(document.getElementById(setting.elementId), 4); switch (setting.elementType) { case 'checkbox': document.getElementById(setting.elementId).checked = ja_getOption(a); document.getElementById(setting.elementId).onchange(null); break; case 'color': case 'number': case 'text': document.getElementById(setting.elementId).value = ja_getOption(a); break; case 'select': document.getElementById(setting.elementId).value = ja_getOption(a); document.getElementById(setting.elementId).onchange(null); break; default: ja_log('Unknown setting type ' + setting.elementType, 1); } }); } // Style driven by ja_build_style_context() closures — recalculate refreshes colors. ja_calculate_real(); ja_log(ja_options, 4); // PHASE 4: Initialize Continuous Scanning if enabled AND layer is visible ja_continuous_enabled = ja_getOption('continuousScanning') || false; if (ja_continuous_enabled && ja_layer_visible) { ja_continuous_mode = true; ja_log('Continuous scanning enabled on startup', 2); // Start the first scan after a brief delay to ensure map is ready setTimeout(() => ja_start_continuous_scan(), 500); } else { ja_continuous_mode = false; if (!ja_layer_visible) { ja_log('Layer is hidden, continuous scanning suppressed', 2); } } }; /** * Clears all saved settings and redraws markers with default values. * * Removes the `wme_ja_options` key from `localStorage` entirely, empties `ja_options`, then * calls `ja_apply()` which will fall back to schema defaults for every setting via * `ja_getOption`. * * @returns {boolean} Always returns false (used as the Reset button's `onclick` handler). */ var ja_reset = function resetJAOptions() { ja_log('Resetting settings', 2); if (localStorage != null) { localStorage.removeItem('wme_ja_options'); } ja_options = {}; ja_apply(); return false; }; /** * Creates a `<li>` element containing an anchor that opens an external URL in a new tab. * * The anchor's text is retrieved via `ja_getMessage(text)` so the link label participates in * the i18n translation system. Used in `setupHtml` to populate the "Version info & links" * list at the bottom of the sidebar panel. * * @param {string} url - Fully-qualified URL for the link's `href`. * @param {string} text - I18n message key (looked up via `ja_getMessage`). * @returns {HTMLLIElement} The newly created list item element. */ function ja_helpLink(url, text) { var elem = document.createElement('li'); var l = document.createElement('a'); l.href = url; l.target = '_blank'; l.appendChild(document.createTextNode(ja_getMessage(text))); elem.appendChild(l); return elem; } // ── Calculation debounce timer ──────────────────────────────────────────────── // // Debounces calls to `ja_calculate_real()` so that rapid successive WME events // (e.g. map-move + selection-changed firing together) only trigger one redraw. // `ja_calculate()` always goes through this object; never call `ja_calculate_real()` // directly from event handlers except where an immediate synchronous redraw is required // (e.g. inside `ja_apply`). var ja_calculation_timer = { start: function () { ja_log('Starting timer', 3); this.cancel(); var ja_calculation_timer_self = this; this.timeoutID = setTimeout(function () { ja_calculation_timer_self.calculate(); }, 200); }, calculate: function () { ja_calculate_real(); delete this.timeoutID; }, cancel: function () { if (typeof this.timeoutID === 'number') { clearTimeout(this.timeoutID); ja_log('Cleared timeout ID : ' + this.timeoutID, 3); delete this.timeoutID; } }, }; /** * Public entry point for triggering a map redraw. * * All WME event handlers call this function rather than `ja_calculate_real()` directly. * It delegates to `ja_calculation_timer.start()` which applies a 200 ms debounce so that * clusters of rapid events (e.g. selection change + data model update) only produce one * redraw. */ function ja_calculate() { ja_calculation_timer.start(); } /** * Returns `'black'` or `'white'` for use as a text color that contrasts against the given * background. * * Uses the YIQ luminance formula (`(R*299 + G*587 + B*114) / 1000`) — a perceptual * weighting that approximates human sensitivity to each colour channel. Values ≥ 128 * are considered light backgrounds (black text); < 128 are dark (white text). * * @param {string} hex_color - Six-digit hex color string (e.g. `'#aa0000'`). * @returns {'black'|'white'} High-contrast text color. */ function ja_get_contrast_color(hex_color) { ja_log('Parsing YIQ-based contrast color for: ' + hex_color + ' ...', 3); var r = parseInt(hex_color.substring(1, 3), 16); var g = parseInt(hex_color.substring(3, 5), 16); var b = parseInt(hex_color.substring(5, 7), 16); var yiq = (r * 299 + g * 587 + b * 114) / 1000; return yiq >= 128 ? 'black' : 'white'; } /** * Returns the user-configured fill color for a given routing-instruction type. * * Centralises the mapping from `ja_routing_type` constants to the corresponding color option * key so that both `ja_build_style_context()` and any future callers have a single source of * truth. Override instruction types map to the same color buckets as their non-override * equivalents (e.g. `OverrideTURN_LEFT` → `turnInstructionColor`). * * Returns the generic fallback `'#ffcc88'` for any type not explicitly listed — this acts as * a visible sentinel to catch unhandled new routing types during development. * * @param {string} ja_type - A value from the `ja_routing_type` enum. * @returns {string} Six-digit hex color string (e.g. `'#00bd00'`). */ function ja_fill_color_for_type(ja_type) { if (ja_type === ja_routing_type.TURN || ja_type === ja_routing_type.TURN_LEFT || ja_type === ja_routing_type.TURN_RIGHT) return ja_getOption('turnInstructionColor'); if (ja_type === ja_routing_type.BC) return ja_getOption('noInstructionColor'); if (ja_type === ja_routing_type.KEEP || ja_type === ja_routing_type.KEEP_LEFT || ja_type === ja_routing_type.KEEP_RIGHT) return ja_getOption('keepInstructionColor'); if (ja_type === ja_routing_type.EXIT || ja_type === ja_routing_type.EXIT_LEFT || ja_type === ja_routing_type.EXIT_RIGHT) return ja_getOption('exitInstructionColor'); if (ja_type === ja_routing_type.U_TURN) return ja_getOption('uTurnInstructionColor'); if (ja_type === ja_routing_type.NO_TURN || ja_type === ja_routing_type.NO_U_TURN) return ja_getOption('noTurnColor'); if (ja_type === ja_routing_type.PROBLEM) return ja_getOption('problemColor'); if (ja_type === ja_routing_type.ROUNDABOUT) return ja_getOption('roundaboutColor'); if (ja_type === ja_routing_type.ROUNDABOUT_EXIT) return ja_getOption('exitInstructionColor'); if (ja_type === ja_routing_type.OverrideTURN_LEFT || ja_type === ja_routing_type.OverrideTURN_RIGHT) return ja_getOption('turnInstructionColor'); if (ja_type === ja_routing_type.OverrideBC) return ja_getOption('noInstructionColor'); if (ja_type === ja_routing_type.OverrideCONTINUE) return ja_getOption('continueInstructionColor'); if (ja_type === ja_routing_type.OverrideKEEP_LEFT || ja_type === ja_routing_type.OverrideKEEP_RIGHT) return ja_getOption('keepInstructionColor'); if (ja_type === ja_routing_type.OverrideEXIT || ja_type === ja_routing_type.OverrideEXIT_LEFT || ja_type === ja_routing_type.OverrideEXIT_RIGHT) return ja_getOption('exitInstructionColor'); if (ja_type === ja_routing_type.OverrideU_TURN) return ja_getOption('uTurnInstructionColor'); return '#ffcc88'; // default/generic — visible sentinel for unhandled types } /** * Builds the SDK `styleContext` object for the `junction_angles` map layer. * * Each property is a function that receives an `{feature}` context object and returns the * value for the corresponding style attribute at render time. Because the functions close * over `ja_getOption`, changes to color settings take effect immediately on the next redraw * without needing to recreate the layer. * * Style context properties: * - `ja_fillColor` — circle background; transparent for `arrow_line` and `roundaboutOverlay` * - `ja_fontColor` — auto-contrasted against fill; transparent for non-text features * - `ja_strokeColor` — dark green default; salmon for `arrow_line`; orange for Override types * (Override color applies equally to regular and far-turn Override markers) * - `ja_strokeWidth` — thicker border for Override types to aid visual distinction * - `ja_graphicName` — 'square' for far-turn markers (JB/Path); 'circle' for regular turns * - `ja_strokeOpacity` — semi-transparent for `arrow_line` features * - `ja_fillOpacity` — 10 % for `roundaboutOverlay` polygon; 0 for `arrow_line` * - `ja_pointRadius` — grows with decimal-count setting; extra width in Simple display mode * - `ja_fontSize` — larger for Override types; 0 for non-label features * - `ja_label` — the `angle` property string of the feature, or `''` * * @returns {Object} styleContext object suitable for `sdk.Map.addLayer({ styleContext })`. */ function ja_build_style_context() { return { ja_fillColor: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props || props.ja_type === 'arrow_line') return 'transparent'; if (props.ja_type === 'roundaboutOverlay') return ja_getOption('roundaboutOverlayColor'); return ja_fill_color_for_type(props.ja_type); }, ja_fontColor: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props || props.ja_type === 'arrow_line' || props.ja_type === 'roundaboutOverlay') return 'transparent'; return ja_get_contrast_color(ja_fill_color_for_type(props.ja_type)); }, ja_strokeColor: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props) return '#183800'; if (props.ja_type === 'arrow_line') return '#ff9966'; if (props.ja_type === 'roundaboutOverlay') return ja_getOption('roundaboutOverlayColor'); if (props.ja_type && props.ja_type.indexOf('Override') === 0) return '#F68F23'; return '#183800'; }, ja_strokeWidth: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props) return 2; if (props.ja_type === 'arrow_line') return 1.2; if (props.ja_type && props.ja_type.indexOf('Override') === 0) return 5; return 2; }, ja_strokeOpacity: function (ctx) { var props = ctx.feature && ctx.feature.properties; return props && props.ja_type === 'arrow_line' ? 0.6 : 1; }, ja_fillOpacity: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props) return 1; if (props.ja_type === 'arrow_line') return 0; if (props.ja_type === 'roundaboutOverlay') return 0.1; return 1; }, ja_pointRadius: function (ctx) { var props = ctx.feature && ctx.feature.properties; var baseRadius = parseInt(ja_getOption('pointSize'), 10) + (parseInt(ja_getOption('decimals')) > 0 ? 4 * parseInt(ja_getOption('decimals')) : 0); if (!props || props.ja_type === 'arrow_line') return 0; // In Simple display mode the arrow sits on the same line as the number. // Detect this: label has no newline but contains a non-digit/non-degree char (the arrow). var labelStr = props.angle != null ? String(props.angle) : ''; if (labelStr.indexOf('\n') === -1 && /[^\d°.\s]/.test(labelStr)) { baseRadius += 4; } if (props.ja_type && props.ja_type.indexOf('Override') === 0) return 2 + baseRadius; return 3 + baseRadius; }, ja_fontSize: function (ctx) { var props = ctx.feature && ctx.feature.properties; if (!props || props.ja_type === 'arrow_line' || props.ja_type === 'roundaboutOverlay') return '0px'; if (props.ja_type && props.ja_type.indexOf('Override') === 0) { return parseInt(ja_getOption('pointSize')) + (ja_getOption('overrideAngles') ? -1 : 8) + 'px'; } return parseInt(ja_getOption('pointSize')) - 1 + 'px'; }, ja_label: function (ctx) { var props = ctx.feature && ctx.feature.properties; return props && props.angle != null ? String(props.angle) : ''; }, ja_graphicName: function (ctx) { var props = ctx.feature && ctx.feature.properties; // Shape determined by marker type and far-turn breadcrumb role: // - Regular turns: always circle // - Far-turn intermediate breadcrumbs: circle (ja_is_far_turn=true, ja_is_square_marker=false) // - Far-turn final exits: square (ja_is_far_turn=true, ja_is_square_marker=true) if (!props || props.ja_type === 'arrow_line' || props.ja_type === 'roundaboutOverlay') { return 'circle'; } // If marked as square far-turn marker (final exit), use square; else circle return props.ja_is_square_marker ? 'square' : 'circle'; }, }; } /** * Builds the SDK `styleRules` array for the `junction_angles` map layer. * * Returns a single catch-all rule that applies the dynamic style context expressions to * every feature on the layer. All visual variation (color, size, label, opacity) is * driven by the `styleContext` functions rather than by multiple rules with filter * predicates — this keeps the rule list simple and avoids SDK predicate evaluation overhead * on every render cycle. * * @returns {Array<{style: Object}>} styleRules array for `sdk.Map.addLayer({ styleRules })`. */ function ja_build_style_rules() { return [ { style: { fillColor: '${ja_fillColor}', fillOpacity: '${ja_fillOpacity}', strokeColor: '${ja_strokeColor}', strokeWidth: '${ja_strokeWidth}', strokeOpacity: '${ja_strokeOpacity}', fontColor: '${ja_fontColor}', pointRadius: '${ja_pointRadius}', fontSize: '${ja_fontSize}', label: '${ja_label}', graphicName: '${ja_graphicName}', fontWeight: 'bold', labelOutlineWidth: 0, }, }, ]; } /** * Returns the localised string for an I18n key in the `ja.*` namespace. * * If no translation is registered for the current locale, the raw `key` string is returned * unchanged. This mirrors WME's own pattern for graceful degradation when a translation is * missing — the key itself is usually a readable English fallback. * * @param {string} key - I18n key within the `ja` namespace (e.g. `'settingsTitle'`). * @returns {string} Translated string, or `key` if no translation exists. */ function ja_getMessage(key) { var tr = I18n.translate('ja.' + key), no_tr = I18n.missingTranslation('ja.' + key); return tr === no_tr ? key : tr; } /** * Registers all supported translations into the WME I18n system under the `ja` namespace. * * Inspects `I18n.locale` and calls the inner `set_trans(def)` helper to assign the * appropriate translation object. The `default` case installs English, which also serves as * the fallback for any unrecognised locale. * * Called once during `junctionangle_init` and again whenever a `wme-user-settings-changed` * event fires (e.g. when the user switches WME's interface language at runtime). * * Supported locales: `cs`, `fi`, `pl`, `ru`, `sv`, `fr`, `es-419`, `uk`, and English default. */ function ja_loadTranslations() { /** * Registers a translation definition object under `I18n.translations[locale].ja`. * * The assignment expression is intentional — it both stores the object and returns it * (the `jshint -W093` directive suppresses the "assignment in return" lint warning). * * @param {Object} def - Key/value map of i18n strings for the `ja` namespace. * @returns {Object} The same `def` object that was just stored. */ var set_trans = function (def) { /*jshint -W093*/ return (I18n.translations[I18n.locale].ja = def); }; ja_log('Loading translations', 2); //Apply switch (I18n.locale) { default: //Default language (English) set_trans({ name: 'Junction Angle Info', settingsTitle: 'Junction Angle Info settings', resetToDefault: 'Reset to default', aAbsolute: 'Absolute', aDeparture: 'Departure', angleMode: 'Angle mode', angleDisplay: 'Angle display style', angleDisplayArrows: 'Direction arrows', displayFancy: 'Fancy', displaySimple: 'Simple', override: 'Check "override instruction"', overrideAngles: 'Show angles of "override instruction"', guess: 'Estimate routing instructions', noInstructionColor: 'Best continuation', continueInstructionColor: 'Continue straight', keepInstructionColor: 'Keep', exitInstructionColor: 'Exit', turnInstructionColor: 'Turn', uTurnInstructionColor: 'U-turn', noTurnColor: 'Disallowed turn', problemColor: 'Angle to avoid', roundaboutColor: 'Non-Normal Exit', roundaboutOverlayColor: 'Overlay', roundaboutOverlayDisplay: 'Show roundabout', rOverNever: 'Never', rOverSelected: 'When selected', rOverAlways: 'Always', uTurnIncludeStreet: 'Include Street Type', uTurnIncludeParkingLot: 'Include Parking Lot roads', uTurnIncludePrivateRoad: 'Include Private roads', wazeDoubleUTurnRestriction: 'Disable for <15m and ±5° parallel', enableFarTurnJB: 'Enable JAI for Junction Boxes', enableFarTurnPath: 'Enable JAI for Paths', continuousScanning: 'Scan for Angles to Avoid', decimals: 'Number of decimals', pointSize: 'Base point size', settingsguide: 'Settings & User Guide', roundaboutnav: 'WIKI: Roundabouts', wazeAlgorithm: 'Waze Turn/Keep/Exit Algorithm', ghissues: 'JAI issue tracker', }); break; //Czech (čeština) case 'cs': set_trans({ name: 'Junction Angle Info', settingsTitle: 'Nastavení JAI', resetToDefault: 'Výchozí nastavení', aAbsolute: 'Absolutní', aDeparture: 'Odjezdový', angleMode: 'Styl zobrazení úhlů', angleDisplay: 'Styl výpisu úhlů', angleDisplayArrows: 'Směrové šipky', displayFancy: 'Zdobný', displaySimple: 'Jednoduchý', override: 'Zvýraznit vynucené hlasové pokyny', overrideAngles: 'Zobrazit úhly vynucených pokynů', guess: 'Odhadovat navigační hlášky', noInstructionColor: 'Bez hlášení', continueInstructionColor: 'Rovně', keepInstructionColor: 'Držte se', exitInstructionColor: 'Sjeďte', turnInstructionColor: 'Odbočte', uTurnInstructionColor: 'Otočte se', noTurnColor: 'Nepovolené směry', problemColor: 'Nejasné úhly', roundaboutColor: 'Rozbité kruháče', roundaboutOverlayColor: 'Kruháče', roundaboutOverlayDisplay: 'ukazovat kruháče', rOverNever: 'Ne-', rOverSelected: 'Při výběru', rOverAlways: 'Vždy', uTurnIncludeStreet: 'Zahrnout ulice', uTurnIncludeParkingLot: 'Zahrnout parkoviště', uTurnIncludePrivateRoad: 'Zahrnout soukromé cesty', wazeDoubleUTurnRestriction: 'Zakázat pro <15m a ±5° paralelně', enableFarTurnJB: 'Povolit JAI pro silniční křižovatky', enableFarTurnPath: 'Povolit JAI pro cesty', continuousScanning: 'Skenování úhlů k vyhnutí', decimals: 'Počet des. míst', pointSize: 'Velikost písma', settingsguide: 'Nastavení a Uživatelská příručka', roundaboutnav: 'US WIKI: Kruhové objezdy', wazeAlgorithm: 'Algoritmus Waze Turn/Keep/Exit', ghissues: 'Hlášení problémů JAI', }); break; //Finnish (Suomen kieli) case 'fi': set_trans({ name: 'Risteyskulmat', settingsTitle: 'Rysteyskulmien asetukset', resetToDefault: 'Palauta', aAbsolute: 'Absoluuttinen', aDeparture: 'Käännös', angleMode: 'Kulmien näyttö', angleDisplay: 'Näyttötyyli', angleDisplayArrows: 'Suuntanuolet', displayFancy: 'Nätti', displaySimple: 'Yksinkertainen', override: 'Check "override instruction"', overrideAngles: 'Show angles of "override instruction"', guess: 'Arvioi reititysohjeet', noInstructionColor: 'ohjeeton "Suora"-väri', continueInstructionColor: 'Continue straight', keepInstructionColor: '"Pysy vasemmalla/oikealla"-ohjeen väri', exitInstructionColor: '"Poistu"-ohjeen väri', turnInstructionColor: '"Käänny"-ohjeen väri', uTurnInstructionColor: '"Käänny ympäri"-ohjeen väri', noTurnColor: 'Kielletyn käännöksen väri', problemColor: 'Vältettävien kulmien väri', roundaboutColor: 'Liikenneympyrän (jolla ei-suoria kulmia) ohjeen väri', roundaboutOverlayColor: 'Liikenneympyrän korostusväri', roundaboutOverlayDisplay: 'Korosta liikenneympyrä', rOverNever: 'Ei ikinä', rOverSelected: 'Kun valittu', rOverAlways: 'Aina', uTurnIncludeStreet: 'Sisällytä kadut', uTurnIncludeParkingLot: 'Sisällytä parkkialueen tiet', uTurnIncludePrivateRoad: 'Sisällytä yksityistiet', wazeDoubleUTurnRestriction: 'Poista käytöstä <15m ja ±5° rinnakkaisille', enableFarTurnJB: 'Ota JAI käyttöön risteyksissä', enableFarTurnPath: 'Ota JAI käyttöön poluilla', continuousScanning: 'Skannaa välttämisen kulmia', decimals: 'Desimaalien määrä', pointSize: 'Ympyrän peruskoko', wazeAlgorithm: 'Waze Turn/Keep/Exit Algoritmi', }); break; //Polish (język polski) case 'pl': set_trans({ settingsTitle: 'Ustawienia', resetToDefault: 'Przywróć domyślne', aAbsolute: 'Absolutne', aDeparture: 'Rozjazdy', angleMode: 'Tryb wyświetlania kątów', angleDisplay: 'Styl kierunków', displayFancy: 'Dwuliniowy', displaySimple: 'Prosty', angleDisplayArrows: 'Strzałki kierunków', override: 'Check "override instruction"', overrideAngles: 'Show angles of "override instruction"', guess: 'Szacuj komunikaty trasy', noInstructionColor: 'Kolor najlepszej kontynuacji', continueInstructionColor: 'Continue straight', keepInstructionColor: 'Kolor dla "kieruj się"', exitInstructionColor: 'Kolor dla "zjedź"', turnInstructionColor: 'Kolor dla "skręć"', uTurnInstructionColor: 'Kolor dla "zawróć"', noTurnColor: 'Kolor niedozwolonych manewrów', problemColor: 'Kolor problematycznych kątów', roundaboutColor: 'Kolor rond niestandardowych', roundaboutOverlayColor: 'Kolor znacznika rond', roundaboutOverlayDisplay: 'Pokazuj ronda', rOverNever: 'Nigdy', rOverSelected: 'Gdy zaznaczone', rOverAlways: 'Zawsze', uTurnIncludeStreet: 'Uwzględnij ulice', uTurnIncludeParkingLot: 'Uwzględnij drogi parkingowe', uTurnIncludePrivateRoad: 'Uwzględnij drogi prywatne', wazeDoubleUTurnRestriction: 'Wyłącz dla <15m i ±5° równoległy', enableFarTurnJB: 'Włącz JAI dla skrzyżowań', enableFarTurnPath: 'Włącz JAI dla ścieżek', continuousScanning: 'Skanuj kąty do uniknięcia', decimals: 'Ilość cyfr po przecinku', pointSize: 'Rozmiar punktów pomiaru', wazeAlgorithm: 'Algorytm Waze Turn/Keep/Exit', }); break; //Portuguese (português) case 'pt': set_trans({ name: 'Informações de Ângulos de Junção', settingsTitle: 'Definições de Informações de Ângulos de Junção', resetToDefault: 'Repor predefinições', aAbsolute: 'Absoluto', aDeparture: 'Partida', angleMode: 'Modo de ângulo', angleDisplay: 'Estilo de visualização de ângulos', angleDisplayArrows: 'Setas de direção', displayFancy: 'Elegante', displaySimple: 'Simples', override: 'Verificar "instrução de substituição"', overrideAngles: 'Mostrar ângulos de "instrução de substituição"', guess: 'Estimar instruções de encaminhamento', noInstructionColor: 'Melhor continuação', continueInstructionColor: 'Continuar reto', keepInstructionColor: 'Manter', exitInstructionColor: 'Sair', turnInstructionColor: 'Virar', uTurnInstructionColor: 'Inversão de marcha', noTurnColor: 'Viragem desautorizada', problemColor: 'Ângulo a evitar', roundaboutColor: 'Saída não-normal', roundaboutOverlayColor: 'Sobreposição', roundaboutOverlayDisplay: 'Mostrar rotunda', rOverNever: 'Nunca', rOverSelected: 'Quando selecionado', rOverAlways: 'Sempre', uTurnIncludeStreet: 'Incluir ruas', uTurnIncludeParkingLot: 'Incluir estacionamentos', uTurnIncludePrivateRoad: 'Incluir estradas privadas', wazeDoubleUTurnRestriction: 'Desativar para <15m e ±5° paralelo', enableFarTurnJB: 'Ativar JAI para caixas de junção', enableFarTurnPath: 'Ativar JAI para caminhos', continuousScanning: 'Procurar ângulos para evitar', decimals: 'Número de casas decimais', pointSize: 'Tamanho base do ponto', settingsguide: 'Definições e guia do utilizador', roundaboutnav: 'WIKI: Rotundas', wazeAlgorithm: 'Algoritmo Waze Turn/Keep/Exit', ghissues: 'Rastreador de problemas JAI', }); break; //Russian (русский) case 'ru': set_trans({ name: 'Углы поворотов', settingsTitle: 'Настройки Junction Angle Info', resetToDefault: 'Сбросить настройки', aAbsolute: 'Абсолютные', aDeparture: 'Повороты', angleMode: '- режим углов', angleDisplay: '- стиль отображения', angleDisplayArrows: '- стрелки направлений', displayFancy: 'Модный', displaySimple: 'Простой', override: 'Визуализировать изменённые подсказки', overrideAngles: 'Показывать углы изменённых подсказок', guess: 'Ожидаемые подсказки', noInstructionColor: 'Нет подсказки', continueInstructionColor: 'Прямо', keepInstructionColor: 'Держитесь', exitInstructionColor: 'Съезд', turnInstructionColor: 'Поверните', uTurnInstructionColor: 'Развернитесь', noTurnColor: 'Запрещённый манёвр', problemColor: 'Избегать', roundaboutColor: 'Некорректный выезд', roundaboutOverlayColor: 'Кольцо', roundaboutOverlayDisplay: '- показ колец', rOverNever: 'Никогда', rOverSelected: 'Если выбрано', rOverAlways: 'Всегда', uTurnIncludeStreet: '- включить улицы', uTurnIncludeParkingLot: '- включить парковки', uTurnIncludePrivateRoad: '- включить частные дороги', wazeDoubleUTurnRestriction: 'Отключить для <16м и ±5° параллель', enableFarTurnJB: 'Включить JAI для перекрёстков', enableFarTurnPath: 'Включить JAI для путей', continuousScanning: 'Сканировать углы для избежания', decimals: '- знаков после запятой', pointSize: '- размер кружка', settingsguide: 'Настройки и руководство пользователя', roundaboutnav: 'Вики: круговые перекрестки', wazeAlgorithm: 'Алгоритм Waze Turn/Keep/Exit', ghissues: 'Сообщить об ошибке', }); break; //Swedish (svenska) case 'sv': set_trans({ name: 'Korsningsvinklar', settingsTitle: 'Inställningar för korsningsvinklar', resetToDefault: 'Återställ', aAbsolute: 'Absolut', aDeparture: 'Sväng', angleMode: 'Vinkelvisning', angleDisplay: 'Vinkelstil', angleDisplayArrows: 'Riktningspilar', displayFancy: 'Grafisk', displaySimple: 'Simpel', override: 'Check "override instruction"', overrideAngles: 'Show angles of "override instruction"', guess: 'Gissa navigeringsinstruktioner', noInstructionColor: 'Färg för "ingen instruktion"', continueInstructionColor: 'Continue straight', keepInstructionColor: 'Färg för "håll höger/vänster"-instruktion', exitInstructionColor: 'Färg för "ta av"-instruktion', turnInstructionColor: 'Färg för "sväng"-instruktion', uTurnInstructionColor: 'Färg för "U-sväng"-instruktion', noTurnColor: 'Färg förbjuden sväng', problemColor: 'Färg för vinklar att undvika', roundaboutColor: 'Färg för rondell (med icke-räta vinklar)', roundaboutOverlayColor: 'Färg för rondellcirkel', roundaboutOverlayDisplay: 'Visa cirkel på rondell', rOverNever: 'Aldrig', rOverSelected: 'När vald', rOverAlways: 'Alltid', uTurnIncludeStreet: 'Inkludera gator', uTurnIncludeParkingLot: 'Inkludera parkeringsvägar', uTurnIncludePrivateRoad: 'Inkludera enskilda vägar', wazeDoubleUTurnRestriction: 'Inaktivera för <15m och ±5° parallell', enableFarTurnJB: 'Aktivera JAI för korsningar', enableFarTurnPath: 'Aktivera JAI för vägar', continuousScanning: 'Skanna vinklar att undvika', decimals: 'Decimaler', pointSize: 'Cirkelns basstorlek', wazeAlgorithm: 'Waze Turn/Keep/Exit Algoritm', }); break; //French (Francais) case 'fr': set_trans({ name: 'Junction Angle Info', settingsTitle: 'Paramètres de Junction Angle Info', angleMode: 'Mode Angle', aAbsolute: 'Absolu', aDeparture: 'Départ', angleDisplay: "Style d'affichage d'Angles", angleDisplayArrows: 'Flèches de Direction', displayFancy: 'Fancy', displaySimple: 'Simple', override: 'Contrôler les "overrides instruction"', overrideAngles: 'Afficher les angles des "overrides" actives', guess: 'Estimer les instructions routage', noInstructionColor: 'Sans instruction', continueInstructionColor: 'Tout droit', keepInstructionColor: 'Serrez', exitInstructionColor: 'Sortez', turnInstructionColor: 'Tournez', uTurnInstructionColor: 'Demi-tour', noTurnColor: 'Virage interdit', problemColor: 'Angle à éviter', roundaboutOverlayDisplay: 'Surligner les rond-point', rOverNever: 'Jamais', rOverSelected: 'Sélectionné', rOverAlways: 'Toujours', roundaboutOverlayColor: 'Surlignage', roundaboutColor: 'Sortie anormale', uTurnIncludeStreet: 'Inclure les rues', uTurnIncludeParkingLot: 'Inclure les voies de parking', uTurnIncludePrivateRoad: 'Inclure les voies privées', wazeDoubleUTurnRestriction: 'Désactiver pour <15m et ±5° parallèle', enableFarTurnJB: 'Activer JAI pour les carrefours', enableFarTurnPath: 'Activer JAI pour les chemins', continuousScanning: 'Analyser les angles à éviter', decimals: 'Nombre de decimales', pointSize: 'Taille des bulles', wazeAlgorithm: 'Algorithme Waze Turn/Keep/Exit', resetToDefault: 'Réinitialiser par défaut', settingsguide: 'Paramètres et Guide utilisateur', roundaboutnav: 'WIKI: Rond-point (en)', ghissues: 'JAI Reporter un problème', }); break; //Latin-American Spanish (español latinoamericano) case 'es-419': set_trans({ name: 'Información en Ángulos de Intersección (JAI)', settingsTitle: 'Configuración de Información en Ángulos', resetToDefault: 'Limpiar configuración', aAbsolute: 'Absoluto', aDeparture: 'Salida', angleMode: 'Modo de ángulos', angleDisplay: 'Estilo para mostrar', angleDisplayArrows: 'Flechas de dirección', displayFancy: 'Lujoso', displaySimple: 'Simple', override: 'Revisar "instrucciones forzadas"', overrideAngles: 'Ver ángulos en "instrucciones forzadas"', guess: 'Estimar instrucciones de giro', noInstructionColor: 'Sin instrucción', continueInstructionColor: '"Sigue derecho"', keepInstructionColor: '"Mantente"', exitInstructionColor: '"Sale"', turnInstructionColor: '"Gira"', uTurnInstructionColor: '"Gira en U"', noTurnColor: 'Giros deshabilitados', problemColor: 'Ángulos a evitar', roundaboutColor: 'Rotondas anormales', roundaboutOverlayColor: 'Rotondas', roundaboutOverlayDisplay: 'Mostrar rotondas', rOverNever: 'Nunca', rOverSelected: 'Seleccionadas', rOverAlways: 'Siempre', uTurnIncludeStreet: 'Incluir calles', uTurnIncludeParkingLot: 'Incluir vías de estacionamiento', uTurnIncludePrivateRoad: 'Incluir caminos privados', wazeDoubleUTurnRestriction: 'Desactivar para <15m y ±5° paralelo', enableFarTurnJB: 'Habilitar JAI para intersecciones', enableFarTurnPath: 'Habilitar JAI para caminos', continuousScanning: 'Escanear ángulos para evitar', decimals: 'Decimales', pointSize: 'Tamaño del texto', wazeAlgorithm: 'Algoritmo Waze Turn/Keep/Exit', settingsguide: 'Configuración y Guía del usuario', roundaboutnav: 'WIKI: Rotondas', ghissues: 'Seguimiento de problemas', }); break; //Ukrainian (український) case 'uk': set_trans({ name: 'Junction Angle Info', settingsTitle: 'Налаштування Junction Angle Info', resetToDefault: 'Скинути налаштування', aAbsolute: 'Абсолютні', aDeparture: 'Повороти', angleMode: '- режим кутів', angleDisplay: '- стиль відображення', angleDisplayArrows: '- стрілки напрямків', displayFancy: 'Модний', displaySimple: 'Простий', override: 'Візуалізувати "змінені підказки"', overrideAngles: 'Показувати кути для "змінених підказок"', guess: 'Очікувані підказки:', noInstructionColor: 'Немає підказки', continueInstructionColor: 'Прямо', keepInstructionColor: 'Тримайтеся', exitInstructionColor: "З'їзд", turnInstructionColor: 'Поверніть', uTurnInstructionColor: 'Розверніться', noTurnColor: 'Заборонений маневр', problemColor: 'Уникати', roundaboutColor: 'Некоректний виїзд', roundaboutOverlayColor: 'Кільце', roundaboutOverlayDisplay: '- показ кілець', rOverNever: 'Ніколи', rOverSelected: 'Якщо вибрано', rOverAlways: 'Завжди', uTurnIncludeStreet: '- включати вулиці', uTurnIncludeParkingLot: '- включати парковки', uTurnIncludePrivateRoad: '- включати приватні дороги', wazeDoubleUTurnRestriction: 'Вимкнути для <15м і ±5° паралельно', enableFarTurnJB: 'Увімкнути JAI для перехресть', enableFarTurnPath: 'Увімкнути JAI для шляхів', continuousScanning: 'Сканування кутів для уникнення', decimals: '- знаків після коми', pointSize: '- розмір шрифту', wazeAlgorithm: 'Алгоритм Waze Turn/Keep/Exit', settingsguide: 'Налаштування та посібник користувача', roundaboutnav: 'WIKI: кругові перехрестя(en)', ghissues: 'JAI - Повідомити про помилку', }); break; } } /* * Bootstrapping and logging */ /** * Displays the WazeWrap "script updated" notification banner when the script version changes. * * Compares `SCRIPT_VERSION` against the `lastVersion` value stored in `ja_options`. If they * differ (and `SHOW_UPDATE_MESSAGE` is true) it calls `WazeWrap.Interface.ShowScriptUpdate` * with the current release notes built from `SCRIPT_VERSION_CHANGES`, then updates * `ja_options['lastVersion']` and persists it to `localStorage` so the banner is not shown * again on the next page load. * * Note: `lastVersion` is stored directly in `ja_options` and must never be accessed via * `ja_getOption`/`ja_setOption` because it is not declared in the `ja_settings` schema. */ function showScriptInfoAlert() { /* Check version and alert on update */ if (SHOW_UPDATE_MESSAGE && SCRIPT_VERSION !== ja_options['lastVersion']) { let releaseNotes = ''; releaseNotes += "<p>What's New:</p>"; if (SCRIPT_VERSION_CHANGES.length > 0) { releaseNotes += '<ul>'; for (let idx = 0; idx < SCRIPT_VERSION_CHANGES.length; idx++) releaseNotes += `<li>${SCRIPT_VERSION_CHANGES[idx]}`; releaseNotes += '</ul>'; } else { releaseNotes += '<ul><li>Nothing major.</ul>'; } WazeWrap.Interface.ShowScriptUpdate(GM_info.script.name, SCRIPT_VERSION, releaseNotes, DOWNLOAD_URL); ja_options['lastVersion'] = SCRIPT_VERSION; if (localStorage) { localStorage.setItem('wme_ja_options', JSON.stringify(ja_options)); } } } /** * Conditional console logger gated by `junctionangle_debug`. * * Messages are only printed when `ja_log_level <= junctionangle_debug`, so verbosity can be * tuned without touching call sites: * - Level 0 — silent * - Level 1 — important warnings / start-up messages (default release setting) * - Level 2 — setting changes, calculation entry/exit * - Level 3 — per-segment / per-node detail * - Level 4 — insane (angle math step-by-step) * * Object arguments are passed directly to `console.log` (no string coercion) so the browser * DevTools inspector can expand them interactively. * * @param {*} ja_log_msg - Message string or object to log. * @param {number} [ja_log_level=1] - Minimum debug level required to print this message. */ function ja_log(ja_log_msg, ja_log_level) { if (typeof ja_log_level === 'undefined') { ja_log_level = 1; } if (ja_log_level <= junctionangle_debug) { if (typeof ja_log_msg === 'object') { console.log(ja_log_msg); } else { console.log('WME JAI: ' + ja_log_msg); } } } sdk = await bootstrap( /** @type {BootstrapArgs} */ ({ scriptUpdateMonitor: { downloadUrl: DOWNLOAD_URL }, }), ); /** * Renders (or re-renders) the entire JAI settings panel inside the SDK sidebar tab pane. * * Clears `jaTabPane` and rebuilds its contents from scratch — safe to call more than once * (e.g. on `wme-user-settings-changed`) to pick up a new locale without stale DOM nodes. * * Structure: scoped `<style>`, a script header, four setting cards (Display, Routing * instructions, Instruction colors, Roundabout), and a footer with a Reset button and links. * CSS is scoped to `.wme-ja-panel` (added to `jaTabPane` by `junctionangle_init`). * Checkboxes use custom toggle-switch markup; all element IDs are unchanged from `ja_settings` * so `ja_save`, `ja_apply`, and `ja_onchange` work without modification. * * @param {HTMLElement} jaTabPane - The SDK sidebar tab pane element returned by * `sdk.Sidebar.registerScriptTab()`. */ function setupHtml(jaTabPane) { jaTabPane.innerHTML = ''; ja_log('---------- Creating settings HTML ----------', 2); // ── CSS (scoped to .wme-ja-panel) ───────────────────────────────── var style = document.createElement('style'); style.textContent = [ '.wme-ja-panel { padding: 8px; box-sizing: border-box; }', '.wme-ja-panel .ja-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; padding: 8px 10px; background: linear-gradient(135deg, #0066cc, #0052a3); color: #fff; border-radius: 8px; }', '.wme-ja-panel .ja-header-left { display: flex; align-items: center; gap: 6px; }', '.wme-ja-panel .ja-header-icon { color: #fff; font-size: 1.2em; }', '.wme-ja-panel .ja-header-name { font-weight: 700; font-size: 13px; color: #fff; }', '.wme-ja-panel .ja-header-version { font-size: 10px; opacity: 0.8; color: #fff; }', '.wme-ja-panel .ja-card { border: 1px solid var(--hairline, #ddd); border-radius: 8px; margin-bottom: 8px; overflow: hidden; }', '.wme-ja-panel .ja-card-header { display: flex; align-items: center; gap: 7px; padding: 7px 10px; font-weight: 700; font-size: 11px; text-transform: uppercase; letter-spacing: 0.03em; border-bottom: 1px solid var(--hairline, #ddd); background: linear-gradient(135deg, #f8f9fa, #f0f1f3); color: #333; }', '.wme-ja-panel .ja-card-header:hover { background: linear-gradient(135deg, #f0f1f3, #e8eaed); }', '.wme-ja-panel .ja-card-header i { color: #0066cc; font-size: 11px; width: 14px; text-align: center; }', '.wme-ja-panel .ja-card-body { padding: 2px 0; }', '.wme-ja-panel .ja-row { display: flex; justify-content: space-between; align-items: center; padding: 5px 10px; min-height: 32px; box-sizing: border-box; }', '.wme-ja-panel .ja-sub-row { padding-left: 22px; }', '.wme-ja-panel .ja-sub-sub-row { padding-left: 34px; }', '.wme-ja-panel .ja-row-label { flex: 1; font-size: 12px; padding-right: 8px; line-height: 1.3; }', '.wme-ja-panel .ja-row.disabled { opacity: 0.4; pointer-events: none; }', '.wme-ja-panel select { font-size: 12px; border: 1px solid var(--hairline, #ccc); border-radius: 4px; padding: 3px 5px; width: 130px; max-width: 130px; box-sizing: border-box; background: var(--background_default, #fff); color: var(--content_default, #333); }', '.wme-ja-panel input[type="number"] { font-size: 12px; border: 1px solid var(--hairline, #ccc); border-radius: 4px; padding: 3px 5px; width: 52px; text-align: right; box-sizing: border-box; background: var(--background_default, #fff); color: var(--content_default, #333); }', '.wme-ja-panel input[type="color"] { width: 30px; height: 22px; padding: 1px 2px; border: 1px solid var(--hairline, #ccc); border-radius: 3px; cursor: pointer; flex-shrink: 0; }', '@supports (-webkit-appearance:none) { .wme-ja-panel input[type="color"] { padding: 0 2px; } }', '.wme-ja-panel .ja-toggle { position: relative; display: inline-block; width: 34px; height: 18px; flex-shrink: 0; }', '.wme-ja-panel .ja-toggle input { opacity: 0; width: 0; height: 0; position: absolute; }', '.wme-ja-panel .ja-toggle-slider { position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; border-radius: 18px; transition: background-color 0.2s; }', '.wme-ja-panel .ja-toggle-slider:before { position: absolute; content: ""; height: 12px; width: 12px; left: 3px; bottom: 3px; background-color: white; border-radius: 50%; transition: transform 0.2s; }', '.wme-ja-panel .ja-toggle input:checked + .ja-toggle-slider { background-color: #00bd00; }', '.wme-ja-panel .ja-toggle input:checked + .ja-toggle-slider:before { transform: translateX(16px); }', '.wme-ja-panel .ja-colors-grid { display: grid; grid-template-columns: 1fr 1fr; }', '.wme-ja-panel .ja-colors-grid .ja-row { padding: 4px 8px; }', '.wme-ja-panel .ja-colors-grid .ja-row-label { font-size: 11px; }', '.wme-ja-panel .ja-footer { margin-top: 4px; }', '.wme-ja-panel .ja-footer .btn { width: 100%; margin-bottom: 6px; font-size: 12px; }', '.wme-ja-panel .ja-footer ul { margin: 0; padding: 0; font-size: 11px; }', '.wme-ja-panel .ja-footer ul li { margin-bottom: 2px; }', '.wme-ja-panel .ja-footer ul li a { opacity: 0.7; }', '.wme-ja-panel .ja-footer ul li a:hover { opacity: 1; }', '[wz-theme="dark"] .wme-ja-panel .ja-header { background: linear-gradient(135deg, #0052a3, #003d7a); }', '[wz-theme="dark"] .wme-ja-panel .ja-card-header { background: linear-gradient(135deg, #2a2c30, #202124); color: #e8eaed; }', '[wz-theme="dark"] .wme-ja-panel .ja-card-header:hover { background: linear-gradient(135deg, #333538, #2a2c30); }', '[wz-theme="dark"] .wme-ja-panel .ja-card-header i { color: #33ccff; }', ].join('\n'); jaTabPane.appendChild(style); // ── Inner helpers ───────────────────────────────────────────────── /** Creates a card div with an icon header and returns { card, body }. */ function makeCard(iconClass, title) { var card = document.createElement('div'); card.className = 'ja-card'; var cardHeader = document.createElement('div'); cardHeader.className = 'ja-card-header'; var icon = document.createElement('i'); icon.className = 'fa ' + iconClass; var titleSpan = document.createElement('span'); titleSpan.textContent = title; cardHeader.appendChild(icon); cardHeader.appendChild(titleSpan); card.appendChild(cardHeader); var body = document.createElement('div'); body.className = 'ja-card-body'; card.appendChild(body); return { card: card, body: body }; } /** Creates a flex row with a label and a trailing control element. */ function makeRow(labelText, control, extraClass) { var row = document.createElement('div'); row.className = 'ja-row' + (extraClass ? ' ' + extraClass : ''); var labelEl = document.createElement('span'); labelEl.className = 'ja-row-label'; labelEl.textContent = labelText; row.appendChild(labelEl); row.appendChild(control); return row; } /** Creates a <select> wired to ja_onchange for the given settings key. */ function makeSelect(settingKey) { var setting = ja_settings[settingKey]; var select = document.createElement('select'); select.id = setting.elementId; for (var i = 0; i < setting.options.length; i++) { var opt = document.createElement('option'); opt.value = setting.options[i]; opt.textContent = ja_getMessage(setting.options[i]); select.appendChild(opt); } select.onchange = function () { ja_onchange(this); }; return select; } /** Creates a toggle-switch <label> wrapping a checkbox for the given settings key. */ function makeToggle(settingKey) { var setting = ja_settings[settingKey]; var toggleLabel = document.createElement('label'); toggleLabel.className = 'ja-toggle'; var input = document.createElement('input'); input.type = 'checkbox'; input.id = setting.elementId; input.onchange = function () { ja_onchange(this); }; var slider = document.createElement('span'); slider.className = 'ja-toggle-slider'; toggleLabel.appendChild(input); toggleLabel.appendChild(slider); return toggleLabel; } /** Creates a number <input> wired to ja_onchange for the given settings key. */ function makeNumber(settingKey) { var setting = ja_settings[settingKey]; var input = document.createElement('input'); input.type = 'number'; input.id = setting.elementId; input.min = setting.min; input.max = setting.max; input.onchange = function () { ja_onchange(this); }; return input; } /** Creates a color <input> wired to ja_onchange for the given settings key. */ function makeColor(settingKey) { var setting = ja_settings[settingKey]; var input = document.createElement('input'); input.type = 'color'; input.id = setting.elementId; input.onchange = function () { ja_onchange(this); }; return input; } // ── Script header ────────────────────────────────────────────────── var header = document.createElement('div'); header.className = 'ja-header'; var headerLeft = document.createElement('div'); headerLeft.className = 'ja-header-left'; var headerIcon = document.createElement('i'); headerIcon.className = 'fa fa-code-fork ja-header-icon'; var headerName = document.createElement('span'); headerName.className = 'ja-header-name'; headerName.textContent = ja_getMessage('name'); headerLeft.appendChild(headerIcon); headerLeft.appendChild(headerName); var headerVersion = document.createElement('span'); headerVersion.className = 'ja-header-version'; headerVersion.textContent = 'v' + SCRIPT_VERSION; header.appendChild(headerLeft); header.appendChild(headerVersion); jaTabPane.appendChild(header); // ── Display card ─────────────────────────────────────────────────── var displayCard = makeCard('fa-cog', 'Display'); displayCard.body.appendChild(makeRow(ja_getMessage('angleMode'), makeSelect('angleMode'))); displayCard.body.appendChild(makeRow(ja_getMessage('angleDisplay'), makeSelect('angleDisplay'))); displayCard.body.appendChild(makeRow(ja_getMessage('angleDisplayArrows'), makeSelect('angleDisplayArrows'))); displayCard.body.appendChild(makeRow(ja_getMessage('decimals'), makeNumber('decimals'))); displayCard.body.appendChild(makeRow(ja_getMessage('pointSize'), makeNumber('pointSize'))); jaTabPane.appendChild(displayCard.card); // ── Routing instructions card ────────────────────────────────────── var routingCard = makeCard('fa-road', 'Routing instructions'); routingCard.body.appendChild(makeRow(ja_getMessage('guess'), makeToggle('guess'))); routingCard.body.appendChild(makeRow(ja_getMessage('override'), makeToggle('override'), 'ja-sub-row')); routingCard.body.appendChild(makeRow(ja_getMessage('overrideAngles'), makeToggle('overrideAngles'), 'ja-sub-row ja-sub-sub-row')); jaTabPane.appendChild(routingCard.card); // ── Instruction colors card ──────────────────────────────────────── var colorsCard = makeCard('fa-paint-brush', 'Instruction colors'); colorsCard.body.className += ' ja-colors-grid'; ['noInstructionColor', 'continueInstructionColor', 'keepInstructionColor', 'exitInstructionColor', 'turnInstructionColor', 'uTurnInstructionColor', 'noTurnColor', 'problemColor'].forEach( function (key) { colorsCard.body.appendChild(makeRow(ja_getMessage(key), makeColor(key))); }, ); jaTabPane.appendChild(colorsCard.card); // ── Roundabout card ──────────────────────────────────────────────── var roundaboutCard = makeCard('fa-circle-o', 'Roundabout'); roundaboutCard.body.appendChild(makeRow(ja_getMessage('roundaboutOverlayDisplay'), makeSelect('roundaboutOverlayDisplay'))); roundaboutCard.body.appendChild(makeRow(ja_getMessage('roundaboutOverlayColor'), makeColor('roundaboutOverlayColor'), 'ja-sub-row')); roundaboutCard.body.appendChild(makeRow(ja_getMessage('roundaboutColor'), makeColor('roundaboutColor'), 'ja-sub-row')); jaTabPane.appendChild(roundaboutCard.card); // ── U-Turn detection card ────────────────────────────────────────── var uturnsCard = makeCard('fa-undo', 'U-Turn detection road types'); uturnsCard.body.appendChild(makeRow(ja_getMessage('uTurnIncludeStreet'), makeToggle('uTurnIncludeStreet'))); uturnsCard.body.appendChild(makeRow(ja_getMessage('uTurnIncludeParkingLot'), makeToggle('uTurnIncludeParkingLot'))); uturnsCard.body.appendChild(makeRow(ja_getMessage('uTurnIncludePrivateRoad'), makeToggle('uTurnIncludePrivateRoad'))); uturnsCard.body.appendChild(makeRow(ja_getMessage('wazeDoubleUTurnRestriction'), makeToggle('wazeDoubleUTurnRestriction'))); jaTabPane.appendChild(uturnsCard.card); // ── Experimental card ────────────────────────────────────────────── var experimentalCard = makeCard('fa-flask', 'Experimental'); experimentalCard.body.appendChild(makeRow(ja_getMessage('enableFarTurnJB'), makeToggle('enableFarTurnJB'))); experimentalCard.body.appendChild(makeRow(ja_getMessage('enableFarTurnPath'), makeToggle('enableFarTurnPath'))); experimentalCard.body.appendChild(makeRow(ja_getMessage('continuousScanning'), makeToggle('continuousScanning'))); jaTabPane.appendChild(experimentalCard.card); // ── Footer: reset button + info links ────────────────────────────── var footer = document.createElement('div'); footer.className = 'ja-footer'; var resetBtn = document.createElement('button'); resetBtn.type = 'button'; resetBtn.className = 'btn btn-default'; resetBtn.addEventListener('click', ja_reset, true); resetBtn.textContent = ja_getMessage('resetToDefault'); footer.appendChild(resetBtn); var infoList = document.createElement('ul'); infoList.className = 'list-unstyled'; infoList.appendChild(ja_helpLink('https://github.com/WazeDev/WME-JAI/blob/development/USER-SETTINGS.md', 'settingsguide')); infoList.appendChild(ja_helpLink('https://www.waze.com/discuss/t/roundabout/377970', 'roundaboutnav')); infoList.appendChild(ja_helpLink('https://www.waze.com/discuss/t/how-waze-determines-turn-keep-exit-maneuvers/378038', 'wazeAlgorithm')); infoList.appendChild(ja_helpLink('https://www.waze.com/discuss/t/script-wme-junction-angle-info/52238', 'ghissues')); footer.appendChild(infoList); jaTabPane.appendChild(footer); } /** * Entry point called once after the WME SDK bootstrap resolves. * * Responsibilities (in order): * 1. **Event registration** — wires SDK events for selection changes, segment/node data model * changes, map zoom/move, and user settings changes to their respective handlers. * 2. **Settings & translations** — calls `ja_load()` to restore saved options from * `localStorage`, `ja_loadTranslations()` to install the i18n strings, and * `showScriptInfoAlert()` to display a WazeWrap update banner if the version changed. * 3. **Map layer** — creates the `junction_angles` SDK layer with the style context and rules * built by `ja_build_style_context()` / `ja_build_style_rules()`, then sets * `ja_layer_created = true` so `ja_apply()` can proceed. * 4. **Sidebar** — registers the script tab with the SDK, injects the power button into the * tab label, sets up `setupHtml()`, and binds `ja_setLayerEnabled()` to both the Map * Layers checkbox event and the power button click. * 5. **Initial render** — calls `ja_apply()` and `ja_calculate()` to populate controls and * draw angle markers for whatever is currently selected in WME. */ async function junctionangle_init() { // ── Event registration ──────────────────────────────────────────── sdk.Events.on({ eventName: 'wme-selection-changed', eventHandler: testSelectedItem }); sdk.Events.trackDataModelEvents({ dataModelName: 'segments' }); sdk.Events.on({ eventName: 'wme-data-model-objects-changed', eventHandler: function (payload) { if (payload.dataModelName === 'segments' && hasSelection()) { ja_calculate(); } }, }); sdk.Events.on({ eventName: 'wme-data-model-objects-removed', eventHandler: function (payload) { if (payload.dataModelName === 'segments' && hasSelection()) { ja_calculate(); } }, }); sdk.Events.trackDataModelEvents({ dataModelName: 'nodes' }); sdk.Events.on({ eventName: 'wme-data-model-objects-changed', eventHandler: function (payload) { if (payload.dataModelName === 'nodes' && hasSelection()) { ja_calculate(); } }, }); sdk.Events.on({ eventName: 'wme-data-model-objects-removed', eventHandler: function (payload) { if (payload.dataModelName === 'nodes' && hasSelection()) { ja_calculate(); } }, }); // ── BigJunction (Junction Box) change tracking (experimental) ───────── // Junction Box data lives in the BigJunctions data model, separate from segments // and nodes. Without this tracking, adding, editing, or deleting a Junction Box // while a segment is selected would not refresh the far turn markers — the user // would have to deselect and reselect to see the updated state. // // We mirror the same pattern used for 'segments' and 'nodes' above: track the // data model and re-run ja_calculate() on change or removal events. sdk.Events.trackDataModelEvents({ dataModelName: 'bigJunctions' }); sdk.Events.on({ eventName: 'wme-data-model-objects-changed', eventHandler: function (payload) { if (payload.dataModelName === 'bigJunctions' && hasSelection()) { ja_calculate(); } }, }); sdk.Events.on({ eventName: 'wme-data-model-objects-removed', eventHandler: function (payload) { if (payload.dataModelName === 'bigJunctions' && hasSelection()) { ja_calculate(); } }, }); sdk.Events.on({ eventName: 'wme-map-zoom-changed', eventHandler: function () { if (hasSelection()) { ja_calculate(); } }, }); sdk.Events.on({ eventName: 'wme-map-move-end', eventHandler: function () { // On-demand roundabout overlay: only update if setting is "Always" and something is selected if (ja_options.roundaboutOverlayDisplay === 'rOverAlways' && hasSelection()) { if (sdk.Map.getZoomLevel() >= MIN_ZOOM_LEVEL) { ja_calculate(); } } // Continuous scanning: trigger on every pan (if enabled, regardless of selection) if (ja_continuous_mode) { ja_debounced_continuous_scan(); } }, }); // PHASE 3: Continuous Scanning Event Handlers ──────────────────── // Wire up zoom and move events to trigger debounced continuous scans sdk.Events.on({ eventName: 'wme-map-zoom-changed', eventHandler: function () { if (ja_continuous_mode) { ja_debounced_continuous_scan(); } }, }); // Track segment/node/turn edits and clear relevant cache entries sdk.Events.on({ eventName: 'wme-data-model-objects-changed', eventHandler: function (payload) { ja_log('*** CONTINUOUS CACHE HANDLER: dataModelName=' + payload.dataModelName + ', ja_continuous_mode=' + ja_continuous_mode + ', hasObjects=' + (payload.objects ? payload.objects.length : 0) + ', payload keys=' + Object.keys(payload).join(','), 2); if (ja_continuous_mode && (payload.dataModelName === 'segments' || payload.dataModelName === 'nodes' || payload.dataModelName === 'turns')) { var nodeIds = []; // Collect node IDs from affected segments if (payload.dataModelName === 'segments' && payload.objects && payload.objects.length > 0) { for (var i = 0; i < payload.objects.length; i++) { var seg = payload.objects[i]; if (seg.fromNodeId) nodeIds.push(seg.fromNodeId); if (seg.toNodeId) nodeIds.push(seg.toNodeId); } ja_log('Cache invalidation: clearing ' + nodeIds.length + ' nodes affected by ' + payload.objects.length + ' segment edits', 2); } // Collect node IDs from affected turns if (payload.dataModelName === 'turns' && payload.objects && payload.objects.length > 0) { for (var i = 0; i < payload.objects.length; i++) { var turn = payload.objects[i]; // Turn has nodeId property (the junction node) if (turn.nodeId) nodeIds.push(turn.nodeId); } ja_log('Cache invalidation: clearing ' + nodeIds.length + ' nodes affected by ' + payload.objects.length + ' turn edits', 2); } // Collect node IDs from affected nodes (geometry changes) if (payload.dataModelName === 'nodes' && payload.objects && payload.objects.length > 0) { for (var i = 0; i < payload.objects.length; i++) { var node = payload.objects[i]; if (node.id) nodeIds.push(node.id); } ja_log('Cache invalidation: clearing ' + nodeIds.length + ' nodes directly affected by ' + payload.objects.length + ' node geometry edits', 2); } // Clear cache and rendered entries for all affected nodes for (var j = 0; j < nodeIds.length; j++) { var nId = nodeIds[j]; delete ja_continuous_cache[nId]; ja_log('Cleared cache for node ' + nId, 3); // Remove all rendered markers for this node (they'll be recalculated) var keysToDelete = []; ja_continuous_rendered.forEach(function (key) { if (key.startsWith(nId + '_')) { keysToDelete.push(key); } }); keysToDelete.forEach(function (key) { ja_continuous_rendered.delete(key); ja_log('Invalidated rendered marker: ' + key, 3); }); } if (nodeIds.length > 0) { ja_log('Cache cleared for ' + nodeIds.length + ' affected nodes, triggering debounced scan', 2); ja_debounced_continuous_scan(); } } }, }); sdk.Events.on({ eventName: 'wme-user-settings-changed', eventHandler: function () { ja_loadTranslations(); if (ja_sidebar_tabPane) { setupHtml(ja_sidebar_tabPane); } ja_apply(); }, }); // ── Translations & sidebar HTML ─────────────────────────────────── ja_load(); ja_loadTranslations(); showScriptInfoAlert(); // ── SDK map layer ───────────────────────────────────────────────── sdk.Map.addLayer({ layerName: 'junction_angles', styleContext: ja_build_style_context(), styleRules: ja_build_style_rules(), }); ja_layer_created = true; // ── SDK Sidebar ─────────────────────────────────────────────────── const { tabLabel: jaTabLabel, tabPane: jaTabPane } = await sdk.Sidebar.registerScriptTab(); // ── Tab label with power button ─────────────────────────────────── jaTabLabel.innerHTML = '<span id="ja-power-btn" class="fa fa-power-off"' + ' style="margin-right:5px;cursor:pointer;color:#00bd00;font-size:13px;"' + ' title="Toggle Junction Angles"></span>' + '<span title="Junction Angle Info">JAI</span>'; jaTabPane.id = 'sidepanel-ja'; jaTabPane.classList.add('wme-ja-panel'); ja_sidebar_tabPane = jaTabPane; setupHtml(jaTabPane); ja_apply(); // ── Shared toggle — called by both the power button and the layer checkbox ── /** * Single source of truth for enabling/disabling the junction_angles map layer. * * Updates `ja_layer_visible`, sets SDK layer visibility, syncs the Map Layers checkbox * (without firing `wme-layer-checkbox-toggled` — that event only fires on user interaction), * and updates the power button colour in the sidebar tab label. * * Both the power button click handler and the `wme-layer-checkbox-toggled` event handler * call this function to avoid circular update loops. * * @param {boolean} enabled - True to show the layer; false to hide it. */ function ja_setLayerEnabled(enabled) { ja_layer_visible = enabled; // When layer is disabled, also stop continuous scanning (no point scanning if layer is hidden) if (!enabled) { if (ja_continuous_mode) { ja_continuous_mode = false; if (ja_continuous_scan_timer) { clearTimeout(ja_continuous_scan_timer); ja_continuous_scan_timer = null; } ja_log('Layer disabled. Stopping continuous scanning.', 2); } } else { // When layer is re-enabled, restart continuous scanning if the setting is on if (ja_continuous_enabled && !ja_continuous_mode) { ja_continuous_mode = true; ja_log('Layer enabled. Resuming continuous scanning.', 2); ja_start_continuous_scan(); } } // Persist layer visibility state to localStorage if (localStorage) { localStorage.setItem('wme_ja_layer_visible', ja_layer_visible ? 'true' : 'false'); } sdk.Map.setLayerVisibility({ layerName: 'junction_angles', visibility: ja_layer_visible }); sdk.LayerSwitcher.setLayerCheckboxChecked({ name: 'Junction Angle Info', isChecked: ja_layer_visible }); var btn = jaTabLabel.querySelector('#ja-power-btn'); if (btn) { btn.style.color = ja_layer_visible ? '#00bd00' : '#ccc'; } } // ── Layer visibility checkbox ───────────────────────────────────── // Restore layer visibility state from localStorage (default to true if not saved) if (localStorage) { var savedVisibility = localStorage.getItem('wme_ja_layer_visible'); ja_layer_visible = savedVisibility === 'false' ? false : true; } sdk.LayerSwitcher.addLayerCheckbox({ name: 'Junction Angle Info', isChecked: ja_layer_visible }); sdk.Events.on({ eventName: 'wme-layer-checkbox-toggled', eventHandler: function (evt) { if (evt.name === 'Junction Angle Info') { ja_setLayerEnabled(evt.checked); } }, }); // ── Auto-refresh on turn instruction/restriction changes ────────────── // When a user edits a turn (changes instruction, adds/removes restrictions, etc.), // automatically recalculate JAI markers if a segment or node is currently selected. // This prevents stale markers when turn data changes in-place. sdk.Events.on({ eventName: 'wme-after-edit', eventHandler: function () { // Check if we have a current selection (segment, node, or multiple items) var currentSel = sdk.Editing.getSelection(); if (currentSel && currentSel.ids && currentSel.ids.length > 0) { // Recalculate markers for the currently selected items ja_calculate(); } }, }); // ── Power button click ──────────────────────────────────────────── jaTabLabel.addEventListener('click', function (e) { if (e.target && e.target.id === 'ja-power-btn') { ja_setLayerEnabled(!ja_layer_visible); e.stopPropagation(); } }); // ── Apply saved visibility state to layer ───────────────────────── if (!ja_layer_visible) { // If saved state is off, hide the layer immediately sdk.Map.setLayerVisibility({ layerName: 'junction_angles', visibility: false }); var btn = jaTabLabel.querySelector('#ja-power-btn'); if (btn) { btn.style.color = '#ccc'; } } ja_apply(); ja_calculate(); } junctionangle_init(); })();
