proj.js

  1. 'use strict';
  2. const proj4 = require('proj4');
  3. const terraformer = require('terraformer');
  4. const teraProj = require('terraformer-proj4js');
  6. /**
  7.  * Reproject a GeoJSON object in place.  This is a wrapper around terraformer-proj4js.
  8.  * @param {Object} geojson the GeoJSON to be reprojected, this will be modified in place
  9.  * @param {String|Number} outputSpatialReference the target spatial reference,
  10.  * 'EPSG:4326' is used by default; if a number is suppied it will be used as an EPSG code
  11.  * @param {String|Number} inputSpatialReference same rules as outputSpatialReference if suppied
  12.  * if missing it will attempt to find it encoded in the GeoJSON
  13.  */
  14. function projectGeojson(geojson, outputSpatialReference, inputSpatialReference) {
  15.     const converter = teraProj(terraformer, proj4);
  16.     converter(geojson, outputSpatialReference, inputSpatialReference);
  17. }
  19. /**
  20.  * Convert a projection to an string that is compatible with proj4.  If it is an ESRI SpatialReference or an integer it will be converted.
  21.  * @param {Object|Integer|String} proj an ESRI SpatialReference, integer or string.  Strings will be unchanged and unchecked,
  22.  * ints and SpatialReference objects will be converted.
  23.  * @return {String} A string in the form EPSG:####
  24.  * @private
  25.  */
  26. function normalizeProj(proj) {
  27.     if (typeof proj === 'object') {
  28.         if (proj.wkid) {
  29.             return 'EPSG:' + proj.wkid;
  30.         } else if (proj.wkt) {
  31.             return proj.wkt;
  32.         }
  33.     } else if (typeof proj === 'number') {
  34.         return 'EPSG:' + proj;
  35.     } else if (typeof proj === 'string') {
  36.         return proj;
  37.     }
  38.     throw new Error('Bad argument type, please provide a string, integer or SpatialReference object.');
  39. }
  41. /**
  42.  * Project a single point.
  43.  * @param {Object|Integer|String} srcProj the spatial reference of the point (as ESRI SpatialReference, integer WKID or an EPSG string)
  44.  * @param {Object|Integer|String} destProj the spatial reference of the result (as ESRI SpatialReference, integer WKID or an EPSG string)
  45.  * @param {Array|Object} point a 2d array or object with {x,y} props containing the coordinates to Reproject
  46.  * @return {Array|Object} a 2d array or object containing the projected point
  47.  */
  48. function localProjectPoint(srcProj, destProj, point) {
  49.     return proj4(normalizeProj(srcProj), normalizeProj(destProj), point);
  50. }
  52. /**
  53.  * Project a single point.
  54.  * @param {Object|Integer|String} destProj the spatial reference of the result (as ESRI SpatialReference, integer WKID or an EPSG string)
  55.  * @param {Object} geometry an object conforming to ESRI Geometry object standards containing the coordinates to Reproject
  56.  * @return {Object} an object conforming to ESRI Geomtery object standards containing the input geometry in the destination projection
  57.  */
  58. function localProjectGeometry(destProj, geometry) {
  59.     // FIXME we seem to be really dependant on wkid. ideally enhance to handle all SR types
  61.     // HACK >:'(
  62.     // terraformer has this undesired behavior where, if your input geometry is in WKID 102100, it will magically
  63.     // project all your co-ordinates to lat/long when converting between ESRI and GeoJSON formats.
  64.     // to stop it from ruining us, we temporarily set the spatial reference to nonsense so it will leave it alone
  65.     const realSR = geometry.spatialReference;
  66.     geometry.spatialReference = { wkid: 8888 }; // nonsense!
  67.     const grGeoJ = terraformer.ArcGIS.parse(geometry, { sr: 8888 });
  68.     geometry.spatialReference = realSR;
  70.     // project json
  71.     projectGeojson(grGeoJ, normalizeProj(destProj), normalizeProj(realSR));
  73.     // back to esri format
  74.     const grEsri = terraformer.ArcGIS.convert(grGeoJ);
  76.     // doing this because .convert likes to attach a lat/long spatial reference for fun.
  77.     grEsri.spatialReference = destProj;
  79.     return grEsri;
  80. }
  82. /**
  83.  * Reproject an EsriExtent object on the client.  Does not require network
  84.  * traffic, but may not handle conversion between projection types as well.
  85.  * Internally it tests 8 points along each edge and takes the max extent
  86.  * of the result.
  87.  *
  88.  * @param {EsriExtent} extent to reproject
  89.  * @param {Object} sr is the target spatial reference (if a number it
  90.  *                 will be treated as a WKID)
  91.  * @returns {Object} an extent as an unstructured object
  92.  */
  93. function localProjectExtent(extent, sr) {
  95.     // interpolates two points by splitting the line in half recursively
  96.     function interpolate(p0, p1, steps) {
  97.         if (steps === 0) { return [p0, p1]; }
  99.         let mid = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
  100.         if (steps === 1) {
  101.             return [p0, mid, p1];
  102.         }
  103.         if (steps > 1) {
  104.             let i0 = interpolate(p0, mid, steps - 1);
  105.             let i1 = interpolate(mid, p1, steps - 1);
  106.             return i0.concat(i1.slice(1));
  107.         }
  108.     }
  110.     const points = [[extent.xmin, extent.ymin], [extent.xmax, extent.ymin],
  111.                     [extent.xmax, extent.ymax], [extent.xmin, extent.ymax],
  112.                     [extent.xmin, extent.ymin]];
  113.     let interpolatedPoly = [];
  114.     let srcProj;
  116.     // interpolate each edge by splitting it in half 3 times (since lines are not guaranteed to project to lines we need to consider
  117.     // max / min points in the middle of line segments)
  118.     [0, 1, 2, 3]
  119.         .map(i => interpolate(points[i], points[i + 1], 3).slice(1))
  120.         .forEach(seg => interpolatedPoly = interpolatedPoly.concat(seg));
  122.     // find the source extent (either from wkid or wkt)
  123.     if (extent.spatialReference.wkid) {
  124.         srcProj = 'EPSG:' + extent.spatialReference.wkid;
  125.     } else if (extent.spatialReference.wkt) {
  126.         srcProj = extent.spatialReference.wkt;
  127.     } else {
  128.         throw new Error('No WKT or WKID specified on extent.spatialReference');
  129.     }
  131.     // find the destination extent
  132.     let destProj = normalizeProj(sr);
  134.     if (extent.spatialReference.wkid && !proj4.defs(srcProj)) {
  135.         throw new Error('Source projection WKID not recognized by proj4 library');
  136.     }
  137.     const projConvert = proj4(srcProj, destProj);
  138.     const transformed = interpolatedPoly.map(x => projConvert.forward(x));
  140.     const xvals = transformed.map(x => x[0]);
  141.     const yvals = transformed.map(x => x[1]);
  143.     const x0 = Math.min.apply(null, xvals);
  144.     const x1 = Math.max.apply(null, xvals);
  146.     const y0 = Math.min.apply(null, yvals);
  147.     const y1 = Math.max.apply(null, yvals);
  149.     return { x0, y0, x1, y1, sr };
  150. }
  152. /**
  153.  * Check whether or not a spatialReference is supported by proj4 library.
  154.  *
  155.  * @param {Object} spatialReference to be checked to see if it's supported by proj4
  156.  * @param {Function} epsgLookup an optional lookup function for EPSG codes which are not loaded
  157.  * in the proj4 definitions, the function should take a numeric EPSG code and return a Promise
  158.  * resolving with a proj4 style definition string
  159.  * @returns {Object} with the structure {
  160.  *  foundProj: (bool) indicates if the projection was found,
  161.  *  message: (string) provides a reason why the projection was not found,
  162.  *  lookupPromise: (Promise) an optional promise resolving with true or false if a lookup function was provided and had to be invoked
  163.  * }
  164.  */
  165. function checkProj(spatialReference, epsgLookup) {
  166.     let srcProj;
  168.     // find the source extent (either from wkid or wkt)
  169.     if (spatialReference.wkid) {
  170.         srcProj = 'EPSG:' + spatialReference.wkid;
  171.     } else if (spatialReference.wkt) {
  172.         srcProj = spatialReference.wkt;
  173.     } else {
  174.         return {
  175.             foundProj: false,
  176.             message: 'No WKT or WKID specified on extent.spatialReference'
  177.         };
  178.     }
  180.     if (spatialReference.wkid && !proj4.defs(srcProj)) {
  181.         if (epsgLookup) {
  182.             return {
  183.                 foundProj: false,
  184.                 message: 'Attempting to lookup WKID',
  185.                 lookupPromise: epsgLookup(spatialReference.wkid).then(def => {
  186.                     if (def === null) {
  187.                         return false;
  188.                     }
  189.                     proj4.defs(srcProj, def);
  190.                     return true;
  191.                 })
  192.             };
  193.         }
  194.         return {
  195.             foundProj: false,
  196.             message: 'Source projection in WKID and not recognized by proj4 library'
  197.         };
  198.     }
  200.     return {
  201.         foundProj: true,
  202.         message: 'Source projection OK.'
  203.     };
  204. }
  206. function projectEsriExtentBuilder(esriBundle) {
  207.     return (extent, sr) => {
  208.         const p = localProjectExtent(extent, sr);
  209.         return new esriBundle.Extent(p.x0, p.y0, p.x1, p.y1, p.sr);
  210.     };
  211. }
  213. function esriServiceBuilder(esriBundle) {
  214.     /**
  215.      * Reproject an esri geometry object on the server. Requires network traffic
  216.      * to esri's Geometry Service, but may be slower than proj4 conversion.
  217.      * Internally it tests 1 point and reprojects it to another spatial reference.
  218.      *
  219.      * @param {url} url for the ESRI Geometry Service
  220.      * @param {geometries} geometries to be projected
  221.      * @param {sr} sr is the target spatial reference
  222.      * @returns {Promise} promise to return reprojected geometries
  223.      */
  224.     return (url, geometries, sr) => {
  225.         return new Promise(
  226.             (resolve, reject) => {
  227.                 const params = new esriBundle.ProjectParameters();
  229.                 // connect to esri server
  230.                 const gsvc = new esriBundle.GeometryService(url);
  232.                 params.geometries = geometries;
  233.                 params.outSR = sr;
  235.                 // call project function from esri server to do conversion
  236.                 gsvc.project(params,
  237.                     projectedExtents => {
  238.                         resolve(projectedExtents);
  239.                     }, error => {
  240.                         reject(error);
  241.                     });
  242.             });
  243.     };
  244. }
  246. /**
  247. * Checks if two spatial reference objects are equivalent.  Handles both wkid and wkt definitions.
  248. *
  249. * @method isSpatialRefEqual
  250. * @static
  251. * @param {type} sr1 Esri Spatial Reference First to compare
  252. * @param {type} sr2 Esri Spatial Reference Second to compare
  253. * @return {Boolean} true if the two spatial references are equivalent.  False otherwise.
  254. */
  255. function isSpatialRefEqual(sr1, sr2) {
  256.     if ((sr1.wkid) && (sr2.wkid)) {
  257.         // both SRs have wkids
  258.         return sr1.wkid === sr2.wkid;
  259.     } else if ((sr1.wkt) && (sr2.wkt)) {
  260.         // both SRs have wkt's
  261.         return sr1.wkt === sr2.wkt;
  262.     } else {
  263.         // not enough info provided or mismatch between wkid and wkt.
  264.         return false;
  265.     }
  266. }
  268. module.exports = function (esriBundle) {
  269.     // TODO: Move Point and SpatialReference to its own (geometry) module
  271.     // TODO consider moving this elsewhere.  state is bad, but these are common, and we have no service for esri defs
  272.     proj4.defs('EPSG:3978', '+proj=lcc +lat_1=49 +lat_2=77 +lat_0=49 ' +
  273.         '+lon_0=-95 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs');
  274.     proj4.defs('EPSG:3979', '+proj=lcc +lat_1=49 +lat_2=77 +lat_0=49 +lon_0=-95 ' +
  275.         '+x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs');
  276.     proj4.defs('EPSG:54004', '+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 ' +
  277.         '+datum=WGS84 +units=m +no_defs');
  278.     proj4.defs('EPSG:102100', proj4.defs('EPSG:3857'));
  280.     return {
  281.         addProjection: proj4.defs, // straight passthrough at the moment, maybe add arg checking (two args)?
  282.         checkProj,
  283.         getProjection: proj4.defs, // straight passthrough at the moment, maybe add arg checking (one arg)?
  284.         esriServerProject: esriServiceBuilder(esriBundle),
  285.         Graphic: esriBundle.Graphic,
  286.         graphicsUtils: esriBundle.graphicsUtils,
  287.         isSpatialRefEqual,
  288.         localProjectExtent,
  289.         localProjectPoint,
  290.         localProjectGeometry,
  291.         projectGeojson,
  292.         Point: esriBundle.Point,
  293.         projectEsriExtent: projectEsriExtentBuilder(esriBundle),
  294.         SpatialReference: esriBundle.SpatialReference
  295.     };
  296. };