WME FC Layer

Adds a Functional Class layer for states that publish ArcGIS FC data.

当前为 2019-08-09 提交的版本,查看 最新版本

  1. /* global W */
  2. /* global Promise */
  3. /* global OL */
  4. /* global I18n */
  5. /* global unsafeWindow */
  6. /* global GM_info */
  7. /* global WazeWrap */
  8.  
  9. // // ==UserScript==
  10. // @name WME FC Layer
  11. // @namespace https://greasyfork.org/users/45389
  12. // @version 2019.05.27.001
  13. // @description Adds a Functional Class layer for states that publish ArcGIS FC data.
  14. // @author MapOMatic
  15. // @include /^https:\/\/(www|beta)\.waze\.com\/(?!user\/)(.{2,6}\/)?editor\/?.*$/
  16. // @license GNU GPLv3
  17. // @contributionURL https://github.com/WazeDev/Thank-The-Authors
  18. // @require https://greasyfork.org/scripts/39002-bluebird/code/Bluebird.js?version=255146
  19. // @require https://greasyfork.org/scripts/24851-wazewrap/code/WazeWrap.js
  20. // @grant GM_xmlhttpRequest
  21. // @connect arcgis.com
  22. // @connect arkansas.gov
  23. // @connect azdot.gov
  24. // @connect coloradodot.info
  25. // @connect delaware.gov
  26. // @connect dc.gov
  27. // @connect ga.gov
  28. // @connect uga.edu
  29. // @connect hawaii.gov
  30. // @connect idaho.gov
  31. // @connect in.gov
  32. // @connect iowadot.gov
  33. // @connect illinois.gov
  34. // @connect ksdot.org
  35. // @connect ky.gov
  36. // @connect la.gov
  37. // @connect maine.gov
  38. // @connect md.gov
  39. // @connect ma.us
  40. // @connect state.mi.us
  41. // @connect modot.org
  42. // @connect mt.gov
  43. // @connect unh.edu
  44. // @connect ny.gov
  45. // @connect ncdot.gov
  46. // @connect nd.gov
  47. // @connect oh.us
  48. // @connect or.us
  49. // @connect pa.gov
  50. // @connect sd.gov
  51. // @connect shelbycountytn.gov
  52. // @connect utah.gov
  53. // @connect vermont.gov
  54. // @connect wa.gov
  55. // @connect wv.gov
  56. // @connect wyoroad.info
  57. // ==/UserScript==
  58.  
  59. /* eslint-disable */
  60.  
  61. (function () {
  62. 'use strict';
  63.  
  64. var _settingsStoreName = 'wme_fc_layer';
  65. var _alertUpdate = false;
  66. var _debugLevel = 0;
  67. var _scriptVersion = GM_info.script.version;
  68. var _scriptVersionChanges = [
  69. GM_info.script.name,
  70. 'v' + _scriptVersion,
  71. '',
  72. 'What\'s New',
  73. '------------------------------',
  74. '' // Add important stuff here when _alertUpdate = true.
  75. ].join('\n');
  76. var _mapLayer = null;
  77. var _isAM = false;
  78. var _uid;
  79. var _settings = {};
  80. var _r;
  81. var _mapLayerZIndex = 334;
  82. var _betaIDs = [103400892];
  83. var _statesHash = {
  84. 'Alabama': 'AL', 'Alaska': 'AK', 'American Samoa': 'AS', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA', 'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'District of Columbia': 'DC',
  85. 'Federated States Of Micronesia': 'FM', 'Florida': 'FL', 'Georgia': 'GA', 'Guam': 'GU', 'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA', 'Kansas': 'KS',
  86. 'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Marshall Islands': 'MH', 'Maryland': 'MD', 'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS', 'Missouri': 'MO',
  87. 'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH', 'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC', 'North Dakota': 'ND',
  88. 'Northern Mariana Islands': 'MP', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Palau': 'PW', 'Pennsylvania': 'PA', 'Puerto Rico': 'PR', 'Rhode Island': 'RI', 'South Carolina': 'SC',
  89. 'South Dakota': 'SD', 'Tennessee': 'TN', 'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virgin Islands': 'VI', 'Virginia': 'VA', 'Washington': 'WA', 'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY'
  90. };
  91.  
  92. function reverseStatesHash(stateAbbr) {
  93. for (var stateName in _statesHash) {
  94. if (_statesHash[stateName] === stateAbbr) return stateName;
  95. }
  96. }
  97. var _stateSettings = {
  98. global: {
  99. roadTypes: ['St', 'PS', 'PS2', 'mH', 'MH', 'Ew', 'Rmp', 'Fw'], // Ew = Expressway. For FC's that make it uncertain if they should be MH or FW.
  100. getFeatureRoadType: function (feature, layer) {
  101. var fc = feature.attributes[layer.fcPropName];
  102. return this.getRoadTypeFromFC(fc, layer);
  103. },
  104. getRoadTypeFromFC: function (fc, layer) {
  105. for (var roadType in layer.roadTypeMap) {
  106. if (layer.roadTypeMap[roadType].indexOf(fc) !== -1) {
  107. return roadType;
  108. }
  109. }
  110. return null;
  111. },
  112. isPermitted: function (stateAbbr) { if (_betaIDs.indexOf(_uid) !== -1) return true; var state = _stateSettings[stateAbbr]; if (state.isPermitted) { return state.isPermitted(); } else { return (_r >= 3 && _isAM) || (_r >= 4); } },
  113. getMapLayer: function (stateAbbr, layerID) {
  114. var returnValue;
  115. _stateSettings[stateAbbr].fcMapLayers.forEach(function (layer) {
  116. if (layer.layerID === layerID) {
  117. returnValue = layer;
  118. }
  119. });
  120. return returnValue;
  121. }
  122. },
  123. AL: {
  124. baseUrl: 'https://services.arcgis.com/LZzQi3xDiclG6XvQ/arcgis/rest/services/HPMS_Year2017_F_System_Data/FeatureServer/',
  125. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  126. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  127. fcMapLayers: [
  128. {
  129. layerID: 0, fcPropName: 'F_SYSTEM_V', idPropName: 'OBJECTID', outFields: ['FID', 'F_SYSTEM_V', 'State_Sys'],
  130. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  131. }
  132. ],
  133. isPermitted: function () { return _r >= 3; },
  134. information: { Source: 'ALDOT', Permission: 'Visible to R3+', Description: 'Federal and State highways set to a minimum of mH.' },
  135. getWhereClause: function (context) {
  136. if (context.mapContext.zoom < 4) {
  137. return context.layer.fcPropName + "<>7";
  138. } else {
  139. return null;
  140. }
  141. },
  142. getFeatureRoadType: function (feature, layer) {
  143. var fc = parseInt(feature.attributes[layer.fcPropName]);
  144. if (fc > 4 && feature.attributes.State_Sys === 'YES') { fc = 4; }
  145. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  146. }
  147. },
  148. AK: {
  149. baseUrl: 'https://services.arcgis.com/r4A0V7UzH9fcLVvv/ArcGIS/rest/services/AKDOTPF_Route_Data/FeatureServer/',
  150. defaultColors: { Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  151. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  152. fcMapLayers: [
  153. {
  154. layerID: 13, fcPropName: 'Functional_Class', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'Functional_Class'],
  155. roadTypeMap: { Ew: [1, 2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  156. }
  157. ],
  158. information: { Source: 'Alaska DOT&PF', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  159. getWhereClause: function (context) {
  160. if (context.mapContext.zoom < 4) {
  161. return context.layer.fcPropName + "<>7";
  162. } else {
  163. return null;
  164. }
  165. },
  166. getFeatureRoadType: function (feature, layer) {
  167. if (layer.getFeatureRoadType) {
  168. return layer.getFeatureRoadType(feature);
  169. } else {
  170. return _stateSettings.global.getFeatureRoadType(feature, layer);
  171. }
  172. }
  173. },
  174. AZ: {
  175. baseUrl: 'https://gis.azdot.gov/gis/rest/services/AGOL/FunClass_NHS/MapServer/',
  176. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  177. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  178. fcMapLayers: [
  179. {
  180. layerID: 8, fcPropName: 'FunctionalClass', idPropName: 'OBJECTID',
  181. outFields: ['OBJECTID', 'FunctionalClass', 'RouteId'],
  182. roadTypeMap: { Fw: [1, 11], Ew: [2, 3, 12], MH: [4, 14], mH: [6, 16], PS: [7, 17, 8, 18], St: [] }, maxRecordCount: 1000, supportsPagination: false
  183. }
  184. ],
  185. information: { Source: 'ADOT', Permission: 'Visible to R4+ or R3-AM' },
  186. getWhereClause: function (context) {
  187. return context.layer.fcPropName + ' NOT IN (9, 19)';
  188. },
  189. getFeatureRoadType: function (feature, layer) {
  190. var roadID = feature.attributes.RouteId.trim().replace(/ +/g, ' ');
  191. var roadNum = parseInt(roadID.substring(2, 5));
  192. var fc = parseInt(feature.attributes[layer.fcPropName]);
  193. fc = (fc === 2) ? 4 : fc % 10;
  194. var azIH = [8, 10, 11, 17, 19, 40]; // Interstate hwys in AZ
  195. var isUS = RegExp(/^U\D\d{3}\b/).test(roadID);
  196. var isState = RegExp(/^S\D\d{3}\b/).test(roadID);
  197. var isBiz = RegExp(/^SB\d{3}\b/).test(roadID);
  198. if (fc > 4 && isState && azIH.includes(roadNum) && isBiz) {
  199. fc = 4;
  200. } else if (fc > 4 && isUS) {
  201. fc = isBiz ? 6 : 4;
  202. } else if (fc > 6 && isState) {
  203. fc = isBiz ? 7 : 6;
  204. }
  205. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  206. }
  207. },
  208. AR: {
  209. baseUrl: 'https://gis.arkansas.gov/arcgis/rest/services/FEATURESERVICES/Transportation/FeatureServer/',
  210. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  211. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  212. fcMapLayers: [
  213. {
  214. layerID: 8, fcPropName: 'FunctionalClass', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalClass', 'AH_Route', 'AH_Section'],
  215. roadTypeMap: { Fw: [1, 2], Ew: [], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  216. }
  217. ],
  218. information: { Source: 'ARDOT', Permission: 'Visible to R4+ or R3-AM' },
  219. getWhereClause: function (context) {
  220. return null;
  221. },
  222. getFeatureRoadType: function (feature, layer) {
  223. var attr = feature.attributes;
  224. var fc = parseInt(attr[layer.fcPropName]);
  225. var roadID = parseInt(attr.AH_Route);
  226. var usHwys = [49, 59, 61, 62, 63, 64, 65, 67, 70, 71, 79, 82, 165, 167, 270, 271, 278, 371, 412, 425];
  227. var isUS = usHwys.includes(roadID);
  228. var isState = roadID < 613;
  229. var isBiz = attr.AH_Section[attr.AH_Section.length - 1] === 'B';
  230. if (fc > 3 && isUS) {
  231. fc = isBiz ? 4 : 3;
  232. } else if (fc > 4 && isState) {
  233. fc = isBiz ? 5 : 4;
  234. }
  235. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  236. }
  237. },
  238. CO: {
  239. baseUrl: 'http://dtdapps.coloradodot.info/arcgis/rest/services/MapView/BaseLayers_MapView_ext/MapServer/',
  240. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  241. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  242. fcMapLayers: [
  243. {
  244. layerID: 7, fcPropName: 'FUNCCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASS', 'ROUTE', 'REFPT'],
  245. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  246. },
  247. {
  248. layerID: 17, fcPropName: 'FUNCCLASSID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASSID', 'ROUTE', 'FIPSCOUNTY'],
  249. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  250. },
  251. {
  252. layerID: 18, fcPropName: 'FUNCCLASSID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCCLASSID', 'ROUTE'],
  253. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  254. }
  255. ],
  256. isPermitted: function () { return _r >= 4; },
  257. information: {
  258. Source: 'CDOT', Permission: 'Visible to R4+',
  259. Description: 'Please consult with a state manager before making any changes to road types based on the data presented.'
  260. },
  261. getWhereClause: function (context) {
  262. if (context.mapContext.zoom < 4) {
  263. return context.layer.fcPropName + "<>'7'";
  264. } else {
  265. return null;
  266. }
  267. },
  268. getFeatureRoadType: function (feature, layer) {
  269. var attr = feature.attributes;
  270. var fc = parseInt(attr[layer.fcPropName]);
  271. var route = attr.ROUTE.replace(/ +/g, ' ');
  272. if (layer.layerID === 7) {
  273. var rtnum = parseInt(route.slice(0, 3));
  274. var refpt = attr.REFPT;
  275. var hwys = [6, 24, 25, 34, 36, 40, 50, 70, 84, 85, 87, 138, 160, 285, 287, 350, 385, 400, 491, 550];
  276. var IH = [25, 70];
  277. // Exceptions first, then normal classification
  278. var doNothing = ['024D', '040G'];
  279. var notNothing = ['070K', '070L', '070O', '070Q', '070R'];
  280. var doMin = ['024E', '050D', '070O', '085F', '160D'];
  281. if (doNothing.includes(route) || (rtnum === 70 && route !== '070K' && !notNothing.includes(route))) { }
  282. else if (doMin.includes(route) ||
  283. (rtnum === 40 && refpt > 320 && refpt < 385) ||
  284. (rtnum === 36 && refpt > 79 && refpt < 100.99) ||
  285. (route === '034D' && refpt > 11)) {
  286. fc = 4;
  287. } else if (hwys.includes(rtnum)) {
  288. fc = Math.min(fc, 3);
  289. }
  290. else {
  291. fc = Math.min(fc, 4);
  292. }
  293. }
  294. else {
  295. // All exceptions
  296. var fips = parseInt(attr.FIPSCOUNTY);
  297. if ((fips === 19 && route === 'COLORADO BD') ||
  298. (fips === 37 && (route === 'GRAND AV' || route === 'S H6'))) { fc = 3; }
  299. else if (fips === 67 && route === 'BAYFIELDPAY') { fc = 4; }
  300. }
  301. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  302. }
  303. },
  304. DE: {
  305. baseUrl: 'https://firstmap.delaware.gov/arcgis/rest/services/Transportation/DE_FUNCTIONAL_CLASSIFICATION/MapServer/',
  306. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  307. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  308. fcMapLayers: [
  309. {
  310. layerID: 0, fcPropName: 'VALUE_TEXT', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'VALUE_TEXT'], maxRecordCount: 1000, supportsPagination: false,
  311. roadTypeMap: { Fw: ['Interstate'], Ew: ['Other Expressways & Freeway'], MH: ['Other Principal Arterials'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Minor Collector'], St: ['Local'] }
  312. }
  313. ],
  314. information: { Source: 'Delaware FirstMap', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  315. getWhereClause: function (context) {
  316. if (context.mapContext.zoom < 4) {
  317. return context.layer.fcPropName + " <> 'Local'";
  318. } else {
  319. return null;
  320. }
  321. },
  322. getFeatureRoadType: function (feature, layer) {
  323. if (layer.getFeatureRoadType) {
  324. return layer.getFeatureRoadType(feature);
  325. } else {
  326. return _stateSettings.global.getFeatureRoadType(feature, layer);
  327. }
  328. }
  329. },
  330. DC: {
  331. baseUrl: 'https://maps2.dcgis.dc.gov/dcgis/rest/services/DCGIS_DATA/Transportation_WebMercator/MapServer/',
  332. supportsPagination: false,
  333. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  334. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  335. fetchAllFC: false,
  336. fcMapLayers: [
  337. {
  338. layerID: 48, fcPropName: 'FUNCTIONALCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONALCLASS'], maxRecordCount: 1000, supportsPagination: false,
  339. roadTypeMap: { Fw: ['Interstate'], Ew: ['Other Freeway and Expressway'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Collector'] }
  340. }
  341. ],
  342. information: { Source: 'DDOT', Permission: 'Visible to R4+ or R3-AM' },
  343. getWhereClause: function (context) {
  344. return null;
  345. },
  346. getFeatureRoadType: function (feature, layer) {
  347. if (layer.getFeatureRoadType) {
  348. return layer.getFeatureRoadType(feature);
  349. } else {
  350. return _stateSettings.global.getFeatureRoadType(feature, layer);
  351. }
  352. }
  353. },
  354. FL: {
  355. baseUrl: 'https://services1.arcgis.com/O1JpcwDW8sjYuddV/ArcGIS/rest/services/Functional_Classification_TDA/FeatureServer/',
  356. supportsPagination: false,
  357. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  358. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  359. fetchAllFC: false,
  360. fcMapLayers: [
  361. {
  362. layerID: 0, fcPropName: 'FUNCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCLASS'], maxRecordCount: 1000, supportsPagination: false,
  363. roadTypeMap: { Fw: ['01', '11'], Ew: ['02', '12'], MH: ['04', '14'], mH: ['06', '16'], PS: ['07', '08', '17', '18'] }
  364. }
  365. ],
  366. information: { Source: 'FDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  367. getWhereClause: function (context) {
  368. return null;
  369. },
  370. getFeatureRoadType: function (feature, layer) {
  371. if (layer.getFeatureRoadType) {
  372. return layer.getFeatureRoadType(feature);
  373. } else {
  374. return _stateSettings.global.getFeatureRoadType(feature, layer);
  375. }
  376. }
  377. },
  378. GA: {
  379. baseUrl: 'https://maps.itos.uga.edu/arcgis/rest/services/GDOT/GDOT_FunctionalClass/mapserver/',
  380. supportsPagination: true,
  381. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  382. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  383. fetchAllFC: false,
  384. fcMapLayers: [
  385. { layerID: 0, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  386. { layerID: 1, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  387. { layerID: 2, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  388. { layerID: 3, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  389. { layerID: 4, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  390. { layerID: 5, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  391. { layerID: 6, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } }
  392. ],
  393. information: { Source: 'GDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Federal and State highways set to a minimum of mH.' },
  394. getWhereClause: function (context) {
  395. return null;
  396. },
  397. getFeatureRoadType: function (feature, layer) {
  398. if (layer.getFeatureRoadType) {
  399. return layer.getFeatureRoadType(feature);
  400. } else {
  401. var attr = feature.attributes;
  402. var fc = attr.FUNCTIONAL_CLASS;
  403. if (attr.SYSTEM_CODE === '1' && fc > 4) {
  404. return _stateSettings.global.getRoadTypeFromFC(4, layer);
  405. } else {
  406. return _stateSettings.global.getFeatureRoadType(feature, layer);
  407. }
  408. }
  409. }
  410. },
  411. HI: {
  412. baseUrl: 'http://geodata.hawaii.gov/arcgis/rest/services/Transportation/MapServer/',
  413. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  414. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  415. fcMapLayers: [
  416. {
  417. layerID: 12, fcPropName: 'funsystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'funsystem'],
  418. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  419. }
  420. ],
  421. information: { Source: 'HDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  422. getWhereClause: function (context) {
  423. if (context.mapContext.zoom < 4) {
  424. return context.layer.fcPropName + "<>7";
  425. } else {
  426. return null;
  427. }
  428. },
  429. getFeatureRoadType: function (feature, layer) {
  430. if (layer.getFeatureRoadType) {
  431. return layer.getFeatureRoadType(feature);
  432. } else {
  433. return _stateSettings.global.getFeatureRoadType(feature, layer);
  434. }
  435. }
  436. },
  437. ID: {
  438. baseUrl: 'https://gis.itd.idaho.gov/arcgisprod/rest/services/IPLAN/Functional_Classification/MapServer/',
  439. supportsPagination: false,
  440. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  441. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  442. fetchAllFC: true,
  443. fcMapLayers: [
  444. { layerID: 0, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  445. { layerID: 1, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  446. { layerID: 2, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  447. { layerID: 3, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  448. { layerID: 4, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } },
  449. { layerID: 5, fcPropName: 'FCCODE', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FCCODE'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6] } }
  450. ],
  451. information: { Source: 'ITD', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  452. getWhereClause: function (context) {
  453. return null;
  454. },
  455. getFeatureRoadType: function (feature, layer) {
  456. if (layer.getFeatureRoadType) {
  457. return layer.getFeatureRoadType(feature);
  458. } else {
  459. return _stateSettings.global.getFeatureRoadType(feature, layer);
  460. }
  461. }
  462. },
  463. IL: {
  464. baseUrl: 'http://ags10s1.dot.illinois.gov/ArcGIS/rest/services/IRoads/IRoads_53/MapServer/',
  465. supportsPagination: false,
  466. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', CH: '#ff5e0e' },
  467. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  468. fcMapLayers: [
  469. {
  470. layerID: 3, idPropName: 'OBJECTID', fcPropName: 'FC', outFields: ['FC', 'MRK_RT_TYP', 'CH', 'OBJECTID'],
  471. roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  472. }
  473. ],
  474. isPermitted: function () { return _r >= 4; },
  475. information: { Source: 'IDOT', Permission: 'Visible to R4+' },
  476. getWhereClause: function (context) {
  477. return context.mapContext.zoom < 4 ? "FC<>7" : null;
  478. },
  479. getFeatureRoadType: function (feature, layer) {
  480. var attr = feature.attributes;
  481. var fc = attr.FC;
  482. var type = attr.MRK_RT_TYP;
  483. if (fc > 3 && type === 'U') { // US Route
  484. fc = 3;
  485. } else if (fc > 4 && type === 'S') { // State Route
  486. fc = 4;
  487. } else if (fc > 6 && attr.CH !== '0000') { // County Route
  488. fc = 6;
  489. }
  490. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  491. }
  492. },
  493. IN: {
  494. baseUrl: 'https://gis.in.gov/arcgis/rest/services/DOT/INDOT_LTAP/FeatureServer/',
  495. supportsPagination: false,
  496. overrideUrl: '1Sbwc7e6BfHpZWSTfU3_1otXGSxHrdDYcbn7fOf1VjpA',
  497. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  498. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []], hideRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  499. fcMapLayers: [
  500. {
  501. layerID: 10, idPropName: 'OBJECTID', fcPropName: 'FUNCTIONAL_CLASS', outFields: ['FUNCTIONAL_CLASS', 'OBJECTID', 'TO_DATE'],
  502. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 100000, supportsPagination: false
  503. }
  504. ],
  505. isPermitted: function () { return true; },
  506. information: { Source: 'INDOT', Description: 'Raw unmodified FC data.' },
  507. getWhereClause: function (context) {
  508. var whereParts = ['TO_DATE IS NULL'];
  509. if (context.mapContext.zoom < 4) {
  510. whereParts += ' AND ' + context.layer.fcPropName + '<>7';
  511. }
  512. return whereParts;
  513. },
  514. getFeatureRoadType: function (feature, layer) {
  515. if (layer.getFeatureRoadType) {
  516. return layer.getFeatureRoadType(feature);
  517. } else {
  518. return _stateSettings.global.getFeatureRoadType(feature, layer);
  519. }
  520. }
  521. },
  522. IA: {
  523. baseUrl: 'https://gis.iowadot.gov/public/rest/services/RAMS/Road_Network/MapServer/',
  524. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', PSGr: '#cc6533', StGr: '#e99cb6' },
  525. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  526. fcMapLayers: [
  527. {
  528. layerID: 0, fcPropName: 'FED_FUNCTIONAL_CLASS', idPropName: 'OBJECTID',
  529. outFields: ['OBJECTID', 'FED_FUNCTIONAL_CLASS', 'STATE_ROUTE_NAME_1', 'ACCESS_CONTROL', 'SURFACE_TYPE'],
  530. roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  531. }
  532. ],
  533. information: { Source: 'Iowa DOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Additional colors denote unpaved PS and LS segements.' },
  534. getWhereClause: function (context) {
  535. var theWhereClause = "FACILITY_TYPE<>'7'"; // Removed proposed roads
  536. if (context.mapContext.zoom < 4) {
  537. theWhereClause += " AND " + context.layer.fcPropName + "<>'7'";
  538. }
  539. return theWhereClause;
  540. },
  541. getFeatureRoadType: function (feature, layer) {
  542. var attr = feature.attributes;
  543. var fc = parseInt(attr[layer.fcPropName]);
  544. var isFw = attr.ACCESS_CONTROL === 1;
  545. var isUS = RegExp('^STATE OF IOWA, US').test(attr.STATE_ROUTE_NAME_1);
  546. var isState = RegExp('^STATE OF IOWA, IA').test(attr.STATE_ROUTE_NAME_1);
  547. if (isFw) {
  548. fc = 1;
  549. } else if (fc > 3 && isUS) {
  550. fc = 3;
  551. } else if (fc > 4 && isState) {
  552. fc = 4;
  553. }
  554. if (fc > 4 && attr.SURFACE_TYPE === 20) {
  555. return fc < 7 ? 'PSGr' : 'StGr';
  556. } else {
  557. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  558. }
  559. }
  560. },
  561. KS: {
  562. baseUrl: 'http://wfs.ksdot.org/arcgis_web_adaptor/rest/services/Transportation/',
  563. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  564. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  565. fcMapLayers: [
  566. {
  567. layerID: 0, layerPath: 'Non_State_System/MapServer/', idPropName: 'ID2', fcPropName: 'FUNCLASS', outFields: ['FUNCLASS', 'ID2', 'ROUTE_ID'],
  568. roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  569. },
  570. {
  571. layerID: 1, layerPath: 'National_Highway_System/MapServer/', idPropName: 'OBJECTID', fcPropName: 'FUN_CLASS_CD', outFields: ['FUN_CLASS_CD', 'OBJECTID', 'PREFIX', 'ACCESS_CONTROL'],
  572. roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  573. },
  574. {
  575. layerID: 0, layerPath: 'State_System/MapServer/', idPropName: 'OBJECTID', fcPropName: 'FUN_CLASS_CD', outFields: ['FUN_CLASS_CD', 'OBJECTID', 'PREFIX', 'ACCESS_CONTROL'],
  576. roadTypeMap: { Fw: [1], MH: [2, 3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  577. }
  578. ],
  579. information: { Source: 'KDOT', Permission: 'Visible to R4+ or R3-AM' },
  580. getWhereClause: function (context) {
  581. if (context.mapContext.zoom < 4) {
  582. return context.layer.fcPropName + "<>'7'";
  583. } else {
  584. return null;
  585. }
  586. },
  587. getFeatureRoadType: function (feature, layer) {
  588. var attr = feature.attributes;
  589. var fc = parseInt(attr[layer.fcPropName]);
  590. var roadPrefix = attr.PREFIX;
  591. var isFw = parseInt(attr.ACCESS_CONTROL) === 1;
  592. var isUS = roadPrefix === 'U';
  593. var isState = roadPrefix === 'K';
  594. if (isFw) {
  595. fc = 1;
  596. } else if (fc > 3 && isUS) {
  597. fc = 3;
  598. } else if (fc > 4 && isState) {
  599. fc = 4;
  600. }
  601. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  602. },
  603. },
  604. KY: {
  605. baseUrl: 'https://maps.kytc.ky.gov/arcgis/rest/services/BaseMap/System/MapServer/',
  606. supportsPagination: false,
  607. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  608. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  609. fcMapLayers: [
  610. {
  611. layerID: 0, idPropName: 'OBJECTID', fcPropName: 'FC', outFields: ['FC', 'OBJECTID', 'RT_PREFIX', 'RT_SUFFIX'],
  612. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  613. }
  614. ],
  615. isPermitted: function () { return true; },
  616. information: { Source: 'KYTC' },
  617. getWhereClause: function (context) {
  618. if (context.mapContext.zoom < 4) {
  619. return context.layer.fcPropName + "<>'7'";
  620. } else {
  621. return null;
  622. }
  623. },
  624. getFeatureRoadType: function (feature, layer) {
  625. var attr = feature.attributes;
  626. var fc = parseInt(attr[layer.fcPropName]);
  627. if (fc > 3 && attr.RT_PREFIX === 'US') {
  628. var suffix = attr.RT_SUFFIX;
  629. fc = (suffix && suffix.indexOf('X') > -1) ? 4 : 3;
  630. }
  631. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  632. }
  633. },
  634. LA: {
  635. baseUrl: 'https://giswebnew.dotd.la.gov/arcgis/rest/services/Transportation/LA_RoadwayFunctionalClassification/FeatureServer/',
  636. supportsPagination: false,
  637. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  638. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  639. fcMapLayers: [
  640. { layerID: 0, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  641. { layerID: 1, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  642. { layerID: 2, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  643. { layerID: 3, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  644. { layerID: 4, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  645. { layerID: 5, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  646. { layerID: 6, fcPropName: 'FunctionalSystem', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FunctionalSystem', 'RouteID'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  647. ],
  648. information: { Source: 'LaDOTD', Permission: 'Visible to R4+ or R3-AM' },
  649. getWhereClause: function (context) {
  650. if (context.mapContext.zoom < 4) {
  651. return context.layer.fcPropName + "<>'7'"; // OR State_Route LIKE 'US%' OR State_Route LIKE 'LA%'";
  652. } else {
  653. return null;
  654. }
  655. },
  656. getFeatureRoadType: function (feature, layer) {
  657. var fc = feature.attributes[layer.fcPropName];
  658. if (fc === '2a' || fc === '2b') { fc = 2; }
  659. fc = parseInt(fc);
  660. var route = feature.attributes.RouteID.split('_')[1].trim();
  661. var isUS = /^US \d/.test(route);
  662. var isState = /^LA \d/.test(route);
  663. var isBiz = / BUS$/.test(route);
  664. if (fc > 3 && isUS) {
  665. fc = isBiz ? 4 : 3;
  666. } else if (fc > 4 && isState) {
  667. fc = isBiz ? 5 : 4;
  668. }
  669. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  670. }
  671. },
  672. ME: {
  673. baseUrl: 'https://arcgisserver.maine.gov/arcgis/rest/services/mdot/MaineDOT_Dynamic/MapServer/',
  674. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  675. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  676. fcMapLayers: [
  677. {
  678. layerID: 811, fcPropName: 'fedfunccls', idPropName: 'objectid', outFields: ['objectid', 'fedfunccls', 'prirtename'],
  679. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  680. }
  681. ],
  682. information: { Source: 'MaineDOT', Permission: 'Visible to R4+ or R3-AM' },
  683. getWhereClause: function (context) {
  684. if (context.mapContext.zoom < 4) {
  685. return context.layer.fcPropName + "<>'Local'";
  686. } else {
  687. return null;
  688. }
  689. },
  690. getFeatureRoadType: function (feature, layer) {
  691. var attr = feature.attributes;
  692. var fc = attr[layer.fcPropName];
  693. switch (fc) {
  694. case 'Princ art interstate': fc = 1; break;
  695. case 'Princ art other f&e': fc = 2; break;
  696. case 'Other princ arterial': fc = 3; break;
  697. case 'Minor arterial': fc = 4; break;
  698. case 'Major/urb collector':
  699. case 'Minor collector': fc = 5; break;
  700. default: fc = 7;
  701. }
  702. var route = attr.prirtename;
  703. var isUS = RegExp(/^US \d/).test(route);
  704. var isState = RegExp(/^ST RTE \d/).test(route);
  705. var isBiz = (isUS && RegExp(/(1B|1BS)$/).test(route)) || (isState && RegExp(/(15B|24B|25B|137B)$/).test(route));
  706. if (fc > 3 && isUS) {
  707. fc = isBiz ? 4 : 3;
  708. } else if (fc > 4 && isState) {
  709. fc = isBiz ? 5 : 4;
  710. }
  711. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  712. }
  713. },
  714. MD: {
  715. baseUrl: 'https://geodata.md.gov/imap/rest/services/Transportation/MD_HighwayPerformanceMonitoringSystem/MapServer/',
  716. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#ffff00', St: '#eeeeee' },
  717. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  718. fcMapLayers: [
  719. { layerID: 2, fcPropName: 'FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS', 'ID_PREFIX', 'MP_SUFFIX'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  720. ],
  721. information: { Source: 'MDOT', Permission: 'Visible to R4+ or R3-AM' },
  722. getWhereClause: function (context) {
  723. if (context.mapContext.zoom < 4) {
  724. return "(FUNCTIONAL_CLASS < 7 OR ID_PREFIX IN('MD'))";
  725. } else {
  726. return null;
  727. }
  728. },
  729. getFeatureRoadType: function (feature, layer) {
  730. var attr = feature.attributes;
  731. var fc = parseInt(attr.FUNCTIONAL_CLASS);
  732. var isUS = attr.ID_PREFIX === 'US';
  733. var isState = attr.ID_PREFIX === 'MD';
  734. var isBiz = attr.MP_SUFFIX === 'BU';
  735. if (fc > 3 && isUS) {
  736. fc = isBiz ? 4 : 3;
  737. } else if (fc > 4 && isState) {
  738. fc = isBiz ? 5 : 4;
  739. }
  740. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  741. }
  742. },
  743. MA: {
  744. baseUrl: 'https://gis.massdot.state.ma.us/arcgis/rest/services/Roads/RoadInventory/MapServer/',
  745. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  746. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  747. fcMapLayers: [
  748. {
  749. layerID: 0, fcPropName: 'F_F_Class', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_F_Class', 'Route_ID'],
  750. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  751. }
  752. ],
  753. information: { Source: 'MDOT', Permission: 'Visible to R4+ or R3-AM' },
  754. getWhereClause: function (context) {
  755. if (context.mapContext.zoom < 4) {
  756. return context.layer.fcPropName + "<>'7'";
  757. } else {
  758. return null;
  759. }
  760. },
  761. getFeatureRoadType: function (feature, layer) {
  762. var attr = feature.attributes;
  763. var fc = parseInt(attr[layer.fcPropName]);
  764. var route = attr.Route_ID;
  765. var isUS = /^US\d/.test(route);
  766. var isState = /^SR\d/.test(route);
  767. if (fc > 3 && isUS) {
  768. fc = 3;
  769. } else if (fc > 4 && isState) {
  770. fc = 4;
  771. }
  772. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  773. }
  774. },
  775. MI: {
  776. baseUrl: 'https://gisp.mcgi.state.mi.us/arcgis/rest/services/MDOT/NFC/MapServer/',
  777. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  778. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  779. fcMapLayers: [
  780. { layerID: 2, idPropName: 'OBJECTID', fcPropName: 'NFC', outFields: ['NFC'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  781. ],
  782. isPermitted: function () { return true; },
  783. information: { Source: 'MDOT', Description: 'Raw unmodified FC data.' },
  784. getWhereClause: function (context) {
  785. if (context.mapContext.zoom < 4) {
  786. return context.layer.fcPropName + '<>7';
  787. } else {
  788. return null;
  789. }
  790. },
  791. getFeatureRoadType: function (feature, layer) {
  792. if (layer.getFeatureRoadType) {
  793. return layer.getFeatureRoadType(feature);
  794. } else {
  795. return _stateSettings.global.getFeatureRoadType(feature, layer);
  796. }
  797. }
  798. },
  799. MO: {
  800. baseUrl: 'http://mapping.modot.org/external/rest/services/BaseMap/TmsUtility/MapServer/',
  801. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  802. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  803. fcMapLayers: [
  804. {
  805. layerID: 5, fcPropName: 'FUNC_CLASS_NAME', idPropName: 'SS_PAVEMENT_ID', outFields: ['SS_PAVEMENT_ID', 'FUNC_CLASS_NAME', 'TRAVELWAY_DESG', 'TRAVELWAY_NAME', 'ACCESS_CAT_NAME'],
  806. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  807. }
  808. ],
  809. isPermitted: function () { return _r >= 3 || (_r >= 2 && _isAM); },
  810. information: { Source: 'MoDOT', Permission: 'Visible to R3+ or R2-AM' },
  811. getWhereClause: function (context) {
  812. if (context.mapContext.zoom < 1) {
  813. return '1=0'; //WME very laggy at zoom 0
  814. } else {
  815. // Remove duplicate rows, but suss out interstate business loops
  816. return "FUNC_CLASS_NAME <> ' ' AND (TRAVELWAY_ID = CNTL_TW_ID OR (TRAVELWAY_ID <> CNTL_TW_ID AND TRAVELWAY_DESG = 'LP'))";
  817. }
  818. },
  819. getFeatureRoadType: function (feature, layer) {
  820. var attr = feature.attributes;
  821. var fc = attr[layer.fcPropName];
  822. var rtType = attr.TRAVELWAY_DESG;
  823. var route = attr.TRAVELWAY_NAME;
  824. switch (fc) {
  825. case 'INTERSTATE': fc = 1; break;
  826. case 'FREEWAY': fc = 2; break;
  827. case 'PRINCIPAL ARTERIAL': fc = 3; break;
  828. case 'MINOR ARTERIAL': fc = 4; break;
  829. case 'MAJOR COLLECTOR': fc = 5; break
  830. case 'MINOR COLLECTOR': fc = 6; break;
  831. default: fc = 8; // not a typo
  832. }
  833. var usHwys = ['24', '36', '40', '50', '54', '56', '59', '60', '61', '62', '63', '65', '67', '69', '71', '136', '159', '160', '166', '169', '275', '400', '412'];
  834. var isUS = ['US', 'LP'].includes(rtType); // is US or interstate biz
  835. var isState = ['MO', 'AL'].includes(rtType);
  836. var isSup = rtType === 'RT';
  837. var isBiz = ['BU', 'SP'].includes(rtType) || /BUSINESS .+ \d/.test(route);
  838. var isUSBiz = isBiz && usHwys.includes(route);
  839. if ((fc === 2 && attr.ACCESS_CAT_NAME !== 'FULL') || (fc > 3 && isUS)) {
  840. fc = 3;
  841. } else if (fc > 4 && (isState || isUSBiz)) {
  842. fc = 4;
  843. } else if (fc > 6 && (isSup || isBiz)) {
  844. fc = 6;
  845. }
  846. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  847. }
  848. },
  849. MT: {
  850. baseUrl: 'https://app.mdt.mt.gov/arcgis/rest/services/Standard/ROUTES/MapServer/',
  851. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  852. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  853. fcMapLayers: [
  854. { layerID: 0, fcPropName: 'FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FC', 'SIGN_ROUTE', 'ROUTE_NAME'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false },
  855. { layerID: 1, fcPropName: 'FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FC', 'SIGN_ROUTE', 'ROUTE_NAME'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false }
  856. ],
  857. isPermitted: function () { return _r >= 3; },
  858. information: { Source: 'MDT', Permission: 'Visible to R3+' },
  859. getWhereClause: function (context) {
  860. if (context.mapContext.zoom < 4) {
  861. return context.layer.fcPropName + "<>'LOCAL'";
  862. } else {
  863. return null;
  864. }
  865. },
  866. getFeatureRoadType: function (feature, layer) {
  867. var fc = feature.attributes.FC;
  868. switch (fc) {
  869. case 'PRINCIPAL ARTERIAL - INTERSTATE': fc = 1; break;
  870. case 'PRINCIPAL ARTERIAL - NON-INTERSTATE': fc = 3; break;
  871. case 'MINOR ARTERIAL': fc = 4; break;
  872. case 'MAJOR COLLECTOR':
  873. case 'MINOR COLLECTOR': fc = 5; break;
  874. default: fc = 7;
  875. }
  876. var roadID = feature.attributes.SIGN_ROUTE;
  877. if (!roadID) { roadID = feature.attributes.ROUTE_NAME; }
  878. var isUS = RegExp(/^US \d+/).test(roadID);
  879. var isState = RegExp(/^MONTANA \d+|ROUTE \d+|S \d{3}\b/).test(roadID);
  880. if (fc > 3 && isUS) { fc = 3; }
  881. else if (fc > 4 && isState) { fc = 4; }
  882. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  883. }
  884. },
  885. NH: {
  886. baseUrl: 'https://nhgeodata.unh.edu/nhgeodata/rest/services/GRANITView/GV_BaseLayers/MapServer/',
  887. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  888. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  889. fcMapLayers: [
  890. {
  891. layerID: 18, fcPropName: 'FUNCT_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCT_SYSTEM', 'STREET_ALIASES', 'TIER'],
  892. roadTypeMap: { Fw: [1], Ew: [2], MH: [2, 3], mH: [4], PS: [5, 6], St: [7, 0] }, maxRecordCount: 1000, supportsPagination: false
  893. }
  894. ],
  895. isPermitted: function () { return _r >= 3; },
  896. information: { Source: 'NH GRANIT', Permission: 'Visible to R3+' },
  897. getWhereClause: function (context) {
  898. if (context.mapContext.zoom < 4) {
  899. return context.layer.fcPropName + "<>7 AND " + context.layer.fcPropName + "<>0";
  900. } else {
  901. return null;
  902. }
  903. },
  904. getFeatureRoadType: function (feature, layer) {
  905. var fc = parseInt(feature.attributes[layer.fcPropName]);
  906. if (!(fc > 0)) { fc = 7; }
  907. var route = feature.attributes.STREET_ALIASES;
  908. var isUS = RegExp(/US /).test(route);
  909. var isState = RegExp(/NH /).test(route);
  910. if (fc === 2) { feature.attributes.TIER === 1 ? fc = 1 : fc = 3; }
  911. else if (fc > 3 && isUS) { RegExp(/US 3B/).test(route) ? fc = 4 : fc = 3; }
  912. else if (fc > 4 && isState) { fc = 4; }
  913. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  914. }
  915. },
  916. NM: {
  917. baseUrl: 'https://services.arcgis.com/hOpd7wfnKm16p9D9/ArcGIS/rest/services/NMDOT_Functional_Class/FeatureServer/',
  918. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  919. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  920. fcMapLayers: [
  921. {
  922. layerID: 0, fcPropName: 'Func_Class', idPropName: 'OBJECTID_1', maxRecordCount: 1000, supportsPagination: false,
  923. outFields: ['OBJECTID_1', 'Func_Class', 'D_RT_ROUTE'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  924. }
  925. ],
  926. isPermitted: function () { return true; },
  927. information: { Source: 'NMDOT' },
  928. getWhereClause: function (context) {
  929. return null;
  930. },
  931. getFeatureRoadType: function (feature, layer) {
  932. var fc = parseInt(feature.attributes[layer.fcPropName]);
  933. var roadType = feature.attributes.D_RT_ROUTE.split('-', 1).shift();
  934. var isBiz = roadType === 'BL'; // Interstate Business Loop
  935. var isUS = roadType === 'US';
  936. var isState = roadType === 'NM';
  937. if (roadType === 'IX') { fc = 0; }
  938. else if (fc > 3 && (isBiz || isUS)) { fc = 3; }
  939. else if (fc > 4 && isState) { fc = 4; }
  940. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  941. }
  942. },
  943. NY: {//https://gis3.dot.ny.gov/arcgis/rest/services/Basemap/MapServer/21
  944. baseUrl: 'https://gis3.dot.ny.gov/arcgis/rest/services/',
  945. defaultColors: { Fw: '#ff00c5', Ew: '#5f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  946. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  947. fcMapLayers: [
  948. {
  949. layerID: 'FC/MapServer/1', fcPropName: 'FUNC_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNC_CLASS', 'SEGMENT_NAME', 'ROUTE_NO'], roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 8, 17, 18] },
  950. maxRecordCount: 1000, supportsPagination: false
  951. },
  952. { layerID: 'Basemap/MapServer/21', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'SHIELD'], maxRecordCount: 1000, supportsPagination: false }
  953. ],
  954. information: { Source: 'NYSDOT', Permission: 'Visible to R4+ or R3-AM' },
  955. getWhereClause: function (context) {
  956. if (context.layer.layerID === 'Basemap/MapServer/21') {
  957. return ("SHIELD IN ('C','CT')");
  958. } else {
  959. return null;
  960. }
  961. },
  962. getFeatureRoadType: function (feature, layer) {
  963. var roadType;
  964. if (layer.layerID === 'Basemap/MapServer/21') {
  965. roadType = 'PS';
  966. } else {
  967. roadType = _stateSettings.global.getFeatureRoadType(feature, layer);
  968. var routeNo = feature.attributes.ROUTE_NO;
  969. if (/^NY.*/.test(routeNo)) {
  970. if (roadType === 'PS') roadType = 'mH';
  971. } else if (/^US.*/.test(routeNo)) {
  972. if (roadType === 'PS' || roadType === 'mH') roadType = 'MH';
  973. }
  974. }
  975. return roadType;
  976. }
  977. },
  978. NC: {
  979. baseUrl: 'https://gis11.services.ncdot.gov/arcgis/rest/services/NCDOT_FunctionalClassQtr/MapServer/',
  980. defaultColors: { Fw: '#ff00c5', Rmp: '#999999', Ew: '#5f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  981. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  982. fcMapLayers: [
  983. { layerID: 0, fcPropName: 'FuncClass', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FuncClass', 'RouteClass'], roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, zoomLevels: [3, 4, 5, 6, 7, 8, 9, 10], maxRecordCount: 1000, supportsPagination: false }
  984. //{ layerID:2, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[2], maxRecordCount:1000, supportsPagination:false },
  985. //{ layerID:3, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[0,1], maxRecordCount:1000, supportsPagination:false },
  986. //{ layerID:4, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  987. //{ layerID:5, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  988. //{ layerID:6, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false }
  989. ],
  990. isPermitted: function () { return _r >= 3; },
  991. information: { Source: 'NCDOT', Permission: 'Visible to R3+' },
  992. getWhereClause: function (context) {
  993. if (context.mapContext.zoom < 4) {
  994. var clause = '(' + context.layer.fcPropName + " < 7 OR RouteClass IN ('I','FED','NC','RMP','US'))";
  995. return clause;
  996. } else {
  997. return null;
  998. }
  999. },
  1000. getFeatureRoadType: function (feature, layer) {
  1001. var fc = feature.attributes[layer.fcPropName];
  1002. var roadType;
  1003. switch (this.getHwySys(feature)) {
  1004. case 'interstate':
  1005. roadType = 'Fw';
  1006. break;
  1007. case 'us':
  1008. roadType = fc <= 2 ? 'Ew' : 'MH';
  1009. break;
  1010. case 'state':
  1011. roadType = fc === 2 ? 'Ew' : (fc === 3 ? 'MH' : 'mH');
  1012. break;
  1013. case 'ramp':
  1014. roadType = 'Rmp';
  1015. break;
  1016. default:
  1017. roadType = fc === 2 ? 'Ew' : (fc === 3 ? 'MH' : (fc === 4 ? 'mH' : (fc <= 6 ? 'PS' : 'St')));
  1018. }
  1019. return roadType;
  1020. },
  1021. getHwySys: function (feature) {
  1022. var hwySys;
  1023. switch (feature.attributes.RouteClass) {
  1024. case '1':
  1025. hwySys = 'interstate';
  1026. break;
  1027. case '2':
  1028. hwySys = 'us';
  1029. break;
  1030. case '3':
  1031. hwySys = 'state';
  1032. break;
  1033. case '80':
  1034. hwySys = 'ramp';
  1035. break;
  1036. default:
  1037. hwySys = 'local';
  1038. }
  1039. return hwySys;
  1040. }
  1041. },
  1042. ND: {
  1043. baseUrl: 'https://gis.dot.nd.gov/arcgis/rest/services/external/transinfo/MapServer/',
  1044. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1045. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1046. fcMapLayers: [
  1047. {
  1048. layerID: 10, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { Fw: ['Interstate'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Collector'], St: ['Local'] },
  1049. maxRecordCount: 1000, supportsPagination: false
  1050. },
  1051. {
  1052. layerID: 11, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { Fw: ['Interstate'], MH: ['Principal Arterial'], mH: ['Minor Arterial'], PS: ['Major Collector', 'Collector'], St: ['Local'] },
  1053. maxRecordCount: 1000, supportsPagination: false
  1054. },
  1055. {
  1056. layerID: 12, fcPropName: 'FUNCTION_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTION_CLASS'], roadTypeMap: { PS: ['Major Collector', 'Collector'] },
  1057. maxRecordCount: 1000, supportsPagination: false
  1058. },
  1059. {
  1060. layerID: 16, fcPropName: 'SYSTEM_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'SYSTEM_CD', 'SYSTEM_DESC', 'HIGHWAY', 'HWY_SUFFIX'], roadTypeMap: { Fw: [1, 11], MH: [2, 14], mH: [6, 7, 16, 19] },
  1061. maxRecordCount: 1000, supportsPagination: false
  1062. }
  1063. ],
  1064. information: { Source: 'NDDOT', Permission: 'Visible to R4+ or R3-AM' },
  1065. getWhereClause: function (context) {
  1066. if (context.mapContext.zoom < 4) {
  1067. if (context.layer.layerID !== 16) return context.layer.fcPropName + "<>'Local'";
  1068. } else {
  1069. return null;
  1070. }
  1071. },
  1072. getFeatureRoadType: function (feature, layer) {
  1073. return _stateSettings.global.getFeatureRoadType(feature, layer);
  1074. }
  1075. },
  1076. OH: {
  1077. baseUrl: 'https://gis.dot.state.oh.us/arcgis/rest/services/TIMS/Roadway_Information/MapServer/',
  1078. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1079. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1080.  
  1081. fcMapLayers: [
  1082. {
  1083. layerID: 8, fcPropName: 'FUNCTION_CLASS', idPropName: 'ObjectID', outFields: ['FUNCTION_CLASS', 'ROUTE_TYPE', 'ROUTE_NBR', 'ObjectID'],
  1084. maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1085. }
  1086. ],
  1087. isPermitted: function () { return true; },
  1088. information: { Source: 'ODOT' },
  1089. getWhereClause: function (context) {
  1090. if (context.mapContext.zoom < 4) {
  1091. var clause = '(' + context.layer.fcPropName + " < 7 OR ROUTE_TYPE IN ('CR','SR','US'))";
  1092. return clause;
  1093. } else {
  1094. return null;
  1095. }
  1096. },
  1097. getFeatureRoadType: function (feature, layer) {
  1098. var fc = feature.attributes[layer.fcPropName];
  1099. var prefix = feature.attributes.ROUTE_TYPE;
  1100. var isUS = prefix === 'US';
  1101. var isState = prefix === 'SR';
  1102. var isCounty = prefix === 'CR';
  1103. if (isUS && fc > 3) { fc = 3; }
  1104. if (isState && fc > 4) { fc = 4; }
  1105. if (isCounty && fc > 6) { fc = 6; }
  1106. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1107. }
  1108. },
  1109. OK: {
  1110. baseUrl: 'https://services6.arcgis.com/RBtoEUQ2lmN0K3GY/arcgis/rest/services/Roadways/FeatureServer/',
  1111. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1112. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1113. fcMapLayers: [
  1114. {
  1115. layerID: 0, fcPropName: 'FUNCTIONALCLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONALCLASS', 'FHWAPRIMARYROUTE', 'ODOTROUTECLASS', 'ACCESSCONTROL'],
  1116. maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1117. }
  1118. ],
  1119. information: { Source: 'ODOT', Permission: 'Visible to R4+ or R3-AM' },
  1120. getWhereClause: function (context) {
  1121. if (context.mapContext.zoom < 4) {
  1122. return context.layer.fcPropName + " < 7 OR ODOTROUTECLASS IN ('U','S','I')";
  1123. } else {
  1124. return null;
  1125. }
  1126. },
  1127. getFeatureRoadType: function (feature, layer) {
  1128. var fc = feature.attributes[layer.fcPropName];
  1129. var route = (feature.attributes.FHWAPRIMARYROUTE || '').trim();
  1130. var isBusinessOrSpur = /BUS$|SPR$/i.test(route);
  1131. var prefix = isBusinessOrSpur ? route.substring(0, 1) : feature.attributes.ODOTROUTECLASS;
  1132. var isFw = parseInt(feature.attributes.ACCESSCONTROL) === 1;
  1133. var isInterstate = prefix === 'I';
  1134. var isUS = prefix === 'U';
  1135. var isState = prefix === 'S';
  1136. if (isFw) { fc = 1; }
  1137. else if (fc > 3 && ((isUS && !isBusinessOrSpur) || (isInterstate && isBusinessOrSpur))) { fc = 3; }
  1138. else if (fc > 4 && ((isUS && isBusinessOrSpur) || (isState && !isBusinessOrSpur))) { fc = 4; }
  1139. else if (fc > 5 && isState && isBusinessOrSpur) { fc = 5; }
  1140. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1141. }
  1142. },
  1143. OR: {
  1144. baseUrl: 'https://gis.odot.state.or.us/arcgis/rest/services/transgis/data_catalog_display/Mapserver/',
  1145. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1146. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1147. fcMapLayers: [
  1148. {
  1149. layerID: 78, fcPropName: 'NEW_FC_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'NEW_FC_CD'],
  1150. roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  1151. },
  1152. {
  1153. layerID: 80, fcPropName: 'NEW_FC_CD', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'NEW_FC_CD'],
  1154. roadTypeMap: { Fw: ['1'], Ew: ['2'], MH: ['3'], mH: ['4'], PS: ['5', '6'], St: ['7'] }, maxRecordCount: 1000, supportsPagination: false
  1155. }
  1156. ],
  1157. information: { Source: 'ODOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  1158. getWhereClause: function (context) {
  1159. if (context.mapContext.zoom < 4) {
  1160. return context.layer.fcPropName + " <> '7'";
  1161. } else {
  1162. return null;
  1163. }
  1164. },
  1165. getFeatureRoadType: function (feature, layer) {
  1166. if (layer.getFeatureRoadType) {
  1167. return layer.getFeatureRoadType(feature);
  1168. } else {
  1169. return _stateSettings.global.getFeatureRoadType(feature, layer);
  1170. }
  1171. }
  1172. },
  1173. PA: {
  1174. baseUrl: 'https://www.pdarcgissvr.pa.gov/penndotgis/rest/services/PennShare/PennShare/MapServer/',
  1175. supportsPagination: false,
  1176. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1177. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1178. fcMapLayers: [
  1179. {
  1180. layerID: 3, features: new Map(), fcPropName: 'FUNC_CLS', idPropName: 'MSLINK', outFields: ['MSLINK', 'FUNC_CLS'],
  1181. maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: ['01', '11'], Ew: ['12'], MH: ['02', '14'], mH: ['06', '16'], PS: ['07', '08', '17'], St: ['09', '19'] }
  1182. }
  1183. ],
  1184. isPermitted: function () { return _r >= 4; },
  1185. information: { Source: 'PennDOT', Permission: 'Visible to R4+', Description: 'Raw unmodified FC data.' },
  1186. getWhereClause: function (context) {
  1187. return (context.mapContext.zoom < 4) ? context.layer.fcPropName + " NOT IN ('09','19')" : null;
  1188. },
  1189. getFeatureRoadType: function (feature, layer) {
  1190. if (layer.getFeatureRoadType) {
  1191. return layer.getFeatureRoadType(feature);
  1192. } else {
  1193. var fc = feature.attributes[layer.fcPropName];
  1194. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1195. }
  1196. }
  1197. },
  1198. RI: {
  1199. baseUrl: 'https://services2.arcgis.com/S8zZg9pg23JUEexQ/arcgis/rest/services/RIDOT_Roads_2016/FeatureServer/',
  1200. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1201. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [[], [], [], [], [], [], [], [], [], [], []] },
  1202. fcMapLayers: [
  1203. {
  1204. layerID: 0, fcPropName: 'F_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_SYSTEM', 'ROADTYPE', 'RTNO'],
  1205. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7, 0] }, maxRecordCount: 1000, supportsPagination: false
  1206. }
  1207. ],
  1208. isPermitted: function () { return _r >= 3; },
  1209. information: { Source: 'RIDOT', Permission: 'Visible to R3+' },
  1210. getWhereClause: function (context) {
  1211. return (context.mapContext.zoom < 4) ? context.layer.fcPropName + " NOT IN (7,0)" : null;
  1212. },
  1213. getFeatureRoadType: function (feature, layer) {
  1214. var fc = parseInt(feature.attributes[layer.fcPropName]);
  1215. var type = feature.attributes.ROADTYPE;
  1216. var rtnum = feature.attributes.RTNO;
  1217. if (fc === 2 && ['10', '24', '37', '78', '99', '138', '403'].includes(rtnum)) { fc = 1; } //isFw
  1218. else if ((fc > 3 && type === 'US') || rtnum === '1') { fc = 3; } //isUS
  1219. else if (fc > 4 && rtnum.trim() !== '') { fc = 4; } //isState
  1220. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1221. }
  1222. },
  1223. SC: {
  1224. baseUrl: 'https://services1.arcgis.com/VaY7cY9pvUYUP1Lf/arcgis/rest/services/Functional_Class/FeatureServer/',
  1225. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1226. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1227. fcMapLayers: [
  1228. {
  1229. layerID: 0, fcPropName: 'FC_GIS', idPropName: 'FID', outFields: ['FID', 'FC_GIS', 'ROUTE_LRS'],
  1230. maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1231. }
  1232. ],
  1233. isPermitted: function () { return _r >= 4; },
  1234. information: { Source: 'SCDOT', Permission: 'Visible to R4+' },
  1235. getWhereClause: function (context) {
  1236. return null;
  1237. },
  1238. getFeatureRoadType: function (feature, layer) {
  1239. var roadID = feature.attributes.ROUTE_LRS;
  1240. var roadType = parseInt(roadID.slice(3, 4));
  1241. var isFw = roadType === 1;
  1242. var isUS = roadType === 2;
  1243. var isState = roadType === 4;
  1244. var isBiz = parseInt(roadID.slice(-2, -1)) === 7;
  1245. var fc = 7;
  1246. switch (feature.attributes[layer.fcPropName]) {
  1247. case 'INT': fc = 1; break;
  1248. case 'EXP': fc = 2; break;
  1249. case 'PRA': fc = 3; break;
  1250. case 'MIA': fc = 4; break;
  1251. case 'MAC':
  1252. case 'MIC': fc = 5; break;
  1253. }
  1254. if (fc > 1 && isFw) {
  1255. fc = 1;
  1256. } else if (fc > 3 && isUS) {
  1257. fc = isBiz ? 4 : 3;
  1258. } else if (fc > 4 && isState) {
  1259. fc = (isBiz ? 5 : 4);
  1260. }
  1261. if (layer.getFeatureRoadType) {
  1262. return layer.getFeatureRoadType(feature);
  1263. } else {
  1264. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1265. }
  1266. }
  1267. },
  1268. SD: {
  1269. baseUrl: 'https://arcgis.sd.gov/arcgis/rest/services/DOT/LocalRoads/MapServer/',
  1270. defaultColors: { Fw: '#ff00c5', Ew: '#149ece', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee', PSGr: '#cc6533', StGr: '#e99cb6' },
  1271. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1272. fcMapLayers: [{
  1273. layerID: 1, fcPropName: 'FUNC_CLASS', idPropName: 'OBJECTID', maxRecordCount: 1000, supportsPagination: false,
  1274. outFields: ['OBJECTID', 'FUNC_CLASS', 'SURFACE_TYPE', 'ROADNAME'],
  1275. roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 8, 17], St: [9, 19] }
  1276. }],
  1277. information: { Source: 'SDDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Additional colors denote unpaved PS and LS segements.' },
  1278. getWhereClause: function (context) {
  1279. if (context.mapContext.zoom < 4) {
  1280. return context.layer.fcPropName + " NOT IN (9,19)";
  1281. } else {
  1282. return null;
  1283. }
  1284. },
  1285. getFeatureRoadType: function (feature, layer) {
  1286. var attr = feature.attributes;
  1287. var fc = parseInt(attr[layer.fcPropName]) % 10;
  1288. var isFw = attr.ACCESS_CONTROL === 1;
  1289. var isUS = RegExp('^US HWY ', 'i').test(attr.ROADNAME);
  1290. var isState = RegExp('^SD HWY ', 'i').test(attr.ROADNAME);
  1291. var isBiz = RegExp('^(US|SD) HWY .* (E|W)?(B|L)$', 'i').test(attr.ROADNAME);
  1292. var isPaved = parseInt(attr.SURFACE_TYPE) > 5;
  1293. if (isFw) {
  1294. fc = 1;
  1295. } else if (fc > 4 && isUS) {
  1296. fc = (isBiz ? 6 : 4);
  1297. } else if (fc > 6 && isState) {
  1298. fc = (isBiz ? 7 : 6);
  1299. }
  1300. if (fc > 6 && !isPaved) {
  1301. return fc < 9 ? 'PSGr' : 'StGr';
  1302. } else {
  1303. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1304. }
  1305. }
  1306. },
  1307. TN: {
  1308. baseUrl: 'https://',
  1309. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', PS2: '#cfae0e', St: '#eeeeee' },
  1310. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  1311. fcMapLayers: [
  1312. {
  1313. layerPath: 'testuasiportal.shelbycountytn.gov/arcgis/rest/services/MPO/Webmap_2015_04_20_TMPO/MapServer/', maxRecordCount: 1000, supportsPagination: false,
  1314. layerID: 17, fcPropName: 'FuncClass', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FuncClass'],
  1315. roadTypeMap: { Fw: [1, 11], Ew: [2, 12], MH: [4, 14], mH: [6, 16], PS: [7, 17], PS2: [8, 18], St: [9, 19] }
  1316. },
  1317. {
  1318. layerPath: 'services3.arcgis.com/pXGyp7DHTIE4RXOJ/ArcGIS/rest/services/Functional_Classification/FeatureServer/', maxRecordCount: 1000, supportsPagination: false,
  1319. layerID: 0, fcPropName: 'FC_MPO', idPropName: 'FID', outFields: ['FID', 'FC_MPO'],
  1320. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }
  1321. }
  1322. ],
  1323. information: {
  1324. Source: 'Shelby County, Nashville Area MPO', Permission: 'Visible to R4+ or R3-AM',
  1325. Description: 'Raw unmodified FC data for the Memphis and Nashville regions only.'
  1326. },
  1327. getWhereClause: function (context) {
  1328. if (context.mapContext.zoom < 4) {
  1329. return context.layer.fcPropName + ' NOT IN (0,7,9,19)';
  1330. } else {
  1331. return context.layer.fcPropName + ' <> 0';
  1332. }
  1333. },
  1334. getFeatureRoadType: function (feature, layer) {
  1335. if (layer.getFeatureRoadType) {
  1336. return layer.getFeatureRoadType(feature);
  1337. } else {
  1338. return _stateSettings.global.getFeatureRoadType(feature, layer);
  1339. }
  1340. }
  1341. },
  1342. TX: {
  1343. baseUrl: 'https://services.arcgis.com/KTcxiTD9dsQw4r7Z/ArcGIS/rest/services/TxDOT_Functional_Classification/FeatureServer/',
  1344. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1345. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1] },
  1346. fcMapLayers: [
  1347. { layerID: 0, fcPropName: 'F_SYSTEM', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'F_SYSTEM', 'RTE_PRFX'], maxRecordCount: 1000, supportsPagination: false, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1348. ],
  1349. isPermitted: function () { return _r >= 2; },
  1350. information: { Source: 'TxDOT', Permission: 'Visible to R2+' },
  1351. getWhereClause: function (context) {
  1352. var where = " F_SYSTEM IS NOT NULL AND RTE_PRFX IS NOT NULL";
  1353. if (context.mapContext.zoom < 4) {
  1354. where += ' AND ' + context.layer.fcPropName + " <> 7";
  1355. }
  1356. return where;
  1357. },
  1358. getFeatureRoadType: function (feature, layer) {
  1359. // On-System:
  1360. // IH=Interstate BF=Business FM
  1361. // US=US Highway FM=Farm to Mkt
  1362. // UA=US Alt. RM=Ranch to Mkt
  1363. // UP=US Spur RR=Ranch Road
  1364. // SH=State Highway PR=Park Road
  1365. // SA=State Alt. RE=Rec Road
  1366. // SL=State Loop RP=Rec Rd Spur
  1367. // SS=State Spur FS=FM Spur
  1368. // BI=Business IH RS=RM Spur
  1369. // BU=Business US RU=RR Spur
  1370. // BS=Business State PA=Principal Arterial
  1371. // Off-System:
  1372. // TL=Off-System Tollroad CR=County Road
  1373. // FC=Func. Classified St. LS=Local Street
  1374. if (layer.getFeatureRoadType) {
  1375. return layer.getFeatureRoadType(feature);
  1376. } else {
  1377. var fc = feature.attributes[layer.fcPropName];
  1378. var type = feature.attributes.RTE_PRFX.substring(0, 2).toUpperCase();
  1379. if (type === 'IH' && fc > 1) {
  1380. fc = 1;
  1381. } else if ((type === 'US' || type === 'BI' || type === 'UA') && fc > 3) {
  1382. fc = 3;
  1383. } else if ((type === 'UP' || type === 'BU' || type === 'SH' || type === 'SA') && fc > 4) {
  1384. fc = 4;
  1385. } else if ((type === 'SL' || type === 'SS' || type === 'BS') && fc > 6) {
  1386. fc = 6;
  1387. }
  1388. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1389. }
  1390. }
  1391. },
  1392. UT: {
  1393. baseUrl: 'https://maps.udot.utah.gov/arcgis/rest/services/Functional_Class/MapServer/',
  1394. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1395. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1396. fcMapLayers: [
  1397. {
  1398. layerID: 0, fcPropName: 'FC_CODE', idPropName: 'OBJECTID', outFields: ['*'/*'OBJECTID','FC_CODE'*/], roadTypeMap: { Fw: [1], Ew: [2, 20], MH: [3, 30], mH: [4, 40], PS: [5, 50, 6, 60], St: [7, 77] },
  1399. maxRecordCount: 1000, supportsPagination: false
  1400. }
  1401. ],
  1402. information: { Source: 'TxDOT', Permission: 'Visible to R4+ or R3-AM' },
  1403. getWhereClause: function (context) {
  1404. var clause = context.layer.fcPropName + '<=7';
  1405. if (context.mapContext.zoom < 4) {
  1406. clause += ' OR ' + context.layer.fcPropName + '<7';
  1407. }
  1408. return clause;
  1409. },
  1410. getFeatureRoadType: function (feature, layer) {
  1411. var routeId = feature.attributes.ROUTE_ID;
  1412. var fc = feature.attributes.FC_CODE;
  1413. if ([6, 40, 50, 89, 91, 163, 189, 191, 491].indexOf(routeId) > -1 && fc > 3) {
  1414. // US highway
  1415. fc = 3;
  1416. } else if (routeId <= 491 && fc > 4) {
  1417. // State highway
  1418. fc = 4;
  1419. }
  1420. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1421. }
  1422. },
  1423. VT: {
  1424. baseUrl: 'https://maps.vtrans.vermont.gov/arcgis/rest/services/Master/General/FeatureServer/',
  1425. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1426. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1427. fcMapLayers: [
  1428. {
  1429. layerID: 39, fcPropName: 'FUNCL', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCL', 'HWYSIGN'],
  1430. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1431. }
  1432. ],
  1433. information: { Source: 'TxDOT', Permission: 'Visible to R4+ or R3-AM' },
  1434. getWhereClause: function (context) {
  1435. if (context.mapContext.zoom < 4) {
  1436. return context.layer.fcPropName + "<>7 AND " + context.layer.fcPropName + "<>0";
  1437. } else {
  1438. return null;
  1439. }
  1440. },
  1441. getFeatureRoadType: function (feature, layer) {
  1442. var roadID = feature.attributes.HWYSIGN;
  1443. var fc = feature.attributes[layer.fcPropName];
  1444. if (!(fc > 0)) { fc = 7; }
  1445. var isUS = RegExp(/^U/).test(roadID);
  1446. var isState = RegExp(/^V/).test(roadID);
  1447. var isUSBiz = RegExp(/^B/).test(roadID);
  1448. if (fc > 3 && isUS) {
  1449. fc = 3;
  1450. } else if (fc > 4 && (isUSBiz || isState)) {
  1451. fc = 4;
  1452. }
  1453. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1454. }
  1455. },
  1456. VA: {
  1457. baseUrl: 'https://services.arcgis.com/p5v98VHDX9Atv3l7/arcgis/rest/services/FC_2014_FHWA_Submittal1/FeatureServer/',
  1458. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1459. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1460. fcMapLayers: [
  1461. { layerID: 0, fcPropName: 'FUNCTIONAL_CLASS_ID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FUNCTIONAL_CLASS_ID', 'RTE_NM'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } },
  1462. { layerID: 1, fcPropName: 'STATE_FUNCT_CLASS_ID', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'STATE_FUNCT_CLASS_ID', 'RTE_NM', 'ROUTE_NO'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } },
  1463. { layerID: 3, fcPropName: 'TMPD_FC', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'TMPD_FC', 'RTE_NM'], maxRecordCount: 2000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1464. ],
  1465. information: { Source: 'VDOT', Permission: 'Visible to R4+ or R3-AM' },
  1466. srExceptions: [217, 302, 303, 305, 308, 310, 313, 314, 315, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 339, 341, 342, 343, 344, 345, 346, 347, 348, 350, 353, 355, 357, 358, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 396, 397, 398, 399, 785, 895],
  1467. getWhereClause: function (context) {
  1468. if (context.mapContext.zoom < 4) {
  1469. return context.layer.fcPropName + '<>7';
  1470. } else {
  1471. //NOTE: As of 9/14/2016 there does not appear to be any US/SR/VA labeled routes with FC = 7.
  1472. return null;
  1473. }
  1474. },
  1475. getFeatureRoadType: function (feature, layer) {
  1476. if (layer.getFeatureRoadType) {
  1477. return layer.getFeatureRoadType(feature);
  1478. } else {
  1479. var fc = parseInt(feature.attributes[layer.fcPropName]);
  1480. var rtName = feature.attributes.RTE_NM;
  1481. var match = /^R-VA\s*(US|VA|SR)(\d{5})..(BUS)?/.exec(rtName);
  1482. var isBusiness = (match && (match !== null) && (match[3] === 'BUS'));
  1483. var isState = (match && (match !== null) && (match[1] === 'VA' || match[1] === 'SR'));
  1484. var rtNum = parseInt((layer.layerID === 1) ? feature.attributes.ROUTE_NO : (match ? match[2] : 99999));
  1485. var rtPrefix = match && match[1];
  1486. if (fc > 3 && rtPrefix === 'US') {
  1487. fc = isBusiness ? 4 : 3;
  1488. } else if (isState && fc > 4 && this.srExceptions.indexOf(rtNum) === -1 && rtNum < 600) {
  1489. fc = isBusiness ? 5 : 4;
  1490. }
  1491. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1492. }
  1493. }
  1494. },
  1495. WA: {
  1496. baseUrl: 'https://data.wsdot.wa.gov/arcgis/rest/services/FunctionalClass/WSDOTFunctionalClassMap/MapServer/',
  1497. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1498. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1499. fcMapLayers: [
  1500. {
  1501. layerID: 2, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1502. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1503. },
  1504. {
  1505. layerID: 1, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1506. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1507. },
  1508. {
  1509. layerID: 4, fcPropName: 'FederalFunctionalClassCode', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'FederalFunctionalClassCode'],
  1510. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1511. }
  1512. ],
  1513. information: { Source: 'WSDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Raw unmodified FC data.' },
  1514. getWhereClause: function (context) {
  1515. if (context.mapContext.zoom < 4) {
  1516. return context.layer.fcPropName + " <> 7";
  1517. } else {
  1518. return null;
  1519. }
  1520. },
  1521. getFeatureRoadType: function (feature, layer) {
  1522. if (layer.getFeatureRoadType) {
  1523. return layer.getFeatureRoadType(feature);
  1524. } else {
  1525. return _stateSettings.global.getFeatureRoadType(feature, layer);
  1526. }
  1527. }
  1528. },
  1529. WV: {
  1530. baseUrl: 'https://gis.transportation.wv.gov/arcgis/rest/services/Routes/MapServer/',
  1531. defaultColors: { Fw: '#ff00c5', Ew: '#ff00c5', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1532. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1533. fcMapLayers: [
  1534. { layerID: 11, fcPropName: 'NAT_FUNCTIONAL_CLASS', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'NAT_FUNCTIONAL_CLASS', 'ROUTE_ID'], maxRecordCount: 1000, supportsPagination: true, roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] } }
  1535. ],
  1536. information: { Source: 'WV DOT', Permission: 'Visible to R4+ or R3-AM' },
  1537. getWhereClause: function (context) {
  1538. if (context.mapContext.zoom < 4) {
  1539. return context.layer.fcPropName + ' NOT IN (9,19)';
  1540. } else {
  1541. return null;
  1542. }
  1543. },
  1544. getFeatureRoadType: function (feature, layer) {
  1545. if (layer.getFeatureRoadType) {
  1546. return layer.getFeatureRoadType(feature);
  1547. } else {
  1548. var fcCode = feature.attributes[layer.fcPropName];
  1549. var fc = fcCode;
  1550. if (fcCode === 11) fc = 1;
  1551. else if (fcCode === 4 || fcCode === 12) fc = 2;
  1552. else if (fcCode === 2 || fcCode === 14) fc = 3;
  1553. else if (fcCode === 6 || fcCode === 16) fc = 4;
  1554. else if (fcCode === 7 || fcCode === 17 || fcCode === 8 || fcCode === 18) fc = 5;
  1555. else fc = 7;
  1556. var id = feature.attributes.ROUTE_ID;
  1557. var prefix = id.substr(2, 1);
  1558. var isInterstate = false;
  1559. var isUS = false;
  1560. var isState = false;
  1561. switch (prefix) {
  1562. case '1':
  1563. isInterstate = true;
  1564. break;
  1565. case '2':
  1566. isUS = true;
  1567. break;
  1568. case '3':
  1569. isState = true;
  1570. break;
  1571. }
  1572. if (fc > 1 && isInterstate) { fc = 1; }
  1573. else if (fc > 3 && isUS) { fc = 3; }
  1574. else if (fc > 4 && isState) { fc = 4; }
  1575. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1576. }
  1577. }
  1578. },
  1579. WY: {
  1580. baseUrl: 'https://apps.wyoroad.info/arcgis/rest/services/ITSM/LAYERS/MapServer/',
  1581. defaultColors: { Fw: '#ff00c5', Ew: '#4f33df', MH: '#149ece', mH: '#4ce600', PS: '#cfae0e', St: '#eeeeee' },
  1582. zoomSettings: { maxOffset: [30, 15, 8, 4, 2, 1, 1, 1, 1, 1], excludeRoadTypes: [['St'], ['St'], ['St'], ['St'], [], [], [], [], [], [], []] },
  1583. fcMapLayers: [
  1584. {
  1585. layerID: 21, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1586. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1587. },
  1588. {
  1589. layerID: 22, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1590. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1591. },
  1592. {
  1593. layerID: 23, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1594. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1595. },
  1596. {
  1597. layerID: 24, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1598. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1599. },
  1600. {
  1601. layerID: 25, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1602. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1603. },
  1604. {
  1605. layerID: 26, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1606. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1607. },
  1608. {
  1609. layerID: 27, fcPropName: 'CLASSIFICATION', idPropName: 'OBJECTID', outFields: ['OBJECTID', 'CLASSIFICATION', 'COMMON_ROUTE_NAME'],
  1610. roadTypeMap: { Fw: [1], Ew: [2], MH: [3], mH: [4], PS: [5, 6], St: [7] }, maxRecordCount: 1000, supportsPagination: false
  1611. }
  1612. ],
  1613. information: { Source: 'WYDOT', Permission: 'Visible to R4+ or R3-AM', Description: 'Minimum suggested FC.' },
  1614. getWhereClause: function (context) {
  1615. if (context.mapContext.zoom < 4) {
  1616. return context.layer.fcPropName + " <> 'Local'";
  1617. } else {
  1618. return null;
  1619. }
  1620. },
  1621. getFeatureRoadType: function (feature, layer) {
  1622. var attr = feature.attributes;
  1623. var fc = attr[layer.fcPropName];
  1624. var route = attr.COMMON_ROUTE_NAME;
  1625. switch (fc) {
  1626. case 'Interstate': fc = 1; break;
  1627. case 'Expressway': fc = 2; break;
  1628. case 'Principal Arterial': fc = 3; break;
  1629. case 'Minor Arterial': fc = 4; break;
  1630. case 'Major Collector': fc = 5; break
  1631. case 'Minor Collector': fc = 6; break;
  1632. default: fc = 7;
  1633. }
  1634. var isIntBiz = /I (25|80) BUS/.test(route);
  1635. var isUS = /US \d+/.test(route);
  1636. var isUSBiz = /US \d+ BUS/.test(route);
  1637. var isState = /WY \d+/.test(route);
  1638. var isStateBiz = /WY \d+ BUS/.test(route);
  1639. if (fc > 3 && (isUS || isIntBiz)) {
  1640. fc = isUSBiz ? 4 : 3;
  1641. } else if (fc > 4 && isState) {
  1642. fc = isStateBiz ? 5 : 4;
  1643. }
  1644. return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  1645. }
  1646. }
  1647. };
  1648.  
  1649. function log(message, level) {
  1650. if (message && (!level || (level <= _debugLevel))) {
  1651. console.log('FC Layer: ', message);
  1652. }
  1653. }
  1654.  
  1655. function dynamicSort(property) {
  1656. var sortOrder = 1;
  1657. if (property[0] === "-") {
  1658. sortOrder = -1;
  1659. property = property.substr(1);
  1660. }
  1661. return function (a, b) {
  1662. var props = property.split('.');
  1663. props.forEach(function (prop) {
  1664. a = a[prop];
  1665. b = b[prop];
  1666. });
  1667. var result = (a < b) ? -1 : (a > b) ? 1 : 0;
  1668. return result * sortOrder;
  1669. };
  1670. }
  1671.  
  1672. function dynamicSortMultiple() {
  1673. /*
  1674. * save the arguments object as it will be overwritten
  1675. * note that arguments object is an array-like object
  1676. * consisting of the names of the properties to sort by
  1677. */
  1678. var props = arguments;
  1679. if (arguments[0] && Array.isArray(arguments[0])) {
  1680. props = arguments[0];
  1681. }
  1682. return function (obj1, obj2) {
  1683. var i = 0, result = 0, numberOfProperties = props.length;
  1684. /* try getting a different result from 0 (equal)
  1685. * as long as we have extra properties to compare
  1686. */
  1687. while (result === 0 && i < numberOfProperties) {
  1688. result = dynamicSort(props[i])(obj1, obj2);
  1689. i++;
  1690. }
  1691. return result;
  1692. };
  1693. }
  1694.  
  1695. function generateUUID() {
  1696. var d = new Date().getTime();
  1697. var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
  1698. var r = (d + Math.random() * 16) % 16 | 0;
  1699. d = Math.floor(d / 16);
  1700. return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
  1701. });
  1702. return uuid;
  1703. }
  1704.  
  1705. function loadSettingsFromStorage() {
  1706. var loadedSettings = $.parseJSON(localStorage.getItem(_settingsStoreName));
  1707. var defaultSettings = {
  1708. lastVersion: null,
  1709. layerVisible: true,
  1710. activeStateAbbr: 'ALL',
  1711. hideStreet: false
  1712. };
  1713. _settings = loadedSettings ? loadedSettings : defaultSettings;
  1714. for (var prop in defaultSettings) {
  1715. if (!_settings.hasOwnProperty(prop)) {
  1716. _settings[prop] = defaultSettings[prop];
  1717. }
  1718. }
  1719. }
  1720.  
  1721. function saveSettingsToStorage() {
  1722. if (localStorage) {
  1723. _settings.lastVersion = _scriptVersion;
  1724. _settings.layerVisible = _mapLayer.visibility;
  1725. localStorage.setItem(_settingsStoreName, JSON.stringify(_settings));
  1726. log('Settings saved', 1);
  1727. }
  1728. }
  1729.  
  1730. function getLineWidth() {
  1731. return 12 * Math.pow(1.15, (W.map.getZoom() - 1));
  1732. }
  1733.  
  1734. function sortArray(array) {
  1735. array.sort(function (a, b) { if (a < b) return -1; if (a > b) return 1; else return 0; });
  1736. }
  1737.  
  1738. function getVisibleStateAbbrs() {
  1739. var visibleStates = [];
  1740. W.model.states.getObjectArray().forEach(function (state) {
  1741. var stateAbbr = _statesHash[state.name];
  1742. var activeStateAbbr = _settings.activeStateAbbr;
  1743. if (_stateSettings[stateAbbr] && _stateSettings.global.isPermitted(stateAbbr) && (!activeStateAbbr || activeStateAbbr === 'ALL' || activeStateAbbr === stateAbbr)) {
  1744. visibleStates.push(stateAbbr);
  1745. }
  1746. });
  1747. return visibleStates;
  1748. }
  1749.  
  1750. function getAsync(url, context) {
  1751. return new Promise(function (resolve, reject) {
  1752. GM_xmlhttpRequest({
  1753. context: context, method: "GET", url: url,
  1754. onload: function (res) {
  1755. if (res.status.toString() === '200') {
  1756. resolve({ responseText: res.responseText, context: context });
  1757. } else {
  1758. reject({ responseText: res.responseText, context: context });
  1759. }
  1760. },
  1761. onerror: function () {
  1762. reject(Error("Network Error"));
  1763. }
  1764. });
  1765. });
  1766. }
  1767. function wait(ms) {
  1768. var start = new Date().getTime();
  1769. var end = start;
  1770. while (end < start + ms) {
  1771. end = new Date().getTime();
  1772. }
  1773. }
  1774. function getUrl(context, queryType, queryParams) {
  1775. var extent = context.mapContext.extent,
  1776. zoom = context.mapContext.zoom,
  1777. layer = context.layer,
  1778. state = context.state;
  1779.  
  1780. var whereParts = [];
  1781. var geometry = { xmin: extent.left, ymin: extent.bottom, xmax: extent.right, ymax: extent.top, spatialReference: { wkid: 102100, latestWkid: 3857 } };
  1782. var geometryStr = JSON.stringify(geometry);
  1783. var stateWhereClause = state.getWhereClause(context);
  1784. var layerPath = layer.layerPath || '';
  1785. var url = state.baseUrl + layerPath + layer.layerID + '/query?geometry=' + encodeURIComponent(geometryStr);
  1786.  
  1787. if (queryType === 'countOnly') {
  1788. url += '&returnCountOnly=true';
  1789. } else if (queryType === 'idsOnly') {
  1790. url += '&returnIdsOnly=true';
  1791. } else if (queryType === 'paged') {
  1792. // TODO
  1793. } else {
  1794. url += '&returnGeometry=true&maxAllowableOffset=' + state.zoomSettings.maxOffset[zoom];
  1795. url += '&outFields=' + encodeURIComponent(layer.outFields.join(','));
  1796. if (queryType === 'idRange') {
  1797. var idPropName = context.layer.idPropName;
  1798. whereParts.push('(' + queryParams.idFieldName + '>=' + queryParams.range[0] + ' AND ' + queryParams.idFieldName + '<=' + queryParams.range[1] + ')');
  1799. }
  1800. }
  1801. if (stateWhereClause) whereParts.push(stateWhereClause);
  1802. if (whereParts.length > 0) url += '&where=' + encodeURIComponent(whereParts.join(' AND '));
  1803. url += '&spatialRel=esriSpatialRelIntersects&geometryType=esriGeometryEnvelope&inSR=102100&outSR=3857&f=json';
  1804. //wait(500); // I don't know why this was in the code. Leaving it commented here just in case it was a hack to solve some issue.
  1805. return url;
  1806. }
  1807.  
  1808. function convertFcToRoadTypeVectors(feature, state, stateAbbr, layer, zoom) {
  1809. var roadType = state.getFeatureRoadType(feature, layer);
  1810. log(feature, 3);
  1811. var zIndex = _stateSettings.global.roadTypes.indexOf(roadType) * 100;
  1812. var vectors = [];
  1813. var lineFeatures = [];
  1814. var attr = {
  1815. //fcFeatureUniqueId: stateAbbr + '-' + layer.layerID + '-' + feature.attributes[layer.idPropName],
  1816. //fcFeatureId: feature.attributes[layer.idPropName],
  1817. state: stateAbbr,
  1818. layerID: layer.layerID,
  1819. roadType: roadType,
  1820. dotAttributes: $.extend({}, feature.attributes),
  1821. color: state.defaultColors[roadType],
  1822. strokeWidth: getLineWidth,
  1823. zIndex: zIndex
  1824. };
  1825.  
  1826. feature.geometry.paths.forEach(function (path) {
  1827. var pointList = [];
  1828. var newPoint = null;
  1829. var lastPoint = null;
  1830. path.forEach(function (point) {
  1831. pointList.push(new OL.Geometry.Point(point[0], point[1]));
  1832. });
  1833. var vectorFeature = new OL.Feature.Vector(new OL.Geometry.LineString(pointList), attr);
  1834. vectors.push(vectorFeature);
  1835. });
  1836.  
  1837. return vectors;
  1838. }
  1839.  
  1840. function fetchLayerFC(context) {
  1841. var url = getUrl(context, 'idsOnly');
  1842. log(url, 2);
  1843. if (!context.parentContext.cancel) {
  1844. return getAsync(url, context).bind(context).then(function (res) {
  1845. var ids = $.parseJSON(res.responseText);
  1846. if (!ids.objectIds) ids.objectIds = [];
  1847. sortArray(ids.objectIds);
  1848. log(ids, 2);
  1849. return ids;
  1850. }).then(function (res) {
  1851. var context = this;
  1852. var idRanges = [];
  1853. if (res.objectIds) {
  1854. var len = res.objectIds ? res.objectIds.length : 0;
  1855. var currentIndex = 0;
  1856. var offset = Math.min(this.layer.maxRecordCount, 1000);
  1857. while (currentIndex < len) {
  1858. var nextIndex = currentIndex + offset;
  1859. if (nextIndex >= len) nextIndex = len - 1;
  1860. idRanges.push({ range: [res.objectIds[currentIndex], res.objectIds[nextIndex]], idFieldName: res.objectIdFieldName });
  1861. currentIndex = nextIndex + 1;
  1862. }
  1863. log(context.layer.layerID, 2);
  1864. log(idRanges, 2);
  1865. }
  1866. return idRanges;
  1867. }).map(function (idRange) {
  1868. var context = this;
  1869. if (!context.parentContext.cancel) {
  1870. var url = getUrl(this, 'idRange', idRange);
  1871. log(url, 2);
  1872. return getAsync(url, context).then(function (res) {
  1873. var context = res.context;
  1874. if (!context.parentContext.cancel) {
  1875. var features = $.parseJSON(res.responseText).features;
  1876. // if (context.parentContext.callCount === 0 ) {
  1877. // _mapLayer.removeAllFeatures();
  1878. // }
  1879. context.parentContext.callCount++;
  1880. log('Feature Count=' + (features ? features.length : 0), 2);
  1881. features = features ? features : [];
  1882. var vectors = [];
  1883. features.forEach(function (feature) {
  1884. if (!res.context.parentContext.cancel) {
  1885. var vector = convertFcToRoadTypeVectors(feature, context.state, context.stateAbbr, context.layer, context.mapContext.zoom);
  1886. //var fcFeatureUniqueId = vector[0].attributes.fcFeatureUniqueId;
  1887. //context.parentContext.addedFcFeatureUniqueIds.push(fcFeatureUniqueId);
  1888. if (/*!context.parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] &&*/ !(vector[0].attributes.roadType === 'St' && _settings.hideStreet)) {
  1889. vectors.push(vector);
  1890. }
  1891. }
  1892. });
  1893. return vectors;
  1894. }
  1895. });
  1896. } else {
  1897. log('Async call cancelled', 1);
  1898. }
  1899. });
  1900. }
  1901. }
  1902.  
  1903. function fetchStateFC(context) {
  1904. var state = _stateSettings[context.stateAbbr];
  1905. var contexts = [];
  1906. state.fcMapLayers.forEach(function (layer) {
  1907. contexts.push({ parentContext: context.parentContext, layer: layer, state: state, stateAbbr: context.stateAbbr, mapContext: context.mapContext });
  1908. });
  1909. return Promise.map(contexts, function (context) {
  1910. return fetchLayerFC(context);
  1911. });
  1912. }
  1913.  
  1914. var _lastPromise = null;
  1915. var _lastContext = null;
  1916. var _fcCallCount = 0;
  1917. function fetchAllFC() {
  1918. if (!_mapLayer.visibility) return;
  1919.  
  1920. if (_lastPromise) { _lastPromise.cancel(); }
  1921. $('#fc-loading-indicator').text('Loading FC...');
  1922.  
  1923. var mapContext = { zoom: W.map.getZoom(), extent: W.map.getExtent() };
  1924. var contexts = [];
  1925. var parentContext = { callCount: 0,/*existingFcFeatureUniqueIds:{}, addedFcFeatureUniqueIds:[],*/ startTime: Date.now() };
  1926. // _mapLayer.features.forEach(function(vectorFeature) {
  1927. // var fcFeatureUniqueId = vectorFeature.attributes.fcFeatureUniqueId;
  1928. // var existingFcFeatureUniqueIdArray = parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId];
  1929. // if (!existingFcFeatureUniqueIdArray) {
  1930. // existingFcFeatureUniqueIdArray = [];
  1931. // parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] = existingFcFeatureUniqueIdArray;
  1932. // }
  1933. // existingFcFeatureUniqueIdArray.push(vectorFeature);
  1934. // });
  1935. if (_lastContext) _lastContext.cancel = true;
  1936. _lastContext = parentContext;
  1937. getVisibleStateAbbrs().forEach(function (stateAbbr) {
  1938. contexts.push({ parentContext: parentContext, stateAbbr: stateAbbr, mapContext: mapContext });
  1939. });
  1940. var map = Promise.map(contexts, function (context) {
  1941. return fetchStateFC(context);
  1942. }).bind(parentContext).then(function (statesVectorArrays) {
  1943. if (!this.cancel) {
  1944. _mapLayer.removeAllFeatures();
  1945. statesVectorArrays.forEach(function (vectorsArray) {
  1946. vectorsArray.forEach(function (vectors) {
  1947. vectors.forEach(function (vector) {
  1948. vector.forEach(function (vectorFeature) {
  1949. _mapLayer.addFeatures(vectorFeature);
  1950. });
  1951. });
  1952. });
  1953. });
  1954. //buildTable();
  1955. // for(var fcFeatureUniqueId in this.existingFcFeatureUniqueIds) {
  1956. // if(this.addedFcFeatureUniqueIds.indexOf(fcFeatureUniqueId) === -1) {
  1957. // if (!this.cancel) _mapLayer.removeFeatures(this.existingFcFeatureUniqueIds[fcFeatureUniqueId]);
  1958. // }
  1959. // }
  1960. log('TOTAL RETRIEVAL TIME = ' + (Date.now() - parentContext.startTime), 1);
  1961. log(statesVectorArrays, 1);
  1962. }
  1963. return statesVectorArrays;
  1964. }).catch(function (e) {
  1965. $('#fc-loading-indicator').text('FC Error! (check console for details)');
  1966. log(e, 0);
  1967. }).finally(function () {
  1968. _fcCallCount -= 1;
  1969. if (_fcCallCount === 0) {
  1970. $('#fc-loading-indicator').text('');
  1971. }
  1972. });
  1973.  
  1974. _fcCallCount += 1;
  1975. _lastPromise = map;
  1976. }
  1977.  
  1978. function onLayerCheckboxChanged(checked) {
  1979. _mapLayer.setVisibility(checked);
  1980. }
  1981.  
  1982. function onLayerVisibilityChanged(evt) {
  1983. _settings.layerVisible = _mapLayer.visibility;
  1984. saveSettingsToStorage();
  1985. if (_mapLayer.visibility) {
  1986. fetchAllFC();
  1987. }
  1988. }
  1989.  
  1990. function onModeChanged(model, modeId, context) {
  1991. if (!modeId || modeId === 1) {
  1992. initUserPanel();
  1993. }
  1994. }
  1995.  
  1996. function showScriptInfoAlert() {
  1997. /* Check version and alert on update */
  1998. if (_alertUpdate && _scriptVersion !== _settings.lastVersion) {
  1999. alert(_scriptVersionChanges);
  2000. }
  2001. }
  2002.  
  2003. function initLayer() {
  2004. var _drawingContext = {
  2005. getZIndex: function (feature) {
  2006. return feature.attributes.zIndex;
  2007. },
  2008. getStrokeWidth: function () { return getLineWidth(); }
  2009. };
  2010. var defaultStyle = new OL.Style({
  2011. strokeColor: '${color}', //'#00aaff',
  2012. strokeDashstyle: "solid",
  2013. strokeOpacity: 1.0,
  2014. strokeWidth: '${strokeWidth}',
  2015. graphicZIndex: '${zIndex}'
  2016. });
  2017.  
  2018. var selectStyle = new OL.Style({
  2019. //strokeOpacity: 1.0,
  2020. strokeColor: '#000000'
  2021. });
  2022.  
  2023. _mapLayer = new OL.Layer.Vector("FC Layer", {
  2024. uniqueName: "__FCLayer",
  2025. displayInLayerSwitcher: false,
  2026. rendererOptions: { zIndexing: true },
  2027. styleMap: new OL.StyleMap({
  2028. 'default': defaultStyle,
  2029. 'select': selectStyle
  2030. })
  2031. });
  2032.  
  2033. _mapLayer.setOpacity(0.5);
  2034.  
  2035. I18n.translations[I18n.locale].layers.name.__FCLayer = "FC Layer";
  2036.  
  2037. _mapLayer.displayInLayerSwitcher = true;
  2038. _mapLayer.events.register('visibilitychanged', null, onLayerVisibilityChanged);
  2039. _mapLayer.setVisibility(_settings.layerVisible);
  2040.  
  2041. W.map.addLayer(_mapLayer);
  2042. _mapLayer.setZIndex(_mapLayerZIndex);
  2043. WazeWrap.Interface.AddLayerCheckbox('Display', 'FC Layer', _settings.layerVisible, onLayerCheckboxChanged);
  2044. // Hack to fix layer zIndex. Some other code is changing it sometimes but I have not been able to figure out why.
  2045. // It may be that the FC layer is added to the map before some Waze code loads the base layers and forces other layers higher. (?)
  2046.  
  2047. var checkLayerZIndex = function () {
  2048. if (_mapLayer.getZIndex() != _mapLayerZIndex) {
  2049. log("ADJUSTED FC LAYER Z-INDEX " + _mapLayerZIndex + ', ' + _mapLayer.getZIndex(), 1);
  2050. _mapLayer.setZIndex(_mapLayerZIndex);
  2051. }
  2052. };
  2053.  
  2054. setInterval(function () { checkLayerZIndex(); }, 200);
  2055.  
  2056. W.map.events.register("moveend", W.map, function (e) {
  2057. fetchAllFC();
  2058. return true;
  2059. }, true);
  2060. }
  2061.  
  2062. function initUserPanel() {
  2063. var $tab = $('<li>').append($('<a>', { 'data-toggle': 'tab', href: '#sidepanel-fc-layer' }).text('FC'));
  2064. var $panel = $('<div>', { class: 'tab-pane', id: 'sidepanel-fc-layer' });
  2065. var $stateSelect = $('<select>', { id: 'fcl-state-select', class: 'form-control disabled', style: 'disabled' }).append($('<option>', { value: 'ALL' }).text('All'));
  2066. // $stateSelect.change(function(evt) {
  2067. // _settings.activeStateAbbr = evt.target.value;
  2068. // saveSettingsToStorage();
  2069. // _mapLayer.removeAllFeatures();
  2070. // fetchAllFC();
  2071. // });
  2072. for (var stateAbbr in _stateSettings) {
  2073. if (stateAbbr !== 'global') {
  2074. $stateSelect.append($('<option>', { value: stateAbbr }).text(reverseStatesHash(stateAbbr)));
  2075. }
  2076. }
  2077.  
  2078. var $hideStreet = $('<div>', { id: 'fcl-hide-street-container', class: 'controls-container' })
  2079. .append($('<input>', { type: 'checkbox', name: 'fcl-hide-street', id: 'fcl-hide-street' }).prop('checked', _settings.hideStreet).click(function () {
  2080. _settings.hideStreet = $(this).is(':checked');
  2081. saveSettingsToStorage();
  2082. _mapLayer.removeAllFeatures();
  2083. fetchAllFC();
  2084. }))
  2085. .append($('<label>', { for: 'fcl-hide-street' }).text('Hide local street highlights'));
  2086.  
  2087. $stateSelect.val(_settings.activeStateAbbr ? _settings.activeStateAbbr : 'ALL');
  2088.  
  2089. $panel.append(
  2090. $('<div>', { class: 'form-group' }).append(
  2091. $('<label>', { class: 'control-label' }).text('Select a state')
  2092. ).append(
  2093. $('<div>', { class: 'controls', id: 'fcl-state-select-container' }).append(
  2094. $('<div>').append($stateSelect)
  2095. )
  2096. ),
  2097. $hideStreet,
  2098. $('<div>', { id: 'fcl-table-container' })
  2099. );
  2100.  
  2101. $panel.append($('<div>', { id: 'fcl-state-info' }));
  2102.  
  2103. $panel.append(
  2104. $('<div>', { style: 'margin-top:10px;font-size:10px;color:#999999;' })
  2105. .append($('<div>').text('version ' + _scriptVersion))
  2106. .append(
  2107. $('<div>').append(
  2108. $('<a>', { href: '#' /*, target:'__blank'*/ }).text('Discussion Forum (currently n/a)')
  2109. )
  2110. )
  2111. );
  2112.  
  2113. $('#user-tabs > .nav-tabs').append($tab);
  2114. $('#user-info > .flex-parent > .tab-content').append($panel);
  2115. $('#fcl-state-select').change(function () {
  2116. _settings.activeStateAbbr = this.value;
  2117. saveSettingsToStorage();
  2118. loadStateFCInfo();
  2119. fetchAllFC();
  2120. });
  2121. loadStateFCInfo();
  2122. }
  2123.  
  2124. function loadStateFCInfo() {
  2125. $('#fcl-state-info').empty();
  2126. if (_stateSettings[_settings.activeStateAbbr]) {
  2127. var stateInfo = _stateSettings[_settings.activeStateAbbr].information;
  2128. var $panelStateInfo = $('<dl>');
  2129. for (var propertyName in stateInfo) {
  2130. $panelStateInfo.append($('<dt>', { style: 'margin-top:1em;color:#777777' }).text(propertyName))
  2131. .append($('<dd>').text(stateInfo[propertyName]))
  2132. }
  2133. $('#fcl-state-info').append($panelStateInfo);
  2134. }
  2135. }
  2136.  
  2137. function addLoadingIndicator() {
  2138. $('.loading-indicator').after($('<div class="loading-indicator" style="margin-right:10px" id="fc-loading-indicator">'));
  2139. }
  2140.  
  2141. function initGui() {
  2142. addLoadingIndicator();
  2143. initLayer();
  2144. initUserPanel();
  2145. showScriptInfoAlert();
  2146. }
  2147.  
  2148. function processText(text) {
  2149. return new Promise(function (resolve, reject) {
  2150. var newText = text.replace(/(e)/, 'E');
  2151. resolve(newText);
  2152. });
  2153. }
  2154.  
  2155. function init() {
  2156. if (_debugLevel > 0 && Promise.config) {
  2157. Promise.config({
  2158. warnings: true,
  2159. longStackTraces: true,
  2160. cancellation: true,
  2161. monitoring: false
  2162. });
  2163. } else {
  2164. Promise.config({
  2165. warnings: false,
  2166. longStackTraces: false,
  2167. cancellation: true,
  2168. monitoring: false
  2169. });
  2170. }
  2171.  
  2172. var u = W.loginManager.user;
  2173. _uid = u.id;
  2174. _r = u.rank + 1;
  2175. _isAM = u.isAreaManager;
  2176. loadSettingsFromStorage();
  2177. String.prototype.replaceAll = function (search, replacement) {
  2178. var target = this;
  2179. return target.replace(new RegExp(search, 'g'), replacement);
  2180. };
  2181. initGui();
  2182. W.app.modeController.model.bind('change:mode', onModeChanged);
  2183. W.prefs.on("change:isImperial", function () { initUserPanel(); loadSettingsFromStorage(); });
  2184. fetchAllFC();
  2185. log('Initialized.', 0);
  2186. }
  2187.  
  2188. function bootstrap() {
  2189. if (W && W.loginManager &&
  2190. W.loginManager.events &&
  2191. W.loginManager.events.register &&
  2192. W.model && W.model.states && W.model.states.getObjectArray().length &&
  2193. W.map && W.loginManager.user &&
  2194. WazeWrap.Ready) {
  2195. log('Initializing...', 0);
  2196.  
  2197. init();
  2198. } else {
  2199. log('Bootstrap failed. Trying again...', 0);
  2200. unsafeWindow.setTimeout(function () {
  2201. bootstrap();
  2202. }, 1000);
  2203. }
  2204. }
  2205.  
  2206. log('Bootstrap...', 0);
  2207. bootstrap();
  2208. })();