☰

WME Select Same Type Roads

This script add functionnality to select and modify roads

当前为 2014-10-05 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name WME Select Same Type Roads
  3. // @author buchet37
  4. // @namespace https://greasyfork.org/users/4062
  5. // @description This script add functionnality to select and modify roads
  6. // @match https://world.waze.com/editor/*
  7. // @match https://www.waze.com/editor/*
  8. // @match https://world.waze.com/map-editor/*
  9. // @match https://www.waze.com/map-editor/*
  10. // @include https://*.waze.com/editor/*
  11. // @include https://*.waze.com/*/editor/*
  12. // @include https://*.waze.com/map-editor/*
  13. // @include https://*.waze.com/beta_editor/*
  14. // @include https://descarte*.waze.com/beta/*
  15. // @include https://editor-beta.waze.com/*
  16. // @grant      none
  17. // @version         4.9.5
  18. // ==/UserScript==
  19.  
  20. // Based on Street to River ( http://userscripts.org/scripts/show/122049 )
  21. // Thanks to alcolo47 (some functions are based on WME Extented Tools)
  22. // Thanks to gdu1971, bgodette, Timbones for part of code 
  23. // Adapted by buchet37 for "Select Same Type Road"
  24.  
  25. // Mini howto:
  26. // 1) install this script as greasemonkey script or chrome extension
  27. // 2) Select 2 segments 
  28. // 3) Click the "Select Roads A<=>B" button
  29. // The script will select all same type road between A and B with a limit of 50 segments
  30.  
  31.  
  32. if ('undefined' == typeof __RTLM_PAGE_SCOPE_RUN__) {
  33.   (function page_scope_runner() {
  34.     // If we're _not_ already running in the page, grab the full source
  35.     // of this script.
  36.     var my_src = "(" + page_scope_runner.caller.toString() + ")();";
  37.  
  38.     // Create a script node holding this script, plus a marker that lets us
  39.     // know we are running in the page scope (not the Greasemonkey sandbox).
  40.     // Note that we are intentionally *not* scope-wrapping here.
  41.     var script = document.createElement('script');
  42.     script.setAttribute("type", "text/javascript");
  43.     script.textContent = "var __RTLM_PAGE_SCOPE_RUN__ = true;\n" + my_src;
  44.  
  45.     // Insert the script node into the page, so it will run, and immediately
  46.     // remove it to clean up.  Use setTimeout to force execution "outside" of
  47.     // the user script scope completely.
  48.     setTimeout(function() {
  49. 					document.body.appendChild(script);
  50.           document.body.removeChild(script);
  51.         }, 0);
  52.   })();
  53.  
  54.   // Stop running, because we know Greasemonkey actually runs us in
  55.   // an anonymous wrapper.
  56.   return;
  57. }
  58.  
  59. //	function t(toto) {
  60. 	//	return require.modules[eval(toto)];
  61. 	//}
  62.  
  63.  
  64.  
  65. function selectSameTypeRoad() {
  66.   
  67. 	var defaultWidth = "15 m";  //Default Width is equal to 15m
  68.   
  69. 	// *****************   COMPATIBILITY WITH NEW EDITOR   ***********
  70. 	var WazeActionCreateObject = require("Waze/Action/CreateObject");
  71. 	var WazeActionCreateRoundabout = require ("Waze/Action/CreateRoundabout");
  72. 	var WazeActionDeleteSegment = require ("Waze/Action/DeleteSegment");
  73. 	var WazeActionModifyConnection = require ("Waze/Action/ModifyConnection");
  74. 	var WazeActionMultiAction = require ("Waze/Action/MultiAction");
  75. 	var WazeActionUpdateObject = require("Waze/Action/UpdateObject");
  76. 	var WazeActionUpdateSegmentGeometry = require("Waze/Action/UpdateSegmentGeometry");
  77. 	var WazeFeatureVectorLandmark = require("Waze/Feature/Vector/Landmark");
  78. 	var WazeActionAddLandmark = require("Waze/Action/AddLandmark");
  79. 	
  80.   // *****************************************************************
  81. 	
  82. 	insertButton()
  83.   function insertButton() {
  84. 	 
  85. 		if(document.getElementById('WME_SSTR_All') != null) return;
  86. 	    
  87. 		var chk1 = $('<Label style="font-weight:normal"><input type="checkbox"; style="vertical-align: middle;margin: 0px;" id="WME_SSTR_enable"	title="Enable or Disable WME SSTR">On-Off   </input></Label>');   	
  88. 		var chk2 = $('<Label style="font-weight:normal"><input type="checkbox"; style="vertical-align: middle;margin: 0px;" id="WME_SSTR_SmthRvr" title="Check for smoothing">Smooth</input></Label>');   
  89. 		var chk3 = $('<Label style="font-weight:normal"><input type="checkbox"; style="vertical-align: middle;margin: 0px;" id="WME_SSTR_SmthPlt" title="Check for smoothing">Smooth</input></Label>'); 	
  90. 		var url1 = $('<div style="font-size:12px;display: inline;"> <u><i><a href="https://greasyfork.org/scripts/4715-wme-select-same-type-roads" target="_blank">Select Same Type Road V4.9.5</a></i></u>');
  91. 		
  92. 		var btn1 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Select 1 or more segments and click this button">Select Same Type Roads</button>');
  93. 		var btn2 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Select adjacent segment from node A">Side A</button>');
  94. 		var btn3 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Select adjacent segment from node B">Side B</button>');
  95. 		var btn4 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Start from segment 1 to join Segment 2 (if possible)">1 => 2</button>');
  96. 		var btn6 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Create a ParkingLot from railroad geometry">Railroad => PkgLot</button>');
  97. 		var btn7 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Create a River from Street Geometry">Street => River</button>');
  98. 		var btn8 = $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Select road(s) to make an Overall Landmark">Do Landmark</button>');
  99. 		var btn10= $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="Make a new roundabout from 1 segment of an old one or a set of segments">Redo Roundabout</button>');
  100. 		var btn12= $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="click this button to suppress road geometry">Clear Road Geometry</button>');
  101. 		var btn13= $('<button class="btn btn-default" style="padding:0px 10px; height:22px" title="click this button to allow "All drives" and "All Turns" on selected roads)">All drives on Selection</button>');
  102. 		
  103. 		btn1.click	(select_same_type_roads);
  104. 		btn2.click	(Side_A);
  105. 		btn3.click	(Side_B);
  106. 		btn4.click	(select_AB);
  107. 		btn6.click	(Railroad_ParkingLot);
  108. 		btn7.click	(Street_River);
  109. 		btn8.click	(Roads_to_Interchange);
  110. 		btn10.click (Redo_RoundAbout);
  111. 		btn12.click (Clear_Road_Geometry);
  112. 		btn13.click (All_drives_on_Selection);
  113. 		
  114. 		var WME_SSTR_Menu = $ ('<div id="WME_SSTR_All" style="height: auto;width:100%;"/>');  
  115. 			
  116. 		var cnt0 = $('<section id="WME_SSTR_lnk"		style="padding-top:2px"/>'); cnt0.append(chk1);cnt0.append(" ");cnt0.append(url1);
  117. 		var cnt1 = $('<section id="WME_SSTR"				style="padding-top:2px"/>'); cnt1.append(btn1);
  118. 		var cnt2 = $('<section id="WME_SSTR_Side"		style="padding-top:2px; padding-bottom:5px"/>'); cnt2.append(btn2); cnt2.append(" ");cnt2.append(btn3);
  119. 		var cnt3 = $('<section id="WME_SSTR_12"			style="padding-top:2px; padding-bottom:5px"/>'); cnt3.append(btn4);
  120. 		var cnt4 = $('<section id="WME_SSTR_River"	style="padding-top:2px"/>'); cnt4.append(btn7); cnt4.append(" ");cnt4.append(chk2);
  121. 		var cnt5 = $('<section id="WME_SSTR_Pklt"		style="padding-top:2px"/>'); cnt5.append(btn6); cnt5.append(" ");cnt5.append(chk3);
  122. 		var cnt6 = $('<section id="WME_SSTR_Ldmk"		style="padding-top:2px"/>'); cnt6.append(btn8);
  123. 		var cnt7 = $('<section id="WME_SSTR_Rdt"		style="padding-top:2px; padding-bottom:5px"/>'); cnt7.append(btn10);
  124. 		var cnt8 = $('<section id="WME_SSTR_CrgAds"	style="padding-top:2px"/>'); cnt8.append(btn12); cnt8.append(" ");cnt8.append(btn13);
  125. 		
  126. 		WME_SSTR_Menu.append(cnt0);
  127. 		WME_SSTR_Menu.append(cnt1);
  128. 		WME_SSTR_Menu.append(cnt2);
  129. 		WME_SSTR_Menu.append(cnt3);
  130. 		WME_SSTR_Menu.append(cnt4);									// Problems in new editor
  131. 		WME_SSTR_Menu.append(cnt5);
  132. 		WME_SSTR_Menu.append(cnt6);
  133. 		WME_SSTR_Menu.append(cnt7);
  134. 		WME_SSTR_Menu.append(cnt8);
  135. 		
  136. // ******* Mise en place des buttons      
  137. 		var WME_SSTR_MenuFlag = false, myDialogBoxFlag = false;
  138.      function put_WME_SSTR_Menu() {        // wait for 'sidebar'
  139.        if (document.getElementById('sidebar')!=null) { 							
  140. 				if (document.getElementById('WME_JCB_All')!=null) {   // si mon menu existe
  141. 					$("#WME_JCB_All").append('<hr style="margin-bottom:5px; margin-top:5px;width=100%;color:SkyBlue; background-color:SkyBlue; height:1px;">');}     // on ajoute une barre	
  142. 				else {
  143. 				  var WME_JCB_Menu = $ ('<div id="WME_JCB_All" style="padding:2px 5px 2px 5px;margin:5px 0px 30px 0px;width:295px; border-width:3px; border-style:double;border-color: SkyBlue; border-radius:10px"/>');  
  144. 					$("#sidebar").append(WME_JCB_Menu);
  145. 				}
  146. 				$("#WME_JCB_All").append(WME_SSTR_Menu);		// on ajoute le nemu CRN
  147. 				WME_SSTR_MenuFlag = true;				
  148. 			}
  149.        else {
  150. 				setTimeout (function () {put_WME_SSTR_Menu();}, 501);
  151. 			}
  152.      }
  153.      put_WME_SSTR_Menu();
  154. 		
  155. 		// Boite d'alerte
  156. 		var myAlertBoxFlag = false;
  157. 		function put_myAlertBox() {
  158. 			if (document.getElementById('map-search')!=null) {
  159. 				if (document.getElementById('WME_JCB_AlertBox')==null) { 
  160. 					var myAlertBox = $('<div id="WME_JCB_AlertBox" class="form-control search-query" style="opacity : 0.8;display :none;  height: auto;min-height: 30px; position: absolute;top :16px; margin-left: 350px; margin-right: auto; "/>');	
  161. 					var myAlertTxt = $('<div id="WME_JCB_AlertTxt" style=" opacity : 1;display:inline;padding:0px 0px">City ID/');
  162. 					myAlertBox.append(myAlertTxt);
  163. 					$("#map-search").append(myAlertBox)
  164. 			  }
  165. 				myAlertBoxFlag = true;
  166. 			}
  167.       else {setTimeout (function () {put_myAlertBox();}, 501);}
  168. 		}
  169.     put_myAlertBox();
  170. 		 
  171.  
  172. 		 
  173. 		 function start_init_WME_SSTR() {         // si tous les boutons sont chargés on démarre le script
  174. 			if (WME_SSTR_MenuFlag && myAlertBoxFlag) {
  175. 				init_WME_SSTR();
  176. 			}
  177.       else {setTimeout(function () {start_init_WME_SSTR();}, 501);}
  178.      }
  179.      start_init_WME_SSTR();
  180. 	}
  181. 	
  182. 	function Clear_Road_Geometry(ev) {
  183. 		if (Waze.selectionManager.selectedItems.length!=0) {
  184. 			if (confirm ("Do you want to clear the geometry for selected segments") ) {
  185. 				for (var i = 0; i < Waze.selectionManager.selectedItems.length; i++) {
  186. 					var seg = Waze.selectionManager.selectedItems[i].model;
  187. 					if (seg.type == "segment") {
  188. 						var newGeo = seg.geometry.clone();
  189. 						newGeo.components.splice(1,newGeo.components.length -2);														// on garde le 1er et le dernier point
  190. 						newGeo.components[0].calculateBounds();
  191. 						newGeo.components[1].calculateBounds(); 
  192. 						Waze.model.actionManager.add (new WazeActionUpdateSegmentGeometry (seg,seg.geometry,newGeo));	
  193. 					}
  194. 				}
  195. 			}
  196. 		}
  197. 	}
  198. 	
  199. 	function All_drives_on_Selection(ev) {
  200. 		if (Waze.selectionManager.selectedItems.length!=0) {
  201. 			var action = [];
  202. 			var nodeToAllowed = [];
  203. 			var selectRoadIDs = [];
  204. 			for (var i = 0; i < Waze.selectionManager.selectedItems.length; i++) {
  205. 				var seg = Waze.selectionManager.selectedItems[i].model;
  206. 				if (seg != null && seg.type == "segment" && !seg.attributes.locked && seg.attributes.junctionID == null) {
  207. 				selectRoadIDs.push (seg.getID());
  208. 				//action.push (new Waze.Action.UpdateObject( seg, {fwdDirection: true, revDirection: true}));		// pass to two ways
  209. 				action.push (new WazeActionUpdateObject( seg, {fwdDirection: true, revDirection: true}));		// pass to two ways
  210. 					if (Waze.model.nodes.objects[seg.attributes.fromNodeID]!= null) {																			// store node A
  211. 						nodeToAllowed.push (seg.attributes.fromNodeID);	}																	
  212. 					if (Waze.model.nodes.objects[seg.attributes.toNodeID]!= null) {																				// store node B
  213. 						nodeToAllowed.push (seg.attributes.toNodeID);	}			
  214. 				}
  215. 			}
  216. 			nodeToAllowed = areTwice (nodeToAllowed);																						// on ne traite que les segments inttermédiaires
  217. 			for (var l = 0; l < nodeToAllowed.length; l++) {
  218. 				var node = Waze.model.nodes.objects[nodeToAllowed[l]];
  219. 				var roadIDs =	node.attributes.segIDs;
  220. 				for (var j = 0; j < roadIDs.length; j++) {
  221. 					for (var k = 0; k < roadIDs.length; k++) {
  222. 						if (roadIDs[j]!= roadIDs[k] && isInArray (roadIDs[j],selectRoadIDs) && isInArray (roadIDs[k],selectRoadIDs)) {
  223. 							//action.push (new Waze.Action.ModifyConnection(roadIDs[j], node, roadIDs[k], true));
  224. 							action.push (new WazeActionModifyConnection(roadIDs[j], node, roadIDs[k], true));
  225. 						}
  226. 					}
  227. 				}
  228. 			}
  229. 			//if (action.length !=0) { Waze.model.actionManager.add (new Waze.Action.MultiAction(action));}
  230. 			if (action.length !=0) { Waze.model.actionManager.add (new WazeActionMultiAction(action));}
  231. //alert ("On va au bout");
  232. 		}
  233. 	}
  234.  
  235. 	function areTwice (myArray) {
  236. 		var myNewArray = [];
  237. 		if (myArray.length > 0) {
  238. 			for (var i = 0; i < myArray.length-1; i++) {
  239. 				for (var j = i+1; j < myArray.length; j++) {
  240. 					if (myArray [i] == myArray[j]) {
  241. 						myNewArray.push(myArray [i]);
  242. 					}
  243. 				}	
  244. 			}	
  245. 			return delete_multi_Ids(myNewArray);
  246. 		}
  247. 		else {
  248. 			return (myArray);
  249. 		}
  250. 	}
  251. 	
  252. 	function Redo_RoundAbout (ev) {
  253. 		var selectedGood = (Waze.selectionManager.selectedItems.length!=0);
  254. 		if (selectedGood) {
  255. 			if (Waze.selectionManager.selectedItems[0].model.attributes.junctionID !=null) {			
  256. 				var sel = Waze.selectionManager.selectedItems[0].model;
  257. 				var junc = Waze.model.junctions.objects[sel.attributes.junctionID];
  258. 				var listRoadIds = junc.segIDs;
  259. 				//var listId 
  260. 				}
  261. 			else {
  262. 				var listRoadIds = [];
  263. 				for (var i = 0; i < Waze.selectionManager.selectedItems.length; i++) {
  264. 					var sel = Waze.selectionManager.selectedItems[i].model;
  265. 					listRoadIds.push (sel.getID());
  266. 				}
  267. 			}
  268.  
  269. //alert (listRoadIds.length);
  270. 			
  271. 			var oldRdt = extract_rdt (listRoadIds);
  272. 			
  273. 			if (oldRdt.higherRank == false) {
  274. 				var action = [];
  275. 				for (var j = 0; j < oldRdt.listRoadIds.length; j++) {
  276. 					var seg = Waze.model.segments.objects[oldRdt.listRoadIds[j]]
  277. 					//action.push(new Waze.Action.DeleteSegment(seg));																// ******* Delete Roundabout
  278. 					action.push(new WazeActionDeleteSegment(seg));																// ******* Delete Roundabout
  279.  
  280. 				}
  281. 				for (var i = 0; i < oldRdt.listAdjRoadIds.length; i++) {
  282. 					var seg = Waze.model.segments.objects[oldRdt.listAdjRoadIds[i].id];
  283. 					var newGeo = seg.geometry.clone();
  284. 					if (oldRdt.listAdjRoadIds[i].sideConnect == "A") {
  285. 						var index1 =0;
  286. 						var index2 =1;
  287. 						var nodeEnd = Waze.model.nodes.objects [seg.attributes.toNodeID];
  288. 					}
  289. 					else {
  290. 						var index1 = newGeo.components.length-1;
  291. 						var index2 = newGeo.components.length-2;
  292. 						var nodeEnd = Waze.model.nodes.objects [seg.attributes.fromNodeID];
  293. 					}
  294. 					if (nodeEnd !=null && nodeEnd.onScreen() && nodeEnd.attributes.segIDs.length <2) {
  295. 						action.push (new Waze.Action.UpdateObject(seg, {fwdDirection: true, revDirection: true}));} // dead-end is always two ways roads	
  296. 					if (!seg.attributes.fwdDirection && !seg.attributes.revDirection) {																	// unknown roads are fixed to two ways roads
  297. 						action.push (new Waze.Action.UpdateObject(seg, {fwdDirection: true, revDirection: true}));}
  298. 					var deltaX = newGeo.components[index1].x - newGeo.components[index2].x;
  299. 					var deltaY = newGeo.components[index1].y - newGeo.components[index2].y;
  300. 					var angle = angleDeg (deltaX,deltaY);
  301. 					var meanExt = 0.10 * (oldRdt.rx + oldRdt.ry);
  302. 					newGeo.components[index1].x = newGeo.components[index1].x + meanExt* Math.cos(convertDegRad(angle));
  303. 					newGeo.components[index1].y = newGeo.components[index1].y + meanExt* Math.sin(convertDegRad(angle));
  304. 					newGeo.components[index1].calculateBounds(); 
  305. 					//action.push(new Waze.Action.UpdateSegmentGeometry (seg,seg.geometry,newGeo));
  306. 					action.push(new WazeActionUpdateSegmentGeometry (seg,seg.geometry,newGeo));
  307. 				}
  308. 				//Waze.model.actionManager.add (new Waze.Action.MultiAction(action));						// *******  Strech adjacent segments
  309. 				Waze.model.actionManager.add (new WazeActionMultiAction(action));						// *******  Strech adjacent segments
  310. 				var R = {};
  311. 				R.center = {x: oldRdt.centerX, y:oldRdt.centerY};
  312. 				R.rx  = Math.min (parseInt(144),oldRdt.rx);	
  313. 				R.ry  = Math.min (parseInt(144),oldRdt.ry);
  314. 				if (Math.abs (R.rx - R.ry) < (0.15 * R.rx)) {																		// if Rx near Ry => Circle with mean value
  315. 					R.rx = (R.rx + R.ry) / 2;
  316. 					R.ry =  R.rx;
  317. 				}
  318. 				R.bounds = new OpenLayers.Bounds(R.center.x - R.rx, R.center.y - R.ry, R.center.x+R.rx, R.center.y + R.ry);	
  319. //				var action = new Waze.Action.CreateRoundabout(R);
  320. 				var action = new WazeActionCreateRoundabout(R);
  321. 				Waze.model.actionManager.add (action);
  322. 				var rbtRoadIds = [];
  323. 				for (var j = 0; j < action.roundaboutSegments.length; j++) {																				// store new SegIds
  324. 					rbtRoadIds.push (action.roundaboutSegments[j].getID());
  325. 				}
  326. 				newRdt = searchNewRdt (rbtRoadIds,oldRdt.primaryStreetID);									
  327. 				var action = [];
  328. 				for (var k = 0; k < rbtRoadIds.length; k++) {
  329. 					var road = Waze.model.segments.objects[rbtRoadIds[k]];
  330. 					//action.push(new Waze.Action.UpdateObject(road, {roadType: newRdt.roadtype, level: newRdt.level, lockRank: "0"} ));
  331. 					action.push(new WazeActionUpdateObject(road, {roadType: newRdt.roadtype, level: newRdt.level, lockRank: "0"} ));
  332. 					if (oldRdt.primaryStreetID != null) {
  333. 						//action.push(new Waze.Action.UpdateObject(road, {primaryStreetID: oldRdt.primaryStreetID}));
  334. 						action.push(new WazeActionUpdateObject(road, {primaryStreetID: oldRdt.primaryStreetID}));
  335. 					}
  336. 				}
  337. 				//Waze.model.actionManager.add(new Waze.Action.MultiAction(action));
  338. 				Waze.model.actionManager.add(new WazeActionMultiAction(action));
  339. 				select (rbtRoadIds);
  340. 			}
  341. 			else {
  342. 				alert ("Your ranking is not higher\nto redo this roundabout");
  343. 			}
  344. 		}
  345. 		else {
  346. 			alert ("Incorrect Selection : \n\nOne segment must be selected \nOr It is not Roundabout Segment");
  347. 		}
  348. 	}
  349. 		
  350. 	function searchNewRdt (listRdtSegIds,StreetID) {
  351. 		var roadpriority = [];
  352. 			roadpriority [1]	= 0; 	//"Streets"
  353. 			roadpriority [2]	= 1; 	//"Primary Street"
  354. 			roadpriority [3]	= 3;  //"Freeways"
  355. 			roadpriority [4]	= 2;	//"Ramps"
  356. 			roadpriority [6]	= 3;	//"Major Highway"
  357. 			roadpriority [7]	= 2;	//"Minor Highway"
  358. 			roadpriority [8]	= 0;	//"Dirt roads"
  359. 			roadpriority [18]	= 0;  //"Railroad"
  360. 			roadpriority [19]	= 0;	//"Runway/Taxiway"
  361. 			roadpriority [20]	= 0;  //"Parking Lot Road"
  362. 			roadpriority [5]	= 0; 	//"Walking Trails"
  363. 			roadpriority [10] = 0;  //"Pedestrian Bw"
  364. 			roadpriority [16] = 0;	//"Stairway"
  365. 			roadpriority [17] = 0;  //"Private Road"
  366. 			roadpriority [21] = 0;  //"Service Road"
  367. 			
  368. 		var priorityToRoadtype = [];
  369. 			priorityToRoadtype [0] 	= 1; 	//"Streets"
  370. 			priorityToRoadtype [1] 	= 2; 	//"Primary Street"
  371. 			priorityToRoadtype [2] 	= 7;	//"Minor Highway"
  372. 			priorityToRoadtype [3]	= 6;	//"Major Highway"
  373. 		
  374. 		var compteur = [0,0,0,0];																						//array for number of roads by type
  375. 		var listRdtNodeIds = [];
  376. 		
  377. 		for (var i = 0; i < listRdtSegIds.length; i++) {
  378. 			var road = Waze.model.segments.objects[listRdtSegIds[i]];
  379. 			if (road != null) {
  380. 				listRdtNodeIds.push (road.attributes.fromNodeID);
  381. 				listRdtNodeIds.push (road.attributes.toNodeID);
  382. 			}
  383. 		}
  384. 		listRdtNodeIds = delete_multi_Ids (listRdtNodeIds);
  385. 		
  386. 		var usedNodeIDs = [];
  387. 		usedNodeIDs.push.apply (usedNodeIDs,listRdtNodeIds);
  388. 		var rdt = {};
  389. 		rdt.level = -5;
  390. 		var action = [];
  391. 		for (var j = 0; j <listRdtNodeIds.length; j++) {															// Search connected Segments
  392. 			var node = Waze.model.nodes.objects[listRdtNodeIds[j]];
  393. 			if (node != null) {
  394. 				var nbSegs = node.attributes.segIDs.length;
  395. 				for (var k = 0; k < nbSegs;k++) {
  396. 					var road = Waze.model.segments.objects[node.attributes.segIDs[k]];
  397. 					if ((road != null) && (notInArray (road.getID(),listRdtSegIds))) {
  398. 						rdt.level = Math.max (rdt.level,road.attributes.level);
  399.  							if (road.attributes.roadType == 3 ) {																																						// Freeways are not allowed in roundabout
  400. 							action.push (new Waze.Action.UpdateObject(road, {roadType: 6}));}
  401. 						if (notInArray(road.attributes.roadType,([1,2,3,4,6,7]))) {																												// Road type on roundabout should be at least "Street"
  402. 							action.push (new Waze.Action.UpdateObject(road, {roadType: 1}));}				
  403. 						if (!road.attributes.fwdDirection && !road.attributes.revDirection) {																							// unknown roads are fixed to two ways roads
  404. 							action.push (new Waze.Action.UpdateObject(road, {fwdDirection: true, revDirection: true}));}
  405. 						if (road.attributes.primaryStreetID == null && StreetID != null) {																								// Unnamed Roadsd are named as the rdt
  406. 							 action.push(new Waze.Action.UpdateObject(road, {primaryStreetID: StreetID}));}
  407. 							if (notInArray(road.attributes.fromNodeID,usedNodeIDs) ||  notInArray(road.attributes.toNodeID,usedNodeIDs)) {
  408. 							compteur [roadpriority[road.attributes.roadType]] ++;
  409. 							usedNodeIDs.push (usedNodeIDs, road.attributes.fromNodeID);
  410. 							usedNodeIDs.push (usedNodeIDs, road.attributes.toNodeID);
  411. 						}
  412. 					}	
  413. 				}
  414. 			}
  415. 		}
  416. 		
  417. 		rdt.roadtype = priorityToRoadtype [0];
  418. 		var foundMax = false;
  419. 		for (var k = 3; k > 0; k --) {
  420. 			if ((compteur[k] > 1) &&	 (foundMax == false)) {
  421. 				rdt.roadtype = priorityToRoadtype [k];
  422. 				foundMax = true;
  423. 				}
  424. 			else {
  425. 				compteur [k-1] = compteur[k-1] + compteur[k];
  426. 				compteur [k] = 0;
  427. 			}
  428. 		}
  429. 		rdt.level ++;																								// up Roundabout level
  430. 		
  431. 		if (action.length !=0) {Waze.model.actionManager.add ( new Waze.Action.MultiAction(action));}				// do modifications if there are 
  432. 		return rdt;
  433. 	}
  434. 	
  435. 	function extractNodes (listRoadIds) {
  436. 		var nodeList = [];
  437. 		for (var i = 0; i<listRoadIds.length;i++) {
  438. 			var road = Waze.model.segments.objects[listRoadIds[i]];
  439. 			if (road != null) {
  440. 				nodeList.push (road.attributes.fromNodeID);
  441. 				nodeList.push (road.attributes.toNodeID);
  442. 			}
  443. 		}	
  444. 		return delete_multi_Ids (nodeList);
  445. 	}
  446. 	
  447. 	function extract_rdt (listIDs) {
  448. 		
  449. 		var rdt = {};
  450. 		//rdt.listNodeIds = [];
  451. 		rdt.listAdjRoadIds = [];
  452. 		rdt.higherRank = false;
  453. 		rdt.listRoadIds = listIDs;
  454. 		var xmin =  10000000000000; var ymin = xmin;
  455. 		var xmax = -10000000000000; var ymax = xmax;
  456. 		for (var i = 0; i<rdt.listRoadIds.length;i++) {
  457. 			var road = Waze.model.segments.objects[rdt.listRoadIds[i]];
  458. 			if (road != null) {
  459. 				rdt.higherRank = rdt.higherRank || road.isLockedByHigherRank();
  460. 				for (var j = 0;j < road.geometry.components.length;j++) {
  461. 					xmin = Math.min (xmin, road.geometry.components[j].x);
  462. 					xmax = Math.max (xmax, road.geometry.components[j].x);
  463. 					ymin = Math.min (ymin, road.geometry.components[j].y);
  464. 					ymax = Math.max (ymax, road.geometry.components[j].y);
  465. 				}
  466. 			}
  467. 		}
  468.  
  469. 		rdt.listNodeIds = extractNodes (rdt.listRoadIds);
  470. 		rdt.rx			= (xmax-xmin)/2;
  471. 		rdt.ry 			= (ymax-ymin)/2;
  472. 		rdt.centerX = (xmin+xmax) / 2;
  473. 		rdt.centerY = (ymin+ymax) / 2;
  474.  
  475. 		var roadIDs =[];
  476. 		for (var i = 0; i <rdt.listNodeIds.length; i++) {													// Search connected Segments
  477. 			var node = Waze.model.nodes.objects[rdt.listNodeIds[i]];
  478. 			if (node != null) {
  479. 				var nbSegs = node.attributes.segIDs.length;
  480. 				roadIDs = roadIDs.concat(node.attributes.segIDs);
  481. 				//roadIDs.push.apply(node.attributes.segIDs);													  //collect rioadsIds connect to rdt
  482. 				for (var j=0; j<nbSegs;j++) {
  483. 					var road = Waze.model.segments.objects[node.attributes.segIDs[j]];
  484. 					if ((road != null) && (notInArray (road.getID(),rdt.listRoadIds))) {
  485. 						rdt.higherRank = rdt.higherRank || road.isLockedByHigherRank();				// test if locked at higher rank
  486. 						if (isInArray (road.attributes.fromNodeID,rdt.listNodeIds)) {
  487. 							rdt.listAdjRoadIds.push ({id:road.getID(),sideConnect :"A"});
  488. 						}				
  489. 						if (isInArray (road.attributes.toNodeID,rdt.listNodeIds)) {
  490. 							rdt.listAdjRoadIds.push ({id:road.getID(),sideConnect :"B"});
  491. 						}					
  492. 					}	
  493. 				}
  494. 			}
  495. 		} 
  496. 		
  497. 		var city_ID =[];						//search for primaryStreetID
  498. 	
  499. 		roadIDs = delete_multi_Ids(roadIDs);
  500. 		for (var i = 0; i <roadIDs.length; i++) {	
  501. 			var sel = Waze.model.segments.objects[roadIDs[i]];
  502. 			var streetID = sel.attributes.primaryStreetID;
  503. 			if (streetID && Waze.model.streets.objects[streetID]) {
  504. 				var street = Waze.model.streets.objects[streetID];
  505. 				if (street.cityID && Waze.model.cities.objects[street.cityID]) {
  506. 				  city_ID.push(street.cityID);
  507. 				}
  508. 			}
  509. 		}
  510. 		city_ID = delete_multi_Ids (city_ID);
  511. 		var cityName = "";
  512. 		var city = Waze.model.cities.objects[city_ID[0]];
  513. 		if (city_ID.length == 1 && city && city.name) {
  514. 			if (city.name!=""){cityName = city.name;}
  515. 		}
  516. 		var state_ID = (city.stateID) ? city.stateID : "";
  517. 		var country_Id = (city.countryID) ? city.countryID : "";
  518. 		if (city.stateID && city.countryID) {
  519. 			var newCityID = SearchCityID (city.countryID, city.stateID, cityName);
  520. 			rdt.primaryStreetID = searchPrimaryID (newCityID, "");
  521. 		}
  522. 		return rdt;
  523. 	}
  524. 	
  525. 	 function SearchCityID (country_ID, state_ID, cityName) {
  526.     var emptyct = (cityName==="");
  527.     var fattr = {countryID: country_ID, stateID: state_ID, isEmpty: emptyct, name : cityName };
  528.     var city = Waze.model.cities.getByAttributes(fattr);
  529.     if (city.length === 0) {
  530.       myAlert ("Create new city: "+cityName);
  531.       //var f = new Waze.Action.CreateObject(Waze.Model.ObjectType.CITY, {
  532. 			var f = new WazeActionCreateObject(WazeModelObjectType.CITY, {
  533.         countryID: country_ID,stateID: state_ID,isEmpty: emptyct,name: cityName});
  534.       Waze.model.actionManager.add(f);
  535.       return f.newObject.getID();
  536.     }
  537.     if (city.length === 1) {return city[0].getID();}
  538.     if (city.length > 1) {
  539.       myAlert ("Problems with cityID : "+city.length+" cities with same name. Please save and redo");
  540.       return null;
  541.     }
  542.     return null;
  543.   }
  544. 	
  545. 	 //function SearchPrimaryID (oldStreetID, newCityName, newStreetName) {
  546. 	 function searchPrimaryID (newCityID, newStreetName) {
  547.     if (newCityID == null) { return null; }
  548.     if (newStreetName == null) {newStreetName ="";}
  549.     var emptyst = (newStreetName =="");
  550.     var fattr = {cityID: newCityID, isEmpty: emptyst};
  551.     if (emptyst == false) { fattr.name = newStreetName;}
  552.     var st = Waze.model.streets.getByAttributes(fattr);
  553.     if (st.length === 0) {
  554.       myAlert ("Create new street: "+newCityName+"  "+newStreetName);
  555.       //var a = new Waze.Action.CreateObject(Waze.Model.ObjectType.STREET, {
  556. 			var a = new WazeActionCreateObject(WazeModelObjectType.STREET, {
  557.         name: newStreetName,isEmpty: emptyst,cityID: newCityID});
  558.       Waze.model.actionManager.add(a);
  559.       var newPrimaryStreetID = a.newObject.getID();
  560.     }
  561.     if (st.length === 1) {var newPrimaryStreetID = st[0].getID();}
  562.     if (st.length > 1) {
  563.       myAlert ("Problems with StreetID : "+st.length+" streets with same name. Please save and redo");
  564.       return null;
  565.     }
  566.     return newPrimaryStreetID;
  567.   }
  568. 	
  569. 	// function captureCity (roadListID) {
  570. 		// var road = {};
  571. 		// road.NoCityNoStreet = null;
  572. 		// road.CityNoStreet 	= null;
  573. 		// road.altStreetID    = null;
  574. 		// for (var i = 0; i < roadListID.length;i++) {
  575. 			// var road1 = Waze.model.segments.objects[roadListID[i]];
  576. 			// if (road1 != null && road1.attributes.primaryStreetID!= null) {
  577. 				// var adress = road1.getAddress();
  578. 				// road.altStreetID = road1.attributes.primaryStreetID;
  579. 				// if ((adress.city.isEmpty ) && (adress.street.isEmpty)) {
  580. 					// road.NoCityNoStreet = road1.attributes.primaryStreetID;}
  581. 				// if ((adress.city.name != null) && (adress.city.name != "") && (adress.street.isEmpty)) {
  582. 					// road.CityNoStreet = road1.attributes.primaryStreetID;}
  583. 			// }
  584. 		// } 
  585. 		// return road;
  586. 	// }
  587. 	
  588.  
  589.  
  590. 	function Roads_to_Interchange(ev) {
  591. 	
  592. //alert ("Do landmark is\nnot available in new editor" ); return ;
  593. 		var foundSelectedSegment = false;
  594. 		var selectedGood = (Waze.selectionManager.selectedItems.length>0);
  595. 		var roadIds = [];
  596. 		for (var i = 0; i<Waze.selectionManager.selectedItems.length;i++) { 																					// Test if selection are segment
  597. 			var sel = Waze.selectionManager.selectedItems[i].model;
  598. 			selectedGood = ((selectedGood) && (sel.type == "segment"));
  599. 			if ((selectedGood)&& (sel.attributes.junctionID!=null)) {										// if it is a roundabout
  600. 				var jId = sel.attributes.junctionID;
  601. 				var junc = Waze.model.junctions.objects[jId];
  602. 				roadIds.push.apply (roadIds,junc.segIDs);																	// we add all segment of the roundabout
  603. 			}
  604. 			if (selectedGood) {	roadIds.push ( sel.getID());}															// stocke les segments
  605. 		}
  606. 		if ((selectedGood) &&( roadIds.length != 0)) {
  607. 			roadIds = delete_multi_Ids (roadIds);																				// delete double roads
  608. 			var totalPoints = [];
  609. //points.push({x:5, y:3});
  610. 			var name;
  611. 			var leftEnv = [];
  612. 			var rightEnv = [];
  613. 			var typeLandmak;
  614. 			leftEnv.push ({x: 100000000000000,y:2000000000});
  615. 			var yMax = -100000000000;
  616. //alert (roadIds);
  617. 			for (var k = 0; k<roadIds.length;k++) { 
  618. 				var sel = Waze.model.segments.objects[roadIds[k]];
  619. //alert (sel.getID());
  620. 				if (name == null) {name = getStreet(sel).name;}
  621. 				if (typeLandmak == null) {
  622. 					switch (sel.attributes.roadType) {
  623. 						case 1: //"Streets"
  624. 						case 2: //"Primary Street"
  625. 						case 3: //"Freeways"
  626. 						case 4: //"Ramps"
  627. 						case 6: //"Major Highway"
  628. 						case 7: //"Minor Highway"
  629. 							typeLandmak = ["JUNCTION_INTERCHANGE"]; break;// Jonction/interchange
  630. 						case 8: //"Dirt roads"
  631. 						case 18: //"Railroad"
  632. 						case 19: //"Runway/Taxiway"
  633. 						case 20: //"Parking Lot Road"
  634. 							typeLandmak = ["PARKING_LOT"]; break;						// ParkingLot
  635. 						case 5: //"Walking Trails"
  636. 						case 10: //"Pedestrian Bw"
  637. 						case 16: //"Stairway"
  638. 						case 17: //"Private Road"
  639. 						case 21: //"Service Road"
  640. 							typeLandmak = ["PARK"]; break;												// Park	
  641. 					}
  642. 				}
  643. 				
  644. 				for (var j = 0; j < sel.geometry.components.length;j++) {
  645. 					totalPoints.push (sel.geometry.components[j].clone());
  646. 					if (leftEnv[0].y > sel.geometry.components[j].y) {																							// Stocke le Y mini
  647. 						leftEnv[0]  = sel.geometry.components[j].clone();
  648. 						rightEnv[0] = sel.geometry.components[j].clone();
  649. 					}
  650. 					if (sel.geometry.components[j].y > yMax) { yMax = sel.geometry.components[j].y;}
  651. 				}
  652. 			}
  653. 			
  654. 			while ( rightEnv[rightEnv.length-1].y <yMax) {																		// traitement de la voie droite
  655. 				var anglemin = 190;
  656. 				for (var i = 0; i<totalPoints.length;i++) {														
  657. 					if (totalPoints[i].y > rightEnv[rightEnv.length-1].y) {
  658. 						var deltaX = totalPoints[i].x - rightEnv[rightEnv.length-1].x;
  659. 						if (deltaX !=0) {
  660. 							var deltaY = totalPoints[i].y - rightEnv[rightEnv.length-1].y;
  661. 							var angle = angleDeg( deltaX , deltaY);
  662. 							if (angle < anglemin) {
  663. 								anglemin = angle;
  664. 								var iMin = i;
  665. 							}
  666. 						}
  667. 					}
  668. 				} 
  669. 				rightEnv.push (totalPoints[iMin]);
  670. 			}
  671. 			
  672. 			while ( leftEnv[leftEnv.length-1].y <yMax) {																		// traitement de la voie droite
  673. 				var anglemax = 0;
  674. 				for (var i = 0; i<totalPoints.length;i++) {														
  675. 					if (totalPoints[i].y > leftEnv[leftEnv.length-1].y) {
  676. 						var deltaX = totalPoints[i].x - leftEnv[leftEnv.length-1].x;
  677. 						if (deltaX !=0) {
  678. 							var deltaY = totalPoints[i].y - leftEnv[leftEnv.length-1].y;
  679. 							var angle = angleDeg( deltaX , deltaY);
  680. 							if (angle > anglemax) {
  681. 								anglemax = angle;
  682. 								var iMax = i;
  683. 							}
  684. 						}
  685. 					}
  686. 				} 
  687. 				leftEnv.push (totalPoints[iMax]);
  688. 			}
  689. 			
  690. 			leftEnv.shift(); leftEnv.pop();																//On ote le premier et le dernier point( communs avec droite)			
  691. 			rightEnv.push.apply (rightEnv,leftEnv.reverse ());						//on ajoute la partie Gauche
  692. 			var dummy = doLandmark (rightEnv,name,typeLandmak);						// make the landmark
  693. 			alert("Successfully created Landmark");}
  694. 		else {
  695. 			alert("Incorrect Selection : \n\nOne segment must be selected \nOr It is not RoundAbout Segment");
  696. 		}
  697. 	}
  698.  
  699. 	function doLandmark (geometry,nameLandmak,typeLandmak) {
  700. 		var polyPoints = null;
  701. 		for (var i = 0; i<geometry.length;i++) {
  702. 			var vertex = geometry[i];
  703. 			if (polyPoints == null) {
  704. 				polyPoints = [geometry[i]]; 
  705. 				var ri = new OpenLayers.Geometry.Point(geometry[i].x, geometry[i].y);
  706. 				polyPoints.push(ri)
  707. 				}
  708. 			else {
  709. 				var ri = new OpenLayers.Geometry.Point(geometry[i].x, geometry[i].y);
  710. 				polyPoints.push(ri);
  711. 			}
  712. 		}
  713. 		var polygon = new OpenLayers.Geometry.Polygon(new OpenLayers.Geometry.LinearRing(polyPoints));
  714. 		var landmark = new WazeFeatureVectorLandmark();
  715. 		landmark.geometry = polygon;
  716. 		landmark.attributes.name = nameLandmak;
  717. 		landmark.attributes.categories = typeLandmak;
  718. 		var what = Waze.model.actionManager.add(new WazeActionAddLandmark(landmark));
  719.  
  720. 		activateLayer ("landmarks", true );
  721. 		return true; 
  722. 	}
  723. 	
  724. 	function Street_River (ev) {
  725. 		var selectedGood = (Waze.selectionManager.selectedItems.length==1);
  726. 		var sel = Waze.selectionManager.selectedItems[0].model;
  727. 		selectedGood = selectedGood && (sel.type == "segment") && (sel.attributes.roadType != "18");
  728. 		if (selectedGood) {
  729. 			var offset = getDisplacement();																						// valeur en mètres
  730. 			if (offset == null) {
  731. 				return;}
  732. 			var name = getStreet(sel).name;
  733. 			var points = StreetToLandmark (sel, offset); 
  734. //var dummy = doLandmark (points,name,"H3010")	// river
  735. 			var dummy = doLandmark (points,name,["RIVER_STREAM"]);	// river	
  736. 			alert("Successfully created a River Landmark");}
  737. 		else {
  738. 			alert ("Incorrect Selection : \n\nOne segment must be selected \nOr It is not Street Segment");
  739. 		}
  740. 	}
  741.  
  742. 	function Railroad_ParkingLot (ev) {
  743. //alert ("Railraod to parkingLot is\n\nnot available in new editor" ); return ;
  744. 		var selectedGood = (Waze.selectionManager.selectedItems.length==1);
  745. 		var sel = Waze.selectionManager.selectedItems[0].model;
  746. 		selectedGood = selectedGood && (sel.type == "segment") && (sel.attributes.roadType == "18");
  747. 		if (selectedGood) {
  748. 			var offset = getDisplacement();																						// valeur en mètres
  749. 			if (offset == null) {
  750. 				return;}
  751. 			var name = getStreet(sel).name;
  752. 			var points = StreetToLandmark (sel, offset); 
  753. //var dummy = doLandmark (points,name,"W0001")	// ParkingLot
  754. 			var dummy = doLandmark (points,name,["PARKING_LOT"]);	// ParkingLot		
  755. 			alert("Successfully created ParkingLot Landmark");}
  756. 		else {
  757. 			alert ("Incorrect Selection : \n\nOne segment must be selected \nOr It is not Railroad Segment");
  758. 		}
  759. 	}
  760.  
  761. 	function getDisplacement() {
  762. 		var scale = 1.44449796;																				// Scale mètres => coordonnées waze			
  763. 		var width = prompt ("Enter new Width or leave it to old value ",defaultWidth);
  764. 		if (width == null) {
  765. 			return null}
  766. 		else {
  767. 			if (width.match("m","g")) {
  768. 				width =parseInt(width);
  769. 				if (width < 1) {width = 1;}					//minimum width equal to 1m
  770. 				if (width >100) {width = 100;}		  //maximum width equal to 100m
  771. 				defaultWidth=width+" m";
  772. 				return width * scale / 2;			
  773. 			}
  774. 			if (width.match("ft","g")) {
  775. 				width =parseInt(width);
  776. 				if (width < 3) {width =3;}					//minimum width equal to 3 ft
  777. 				if (width > 300) {width =300;}			//maximum width equal to 300 ft
  778. 				defaultWidth=width+" ft";
  779. 				return width * 0.3048 * scale /2;
  780. 			}
  781. 			width=15;
  782. 			defaultWidth="15 m";
  783. 			return width * scale / 2;
  784. 		}
  785.   }
  786. 	
  787. 	function StreetToLandmark (seg,offset) {
  788. 		var decal = decalage (seg.geometry.components, offset);
  789. 		if (document.getElementById ('WME_SSTR_SmthRvr').checked == 1) {	
  790. 			decal.dir = optGeometry (decal.dir);
  791. 			decal.sym = optGeometry (decal.sym);
  792. 			decal.dir = b_spline (decal.dir);												// creation des B - splines X & Y
  793. 			decal.sym = b_spline (decal.sym);
  794. 			decal.dir = sup_unneed (decal.dir);											// delete aligned points
  795. 			decal.sym = sup_unneed (decal.sym);											// delete aligned points
  796. 		}
  797. 		decal.dir.push.apply  (decal.dir,decal.sym.reverse());		// on rajoute le trajet retour
  798. 		return decal.dir;
  799. 	}
  800. 	
  801. 	function sup_unneed (decal) {
  802. 		for (var phase = 0; phase < 3; phase ++) {
  803. 			var decal1 = [];
  804. 			decal1 [0] = decal [0];
  805. 			for (var i = 1; i< decal.length-2; i++) {
  806. 				if ((decal1[decal1.length-1].x != decal[i+1].x) && (decal[i+1].x != decal[i+2].x)) {															// non vertical => can calculate Atan				
  807. 				var angle1 = ((decal1[decal1.length-1].y  - decal[i+1].y) / (decal1[decal1.length-1].x - decal[i+1].x));
  808. 					var angle2 = ((decal[i+1].y - decal[i+2].y) / (decal[i+1].x - decal[i+2].x));
  809. 					var length1 = longueur (decal1[decal1.length-1].x,decal1[decal1.length-1].y,decal[i+1].x,decal[i+1].y);
  810. 					if (testUnneed (angle1,angle2,length1,phase)) {
  811. 						decal1.push (decal[i+1]);
  812. 					}
  813. 				}
  814. 				else {
  815. 					decal1.push (decal[i+1]);
  816. 				}
  817. 			}
  818. 			decal1.push (decal[decal.length-1]);
  819. 			decal = decal1;
  820. 		}
  821. 		return decal1;
  822. 	} 
  823. 	
  824. 	function testUnneed (angle1,angle2,longueur,phase) {
  825. 		var deltaAngle = Math.abs (AtanDeg (angle1) - AtanDeg (angle2));	
  826. 		switch (phase) {
  827. 			case 0: if ((deltaAngle < 45) && (longueur < 10))	{return false;}; break;
  828. 			case 1: if ((deltaAngle < 1 ) && (longueur >= 10) && (longueur < 250)) {return false;}; break;
  829. 			case 2: if ((deltaAngle < 2 ) && (longueur >= 10) && (longueur < 50 )) {return false;}; break;
  830. 		}
  831. 		return true;
  832. 	}
  833. 	
  834. 	function optGeometry ( line) {
  835. 		var opt = [];
  836. 		opt[0] = line[0].clone();
  837. 		for (var i = 1; i< line.length; i++) {
  838. 			var deltaX = line[i].x-line[i-1].x;
  839. 			var deltaY = line[i].y-line[i-1].y;
  840. 			opt.push ({x: line[i-1].x + deltaX * 0.33, y: line[i-1].y + deltaY * 0.33}); // add 2 extra control points
  841. 			opt.push ({x: line[i-1].x + deltaX * 0.66, y: line[i-1].y + deltaY * 0.66});		
  842. 			opt.push ({x: line[i].x, y: line[i].y});
  843. 		}
  844. 		return opt;
  845. 	}
  846.  
  847. 	function decalage (geom,offset) {	
  848. 		var decal = {};
  849. 		decal.dir = [];																					// décalage d'un coté
  850. 		decal.sym = [];																					// décalage de l'autre
  851. 		decal.dir[0] = geom[0].clone();
  852. 		decal.sym[0] = geom[0].clone();
  853. 		if (Math.abs(geom[1].x - geom[0].x) < 0.1) {geom[1].x = geom[0].x+0.1;}															// traitement de la verticalité
  854. 		var deltaX = geom[1].x - geom[0].x;
  855. 		var deltaY = geom[1].y - geom[0].y;
  856. 		var angle = Math.atan (deltaY/deltaX);	
  857. 		decal.dir[0].x = geom[0].x - sign (deltaX) * offset * Math.sin (angle);
  858. 		decal.dir[0].y = geom[0].y + sign (deltaX) * offset * Math.cos (angle);
  859. 		decal.sym[0].x = geom[0].x + sign (deltaX) * offset * Math.sin (angle);
  860. 		decal.sym[0].y = geom[0].y - sign (deltaX) * offset * Math.cos (angle);
  861. 		
  862. 		var aprev = deltaY / deltaX;
  863. 		var b = geom[0].y - aprev * geom[0].x;										// y = ax+b
  864. 		
  865. 		var off1 = sign(deltaX) *  offset / Math.cos (angle);
  866. 		var bprev = b + off1;	var bprev1 = b - off1;
  867. 		for (var i = 1; i < geom.length-1; i++) {
  868. 			if (Math.abs(geom[i+1].x - geom[i].x)< 0.1) {geom[i+1].x = geom[i].x+0.1;}															// traitement de la verticalité
  869. 			deltaX = geom[i+1].x - geom[i].x; 
  870. 			deltaY = geom[i+1].y - geom[i].y;
  871. 			var anext = deltaY / deltaX;
  872. 			b = geom[i].y - anext * geom[i].x;
  873. 			angle = Math.atan (deltaY/deltaX);
  874. 			off1 = sign(deltaX) * offset / Math.cos (angle);
  875. 			var bnext = b + off1;	var bnext1 = b - off1;
  876. 			
  877. 			var x1 = -(bprev - bnext) / (aprev - anext);
  878. 			var x2 = -(bprev1 - bnext1) / (aprev - anext);
  879. 			decal.dir.push ({x: x1, y: (aprev * x1 + bprev)});											// décalage d'un coté
  880. 			decal.sym.push ({x: x2, y: (aprev * x2 + bprev1)});										  // décalage de l'autre coté
  881. 			
  882. 			aprev = anext;
  883. 			bprev = bnext;	bprev1 = bnext1;
  884. 		}
  885. 																																							// derniers point
  886. 		decal.dir.push ({x: (geom[i].x - sign(deltaX) * offset * Math.sin (angle)),y: (geom[i].y + sign(deltaX) * offset * Math.cos (angle))});  
  887. 		decal.sym.push ({x: (geom[i].x + sign(deltaX) * offset * Math.sin (angle)),y: (geom[i].y - sign(deltaX) * offset * Math.cos (angle))});
  888. 		return decal;
  889. 	}
  890.  
  891. 	function b_spline (ligne) {	
  892. 		var ligne1 = [];																															
  893. 		ligne1 [0] = ligne [0];
  894. 		for (var j = 1; j < ligne.length-2;j++) {
  895. 			var t = 4; 																															// nombre de sous-segments
  896. 			for (var i = 0; i < 1;i+=1/t) {
  897. 				var x1 = ((1-i)*(1-i)*(1-i)*ligne[j-1].x + (3*i*i*i -6*i*i +4)*ligne[j].x + (-3*i*i*i +3*i*i +3*i +1)*ligne[j+1].x + i*i*i*ligne[j+2].x)/6;
  898. 				var y1 = ((1-i)*(1-i)*(1-i)*ligne[j-1].y + (3*i*i*i -6*i*i +4)*ligne[j].y + (-3*i*i*i +3*i*i +3*i +1)*ligne[j+1].y + i*i*i*ligne[j+2].y)/6;
  899. 				ligne1.push ({x: (x1), y: (y1)});
  900. 			}
  901. 		}
  902. 		ligne1.push( ligne[ligne.length-1] );
  903. 		return ligne1;
  904. 	}
  905.  
  906. 	function getStreet(segment) {
  907. 		if (!segment.attributes.primaryStreetID)
  908.       return null;
  909.     var street = segment.model.streets.get(segment.attributes.primaryStreetID);
  910.     return street;
  911.   }
  912.  
  913.   function select_same_type_roads(ev) {
  914. 		var nbRoad = Waze.selectionManager.selectedItems.length;
  915. 		var selectedGood = true;																									// selection must have 1 or 2 items
  916. 		for (var i = 0; i<nbRoad;i++) { 																					// Test if selection are segment
  917. 			var sel = Waze.selectionManager.selectedItems[i].model;
  918. 			selectedGood = ((selectedGood) && (sel.type == "segment"));
  919. 		}
  920. 	
  921. 		if (selectedGood) {
  922. 			var Select_IDs =[];                     											  //tableau de stockage des Routes electionnées
  923. 			for (var j = 0; j < nbRoad; j++) {
  924. 				var sel = Waze.selectionManager.selectedItems[j].model;
  925. 				if (sel.attributes.junctionID!=null) {															  // It's un roundabout
  926. 					var jId = sel.attributes.junctionID;
  927. 					var junc = Waze.model.junctions.objects[jId];
  928. 					Select_IDs.push.apply(Select_IDs,junc.segIDs);}											// Add to pervious selected Ids
  929. 				else {
  930. 					var roadFrom = sel.attributes.fromNodeID;
  931. 					var nodeFrom = Waze.model.nodes.objects[roadFrom];										// recherche à partir du premier noeud
  932. 					var segList = searchRoad(nodeFrom,sel,"0");					
  933. 					Select_IDs.push.apply(Select_IDs,segList.IDs);											// Add to pervious selected Ids
  934. 					var roadTo =  sel.attributes.toNodeID;
  935. 					var nodeTo = Waze.model.nodes.objects[roadTo];												// recherche à partir du deuxième noeud					
  936. 					var segList = searchRoad(nodeTo,sel,"0");			
  937. 					Select_IDs.push.apply(Select_IDs,segList.IDs);											// Add to pervious selected Ids
  938. 				}
  939. 			}
  940. 			select (Select_IDs);
  941. 		}
  942. 		if (!selectedGood) { alert("You must select road(s)");}
  943.   }
  944.  
  945. 	function Side_A(ev) {
  946. 		var nbRoad = Waze.selectionManager.selectedItems.length;
  947. 		var sel = Waze.selectionManager.selectedItems[0].model;
  948. 		if ((nbRoad == 1) && (sel.type == "segment")) {						
  949. 			var roadFrom = sel.attributes.fromNodeID;
  950. 			var nodeFrom = Waze.model.nodes.objects[roadFrom];												// recherche à partir du noeud A
  951. 			var segList = searchRoad(nodeFrom,sel,"0")
  952. 			select (segList.IDs);}
  953. 		else {
  954. 			alert ("One segment (and only one)\nmust be selected");
  955. 		}	
  956. 	}
  957. 	
  958. 	function Side_B(ev) {
  959. 		var nbRoad = Waze.selectionManager.selectedItems.length;
  960. 		var sel = Waze.selectionManager.selectedItems[0].model;
  961. 		if ((nbRoad == 1) && (sel.type == "segment")) {						
  962. 			var roadTo =  sel.attributes.toNodeID;
  963. 			var nodeTo = Waze.model.nodes.objects[roadTo];															// recherche à partir du noeud	A					
  964. 			var segList = searchRoad(nodeTo,sel,"0")
  965. 			select (segList.IDs);}
  966. 		else {
  967. 			alert ("One segment (and only one)\nmust be selected");
  968. 		}	
  969. 	}
  970. 	
  971. 	function select_AB(ev)  {
  972. 		var nbRoad = Waze.selectionManager.selectedItems.length;															// **** Validate selection *****
  973. 		var selectedGood = (nbRoad == 2);																													// selection must have 2 items
  974. 		if (selectedGood) {
  975. 			var sel = Waze.selectionManager.selectedItems[0].model;
  976. 			var sel1 = Waze.selectionManager.selectedItems[1].model;
  977. 			selectedGood = ((sel.type == "segment") && (sel1.type == "segment"));											// Test if selection are segment
  978. 			selectedGood = ((selectedGood) && (sel.attributes.roadType == sel1.attributes.roadType));	// Test if selection have same road Type
  979. 		}
  980. 		if (selectedGood) {
  981. 			var lengthMin = 1000000;
  982. 			var goodTrip = [];
  983. 			var select1 = select_12(sel,sel1);
  984. 			if (select1[select1.length-1] == sel1.getID()) {																								// on a trouvé un chemin dans ce sens
  985. 				goodTrip = select1;
  986. 				lengthMin = lengthTrip (select1);	
  987. 				}
  988. 			var select2 = select_12(sel1,sel);
  989. 			
  990. 			if ((select2[select2.length-1] == sel.getID()) && (lengthTrip (select2) < lengthMin)){					// on a trouvé un chemin dans ce sens
  991. 					goodTrip = select2;
  992. 					lengthMin = lengthTrip (select2);
  993. 			}
  994. 			var nodeTrip1 = nodeFromTrip (select1);																												// ******* search for Common Nodes
  995. 			var nodeTrip2 = nodeFromTrip (select2);
  996. 			var CommonNode = [];	
  997. 			for (var m = 0; m < nodeTrip1.length; m++) {
  998. 				if (isInArray (nodeTrip1[m],nodeTrip2)) {
  999. 					CommonNode.push (nodeTrip1[m]);
  1000. 				}
  1001. 			}
  1002. 	
  1003. 			if (CommonNode.length !=0) {																																								
  1004. 				for (var i = 0; i < CommonNode.length; i++) {
  1005. 					var select3 = [];
  1006. 					var road = Waze.model.segments.objects[select1[0]];
  1007. 					for (var j = 0; ((road.attributes.fromNodeID != CommonNode[i]) && (road.attributes.toNodeID != CommonNode[i])); j++) {
  1008. 						select3.push (road.getID());
  1009. 						road = Waze.model.segments.objects[select1[j]];
  1010. 					}
  1011. 					select3.push (road.getID());
  1012. 					road = Waze.model.segments.objects[select2[0]];
  1013. 					for (var k = 0; ((road.attributes.fromNodeID != CommonNode[i]) && (road.attributes.toNodeID != CommonNode[i])); k++) {
  1014. 						select3.push (road.getID());
  1015. 						road = Waze.model.segments.objects[select2[k]];
  1016. 					}
  1017. 					select3.push (road.getID());
  1018. 					select3 = delete_multi_Ids (select3);
  1019. 					if (lengthTrip (select3) <lengthMin) {
  1020. 						goodTrip = select3;
  1021. 						lengthMin = lengthTrip (goodTrip);
  1022. 					}
  1023. 				}
  1024. 			}
  1025. 			
  1026. 			if (lengthMin != 1000000) {																								// a path was found
  1027. 				goodTrip = addRoundabout (goodTrip);																		// Add roundabout segments
  1028. 				goodTrip = addAlternativePaths (goodTrip);															// add alternative simple way like fork in roundabaout
  1029. 				select (goodTrip);}		// make the selection		
  1030. 			else {
  1031. 				alert("No Path found"); 	
  1032. 			}
  1033. 		}
  1034. 		else { alert("You must select 2 roads \nwith the same type"); 
  1035. 		}
  1036. 	}
  1037.  
  1038. 	function addAlternativePaths (trip) {
  1039. 		var alternativeSegs = [];
  1040. 		var listNodeIDs = nodeFromTrip (trip);																			// list of nodesIds of the trip
  1041. 		var road = Waze.model.segments.objects[trip[0]];					
  1042. 		var roadtype	= road.attributes.roadType;
  1043. 		for (var i = 0; i < listNodeIDs.length;i++) {
  1044. 			var node = Waze.model.nodes.objects[listNodeIDs[i]];
  1045. 			var nodeSegIdList = node.attributes.segIDs;
  1046. 			for (var j = 0; j < nodeSegIdList.length;j++) {
  1047. 				var road1 = Waze.model.segments.objects[nodeSegIdList[j]];		
  1048. 				if ((road1 != null) && (road1.attributes.roadType == roadtype) && (isInArray (road1.attributes.fromNodeID,listNodeIDs)) && (isInArray (road1.attributes.toNodeID,listNodeIDs))) {
  1049. 					alternativeSegs.push (road1.getID());
  1050. 				}
  1051. 			}
  1052. 		}
  1053. 		if (alternativeSegs.length != 0 ) {
  1054. 			trip.push.apply(trip,alternativeSegs);
  1055. 			trip = delete_multi_Ids (trip);
  1056. 		}
  1057. 		return trip;
  1058. 	}
  1059.  
  1060. 	function addRoundabout (trip) {
  1061. 		var roundaboutSegs = [];
  1062. 		for (var i = 0; i < trip.length;i++) {
  1063. 			var road = Waze.model.segments.objects[trip[i]];
  1064. 			if (road.attributes.junctionID!=null) {															  // It's un roundabout
  1065. 				var jId = road.attributes.junctionID;
  1066. 				var junc = Waze.model.junctions.objects[jId];
  1067. 				roundaboutSegs.push.apply(roundaboutSegs,junc.segIDs);								// prepare to add roundabout to select
  1068. 			}
  1069. 		}
  1070. 		if (roundaboutSegs.length != 0 ) {
  1071. 			trip.push.apply(trip,roundaboutSegs);
  1072. 			trip = delete_multi_Ids (trip);
  1073. 		}
  1074. 		return trip;
  1075. 	}
  1076.  
  1077. 	function nodeFromTrip (Trip) {
  1078. 		var node =[];
  1079. 		for (var i = 0; i < Trip.length; i++) {
  1080. 			var road = Waze.model.segments.objects[Trip[i]];
  1081. 			node.push (road.attributes.fromNodeID);
  1082. 			node.push (road.attributes.toNodeID);
  1083. 		}
  1084. 		node = delete_multi_Ids (node);
  1085. 		return node;
  1086. 	}
  1087.  
  1088. 	function lengthTrip (listRoadID) {
  1089. 		var length= 0;
  1090. 		for (var i = 0; i < listRoadID.length;i++) {
  1091. 			var road = Waze.model.segments.objects[listRoadID[i]];
  1092. 			length = length + road.attributes.length;
  1093. 		}
  1094. 		return length;
  1095. 	}
  1096.  
  1097. 	function select_12(startRoad,endRoad) {
  1098. 		var Select_IDs =[];																																		//tableau de stockage des Routes electionnées
  1099. 		var endRoadFrom;
  1100. 		var endRoadTo;
  1101. 		if (endRoad.attributes.fromNodeID != null) {																					// Validate node for End Road 
  1102. 			endRoadFrom = Waze.model.nodes.objects[endRoad.attributes.fromNodeID];}
  1103. 		else {endRoadFrom = Waze.model.nodes.objects[endRoad.attributes.toNodeID];}
  1104. 		if (endRoad.attributes.toNodeID != null) {
  1105. 			endRoadTo = Waze.model.nodes.objects[endRoad.attributes.toNodeID];}
  1106. 		else {endRoadTo = Waze.model.nodes.objects[endRoad.attributes.fromNodeID];}	
  1107. 		var node = choiceStartNode (startRoad,endRoadFrom,endRoadTo);													// Choix du node de depart
  1108. 		var segList = searchRoad(node,startRoad,endRoad.getID());		
  1109. 		Select_IDs.push.apply(Select_IDs,segList.IDs);				
  1110. //alert (Select_IDs);
  1111. 		while ((segList.stop == "multiRoads") &&  (segList.roads.length >"1") && (Select_IDs.length < 50)) {													// Manage jonctions with same type road
  1112. 			var BestNextNode  = searchBestNextNode (segList.node, segList.roads, endRoad);
  1113. 			if ( BestNextNode.getID() != segList.node.getID() ) {																										// search road with best node
  1114. 				for (var i = 0; i < segList.roads.length;i++) {
  1115. 					var road = Waze.model.segments.objects[segList.roads[i]];
  1116. 					if ((BestNextNode.getID() == road.attributes.fromNodeID) || (BestNextNode.getID() == road.attributes.toNodeID)) {
  1117. 					var bestRoad = road;
  1118. 					}
  1119. 				}
  1120. 				var segList = searchRoad (BestNextNode, bestRoad, endRoad.getID());					
  1121. 				Select_IDs.push.apply(Select_IDs, segList.IDs);}
  1122. 			else {
  1123. 				segList.stop = "none"; 
  1124. 			}
  1125. 		}
  1126. 		return (Select_IDs);
  1127. 	}		
  1128.  
  1129. 	function searchBestNextNode (StartNode,listRoadID,endRoad) {
  1130. 		var EndNode1 = Waze.model.nodes.objects[endRoad.attributes.fromNodeID];
  1131. 		var EndNode2 = Waze.model.nodes.objects[endRoad.attributes.toNodeID];
  1132. 		if (distance(StartNode,EndNode2) > distance(StartNode,EndNode1)) {					// determine de noeud de référence de fin
  1133. 			var EndNode = EndNode1;}
  1134. 		else {
  1135. 			var EndNode = EndNode2;
  1136. 		}
  1137. 		var angleEnd = angle(StartNode, EndNode);
  1138. 		var angleMin = 360;
  1139. 		var BestNode;
  1140. 		for (var i = 0; i < listRoadID.length;i++) {
  1141. 			var road = Waze.model.segments.objects[listRoadID[i]];
  1142. 			if (road.attributes.fromNodeID == StartNode.getID()) {												// determine de noeud à tester pour la fin du segment
  1143. 				var node = Waze.model.nodes.objects[road.attributes.toNodeID];}
  1144. 			else {
  1145. 				var node = Waze.model.nodes.objects[road.attributes.fromNodeID];
  1146. 			}
  1147. 			var angle1 = Math.abs(angle (StartNode,node) - angleEnd);
  1148. 			if (angle1 > 180 ) { angle1= 360 - angle1;}															// angle complémentaire
  1149. 			if ( angle1 < angleMin ) {
  1150. 				angleMin = angle1;
  1151. 				BestNode = node;
  1152. 			}
  1153. 		}
  1154. 		return BestNode;
  1155. 	}
  1156.  
  1157.  
  1158. 	
  1159. 	//function sign (x) {
  1160. 	//if ( x < 0 ) { return (-1);}
  1161. 	//		else {return (1);}
  1162. 	//}
  1163. 	
  1164. 	//        **** Math functions *****
  1165. 	function sign (x) {return (x < 0) ? (-1) : (1);}
  1166. 	function AtanDeg ( x) {return ( 180 * Math.atan (x) / Math.PI );}
  1167. 	function convertDegRad (angledeg) {return (Math.PI * (angledeg) / 180 );}
  1168. 	function angle (node1,node2) {
  1169. 		//var deltaX = (node2.geometry.x - node1.geometry.x);
  1170. 		//var deltaY = (node2.geometry.y - node1.geometry.y);
  1171. 		//return angleDeg (deltaX,deltaY);
  1172. 		return angleDeg ((node2.geometry.x - node1.geometry.x),(node2.geometry.y - node1.geometry.y));
  1173. 	}
  1174. 	function angleDeg (deltaX,deltaY) {
  1175. 		if (deltaX == 0) { return ( sign( deltaY ) * 90);}
  1176. 		if (deltaX > 0 ) { return (AtanDeg( deltaY / deltaX));}
  1177. 			else { return ((sign( deltaY )* 180) + AtanDeg( deltaY / deltaX));}
  1178. 	}
  1179. 	function longueur (x1,y1,x2,y2) {
  1180. 		return (Math.sqrt (((x1-x2)*(x1-x2))+((y1-y2)*(y1-y2))));
  1181. 	}
  1182. 	//        **********************
  1183. 	
  1184. 	function select (Select_IDs)	{
  1185. 			Select_IDs = delete_multi_Ids (Select_IDs)	;														// suppression des doublons
  1186. 			var foundSegs =[];	
  1187. 			for (var i = 0; i<Select_IDs.length;i++) {
  1188. 					foundSegs.push(Waze.model.segments.objects[Select_IDs[i]]);					// créer la selection
  1189. 			}
  1190. 			Waze.selectionManager.select(foundSegs); 
  1191. 	}
  1192. 	
  1193. 	function delete_multi_Ids (myArray) {
  1194. 		var myNewArray = [];
  1195. 		if (myArray.length >0) {
  1196. 			myNewArray[0]= myArray [0];
  1197. 			for (var i = 0; i < myArray.length; i++) {
  1198. 				if (notInArray (myArray [i],myNewArray)) {
  1199. 					myNewArray.push(myArray [i]);
  1200. 				}
  1201. 			}
  1202. 		}
  1203. 		return myNewArray;
  1204. 	}
  1205. 	
  1206.   function minInArray (array) {
  1207. 		if (array.length > 0) {
  1208. 			var minimum = array [0];
  1209. 			for (var i = 1; i < array.length; i++) {
  1210. 				//if (array [i] < minimum) {minimum = array [i];}
  1211. 				minimum = Math.min (minimum,array [i]);
  1212. 			}
  1213. 			return minimum;
  1214. 		}
  1215. 		else {return null;}
  1216. 	}
  1217. 	
  1218. 	function isInArray (item,array) {return array.indexOf(item) !== -1;}
  1219.   function notInArray (item,array) {return array.indexOf(item) === -1;}
  1220. 	
  1221. 	
  1222. 	// function notInArray (item,array) {
  1223. 		// for (var i = 0; i < array.length; i++) {
  1224. 			// if (item == array [i]) { return false;}
  1225. 		// }
  1226. 		// return true;
  1227. 	// }
  1228. 	
  1229. 	// function isInArray (item,array) {
  1230. 		// for (var i = 0; i < array.length; i++) {
  1231. 			// if (item == array [i]) { return true;}
  1232. 		// }
  1233. 		// return false;
  1234. 	// }
  1235. 	
  1236. 	function searchRoad(node,roadStart,roadEndID) {
  1237. 		var roadtype	= roadStart.attributes.roadType;
  1238. 		var roadStartID = roadStart.getID();
  1239. 		var roadID = roadStartID;
  1240. 		var foundSegs  = {};																// object for return parameters
  1241. 		foundSegs.IDs = [];
  1242. 		foundSegs.roads = [];																					//init array
  1243. 		foundSegs.stop = "none";																			//init Stop cause
  1244. 		foundSegs.IDs.push(roadID);
  1245. 		var nbSeg = 1;																								//Number of searched segments	
  1246. 		while ((nbSeg < 50) && (roadID != roadEndID)) {
  1247. 			var nodeSegIdList = node.attributes.segIDs;									// list of road connected to node
  1248. 			var sameTypeRoad = [];
  1249. 			for (var i = 0; i < nodeSegIdList.length;i++) { 
  1250. 				var segID = nodeSegIdList [i];
  1251. 				var seg1 =Waze.model.segments.objects[segID];
  1252. 				if (seg1 == null ) return foundSegs;											// le segment n'est pas chargé en mémoire
  1253. 				else {	
  1254. 					if ((seg1.attributes.roadType == roadtype) && (seg1.getID() != roadID)) {
  1255. 						sameTypeRoad.push(segID);
  1256. 					}
  1257. 				}			
  1258. 			}
  1259.  
  1260. 			if (sameTypeRoad.length !=1) {
  1261. 				if (isInArray (roadEndID,sameTypeRoad)) {									// End Road is in the fork
  1262. 					foundSegs.IDs.push(roadEndID);													// We add it and go away
  1263. 					return foundSegs;
  1264. 				}	
  1265. 				sameTypeRoad = validate (sameTypeRoad);										// delete cul-de-sac
  1266. 			}
  1267. 			if (sameTypeRoad.length !=1) {															// not an unique segment (0,2 or more)
  1268. 				foundSegs.stop = "multiRoads";
  1269. 				foundSegs.roads = sameTypeRoad;
  1270. 				foundSegs.node = node; 
  1271. 				return foundSegs;}																				// on retourne le tableau d'Ids s
  1272. 			else {
  1273. 				var roadID = sameTypeRoad[0];
  1274. 				if (isInArray (roadID,foundSegs.IDs)) return foundSegs;		// we are in a lopp : we go away
  1275. 				foundSegs.IDs.push(roadID);
  1276. 				nbSeg = nbSeg + 1;
  1277. 				var seg2 = Waze.model.segments.objects[roadID];
  1278. 				if (node.getID() == seg2.attributes.fromNodeID) { var nodeID = seg2.attributes.toNodeID;}
  1279. 					else { var nodeID = seg2.attributes.fromNodeID;}
  1280. 				var node = Waze.model.nodes.objects[nodeID];
  1281.  
  1282. 				if (node == null ) return foundSegs;											// It's a cul-de-sac : we go away
  1283. 			}
  1284. 		}
  1285. 		return foundSegs;
  1286. 	}
  1287. 	
  1288. 	function validate (sameTypeRoad) {
  1289. 		var myNewSameTypeRoad  = [];
  1290. 		for (var i = 0; i < sameTypeRoad.length; i++) {
  1291. 			var sel = Waze.model.segments.objects[sameTypeRoad[i]];
  1292. 			if ((sel.attributes.fromNodeID !=null) && (sel.attributes.toNodeID!=null)) { //it is not a cul-de-sac
  1293. 				myNewSameTypeRoad.push (sameTypeRoad[i]);
  1294. 			}
  1295. 		}
  1296. 		return myNewSameTypeRoad;
  1297. 	}
  1298. 	
  1299. 	function choiceStartNode (road1,node3,node4) {
  1300. 		var node1,node2;
  1301.  
  1302. 		if (road1.attributes.fromNodeID != null) {																									// test of cul-de-sac & change node if it is
  1303. 			node1 = Waze.model.nodes.objects[road1.attributes.fromNodeID];}
  1304. 		else { node1 = Waze.model.nodes.objects[road1.attributes.toNodeID];}
  1305. 		if (road1.attributes.toNodeID != null) {
  1306. 			node2 = Waze.model.nodes.objects[road1.attributes.toNodeID];}
  1307. 		else { node2 = Waze.model.nodes.objects[road1.attributes.fromNodeID];}
  1308.  
  1309. 		var nodeStart = node1;
  1310. 		var dist_min = distance (node1,node3);
  1311. 		var dist = distance (node1,node4);
  1312. 		if (dist < dist_min ) {dist_min=dist;}
  1313. 		dist = distance (node2,node3);
  1314. 		if (dist < dist_min ) { dist_min = dist; nodeStart = node2;}
  1315. 		dist = distance (node2,node4);
  1316. 		if (dist < dist_min ) { dist_min = dist; nodeStart = node2;}
  1317. 		return nodeStart;
  1318. 	}
  1319. 	
  1320. 	function distance (node1 , node2) {
  1321. 		var dist = (node1.geometry.x - node2.geometry.x)*(node1.geometry.x - node2.geometry.x);
  1322. 		dist = dist + (node1.geometry.y - node2.geometry.y)*(node1.geometry.y - node2.geometry.y);
  1323. 		return Math.sqrt(dist);
  1324. 	}
  1325. 	
  1326.   function activateLayer (layerName, flag) {
  1327.     if (flag == true || flag == false) {
  1328.       var index;
  1329.       switch (layerName.toUpperCase()) {
  1330.         case "AERIALS":         index = 1; break;
  1331.         case "CITIES":          index = 2; break;
  1332.         case "ROADS":           index = 3; break;
  1333.         case "GPS POINTS":      index = 4; break;
  1334.         case "AREA MANAGERS":   index = 6; break;
  1335.         case "LANDMARKS":       index = 7; break;
  1336.         case "SPEED CAMERAS":   index = 10; break;
  1337.         case "MAP PROBLEMS":    index = 12; break;
  1338.         case "UPDATE REQUESTS": index = 14; break;
  1339.         case "EDITABLE AREAS":  index = 17; break;
  1340.         case "LIVE USERS":      index = 27;break;
  1341.       }
  1342.       if (index != null) {
  1343.         var layerID = Waze.map.controls[0].map.layers[index].id;
  1344.         Waze.map.controls[33].map.getLayer(layerID).setVisibility(flag);
  1345.       }
  1346.     }
  1347.   }
  1348.  
  1349. 	function afficheObjet (objet) {
  1350. 		for (var e in objet) {alert("objet["+e+"] ="+ objet[e]+" !");}
  1351. 	}
  1352.  
  1353. 	function manage_WME_SSTR(ev) {
  1354. 		localStorage['WME_SSTR_enable'] = document.getElementById ('WME_SSTR_enable').checked == 1;	
  1355. 		var road = [];
  1356. 		for (var i = 0; i<Waze.selectionManager.selectedItems.length;i++) {
  1357. 			var seg = Waze.selectionManager.selectedItems[i].model;
  1358. 			if (seg != null && seg.type == "segment") { road.push(seg);}
  1359. 		}
  1360. 		effaceMenu ();
  1361. 		if(document.getElementById ('WME_SSTR_enable').checked == 1) {	
  1362. 			if (road.length == 1)  {
  1363. 				document.getElementById ('WME_SSTR_Side').style.display = "block";
  1364. 				if (road[0].attributes.roadType == "18") {
  1365. 					document.getElementById ('WME_SSTR_Pklt').style.display = "block";}
  1366. 				else {
  1367. 					document.getElementById ('WME_SSTR_River').style.display = "block";}
  1368. 			}
  1369. 			if (road.length >= 1) {
  1370. 				document.getElementById ('WME_SSTR').style.display = "block";
  1371. 				document.getElementById ('WME_SSTR_Ldmk').style.display = "block";
  1372. 				if (road[0].attributes.junctionID !=null) {
  1373. 					document.getElementById ('WME_SSTR_Rdt').style.display = "block";
  1374. 				}
  1375. 				if (Waze.loginManager.user.normalizedLevel >= 3) {
  1376. 					document.getElementById ('WME_SSTR_CrgAds').style.display = "block";}
  1377. 			}
  1378. 			if (road.length == 2)  {
  1379. 				document.getElementById ('WME_SSTR_12').style.display = "block";
  1380. 			}
  1381. 		}
  1382. 		return;
  1383. 	}
  1384.  
  1385. 	function effaceMenu () {
  1386. 		document.getElementById ('WME_SSTR').style.display = "none";
  1387. 		document.getElementById ('WME_SSTR_Side').style.display = "none";
  1388. 		document.getElementById ('WME_SSTR_12').style.display = "none";
  1389. 		document.getElementById ('WME_SSTR_River').style.display = "none";
  1390. 		document.getElementById ('WME_SSTR_Pklt').style.display = "none";
  1391. 		document.getElementById ('WME_SSTR_Ldmk').style.display = "none";
  1392. 		document.getElementById ('WME_SSTR_Rdt').style.display = "none";
  1393. 		document.getElementById ('WME_SSTR_CrgAds').style.display = "none";
  1394. 	}
  1395. 	
  1396. 	function manageSmoothRiver () {	
  1397. 		if (document.getElementById ('WME_SSTR_SmthRvr').checked == 1) {		// recopie river sur Parling lot
  1398. 			document.getElementById ('WME_SSTR_SmthPlt').checked = 1;}
  1399. 		else {
  1400. 			document.getElementById ('WME_SSTR_SmthPlt').checked = 0;
  1401. 		}
  1402. 		localStorage['WME_SSTR_Smth'] = document.getElementById ('WME_SSTR_SmthRvr').checked == 1;	
  1403. 		return;
  1404. 	}
  1405. 			
  1406. 	function manageSmoothPklt () {
  1407. 		if (document.getElementById ('WME_SSTR_SmthPlt').checked == 1) {  	// recopie Parling lot sur river
  1408. 			document.getElementById ('WME_SSTR_SmthRvr').checked = 1;}
  1409. 		else {
  1410. 			document.getElementById ('WME_SSTR_SmthRvr').checked = 0;}
  1411. 		localStorage['WME_SSTR_Smth'] = document.getElementById ('WME_SSTR_SmthPlt').checked == 1;	
  1412. 		return;
  1413. 	}
  1414. 	
  1415. 	function init_WME_SSTR() {
  1416. 		if (localStorage['WME_SSTR_enable']=='true') {																				// restaure old Values (if exist)
  1417. 			document.getElementById ('WME_SSTR_enable').checked = 1;}
  1418. 		if (localStorage['WME_SSTR_Smth']=='true') {
  1419. 			document.getElementById ('WME_SSTR_SmthRvr').checked = 1;
  1420. 			document.getElementById ('WME_SSTR_SmthPlt').checked = 1;
  1421. 		}
  1422. 		
  1423. 		if (typeof(Waze.map) != "object" || typeof(require.modules) != "object") {
  1424. 			//alert ("WME_MUR_Not_init")
  1425. 			myAlert("WME_SSTR : Waze.map not ready");
  1426. 			setTimeout(init_WME_SSTR, 2001);}
  1427. 		else {
  1428. 			Waze.selectionManager.events.register("selectionchanged", null, manage_WME_SSTR);
  1429. 			document.getElementById('WME_SSTR_enable').onclick = manage_WME_SSTR;
  1430. 			document.getElementById('WME_SSTR_SmthRvr').onclick = manageSmoothRiver;
  1431. 			document.getElementById('WME_SSTR_SmthPlt').onclick = manageSmoothPklt;
  1432. 			effaceMenu();
  1433. 			manage_WME_SSTR();
  1434. 			myAlert("WME_SSTR initialized");
  1435.  
  1436. 			console_log("Select Same Type Roads initialized");
  1437. 		}
  1438.  
  1439. 		//effaceMenu ()
  1440. 		//manage_WME_SSTR();
  1441. 		//Waze.selectionManager.events.register("selectionchanged", null, manage_WME_SSTR);
  1442.  
  1443. 	}
  1444.  
  1445. 	function myAlert (message) {
  1446. 		var myMessage = document.getElementById ('WME_JCB_AlertTxt').innerHTML;
  1447. 		var line = myMessage.split("<br>");
  1448. 		if (line.length==1 && line[0]==""){ line[0]= message;}
  1449. 			else { line.push (message);}
  1450. 		document.getElementById ('WME_JCB_AlertTxt').innerHTML = line.join ("<br>");
  1451. 		document.getElementById ('WME_JCB_AlertBox').style.display = "block";
  1452. 		setTimeout(function() {endAlert();}, 3750 + 500*Math.random());
  1453. 	} 
  1454. 	
  1455. 	function endAlert() {
  1456. 		var myMessage = document.getElementById ('WME_JCB_AlertTxt').innerHTML;
  1457. 		var line = myMessage.split("<br>");
  1458. 		line.shift();
  1459. 		document.getElementById ('WME_JCB_AlertTxt').innerHTML = line.join ("<br>");
  1460. 		if (line.length ==0){
  1461. 			document.getElementById ('WME_JCB_AlertBox').style.display = "none";
  1462. 		}
  1463. 	}
  1464. 	
  1465.   function console_log(msg) {
  1466.     if (console.log) {console.log(msg);}
  1467.   }
  1468. 	
  1469. }
  1470.  
  1471. selectSameTypeRoad();