proj4 2.7.5 → 2.8.1

package/.github/workflows/build-and-test.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

package/Gruntfile.js

@@ -31,7 +31,8 @@ var projs = [
   'qsc',
   'robin',
   'geocent',
-  'tpers'
+  'tpers',
+  'geos'
 ];
 module.exports = function (grunt) {
   grunt.initConfig({

package/README.md

@@ -23,12 +23,12 @@ If you do not want to download anything, Proj4js is also hosted on [cdnjs](https
 The basic signature is:
 
 ```javascript
-proj4(fromProjection[, toProjection, coordinates])
+proj4([fromProjection, ]toProjection[, coordinates])
 ```
 
 Projections can be proj or wkt strings.
 
-Coordinates may an object of the form `{x:x,y:y}` or an array of the form `[x,y]`.
+Coordinates may be an object of the form `{x:x,y:y}` or an array of the form `[x,y]`.
 
 When all 3 arguments  are given, the result is that the coordinates are transformed from projection1 to projection 2. And returned in the same format that they were given in.
 
@@ -36,8 +36,15 @@ When all 3 arguments  are given, the result is that the coordinates are transfor
 var firstProjection = 'PROJCS["NAD83 / Massachusetts Mainland",GEOGCS["NAD83",DATUM["North_American_Datum_1983",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6269"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4269"]],UNIT["metre",1,AUTHORITY["EPSG","9001"]],PROJECTION["Lambert_Conformal_Conic_2SP"],PARAMETER["standard_parallel_1",42.68333333333333],PARAMETER["standard_parallel_2",41.71666666666667],PARAMETER["latitude_of_origin",41],PARAMETER["central_meridian",-71.5],PARAMETER["false_easting",200000],PARAMETER["false_northing",750000],AUTHORITY["EPSG","26986"],AXIS["X",EAST],AXIS["Y",NORTH]]';
 var secondProjection = "+proj=gnom +lat_0=90 +lon_0=0 +x_0=6300000 +y_0=6300000 +ellps=WGS84 +datum=WGS84 +units=m +no_defs";
 //I'm not going to redefine those two in latter examples.
-proj4(firstProjection,secondProjection,[2,5]);
-// [-2690666.2977344505, 3662659.885459918]
+proj4(firstProjection,secondProjection,[-122.305887, 58.9465872]);
+// [-2690575.447893817, 36622916.8071244564]
+```
+
+The library can also parse coordinates provided with an elevation and measure, again as an object of the form `{x:x,y:y,z:z,m:m}` or an array of the form `[x,y,z,m]`.
+
+```javascript
+proj4(firstProjection,secondProjection,[-122.305887, 58.9465872,10]);
+// [-2690575.447893817, 36622916.8071244564, 10]
 ```
 
 If only 1 projection is given then it is assumed that it is being projected *from* WGS84 (fromProjection is WGS84).
@@ -50,10 +57,10 @@ proj4(firstProjection,[-71,41]);
 If no coordinates are given an object with two methods is returned, its methods are `forward` which projects from the first projection to the second and `inverse` which projects from the second to the first.
 
 ```javascript
-proj4(firstProjection,secondProjection).forward([2,5]);
-// [-2690666.2977344505, 3662659.885459918]
-proj4(secondProjection,firstProjection).inverse([2,5]);
-// [-2690666.2977344505, 3662659.885459918]
+proj4(firstProjection,secondProjection).forward([-122.305887, 58.9465872]);
+// [-2690575.447893817, 36622916.8071244564]
+proj4(secondProjection,firstProjection).inverse([-122.305887, 58.9465872]);
+// [-2690575.447893817, 36622916.8071244564]
 ```
 
 And as above if only one projection is given, it's assumed to be coming from wgs84:
@@ -62,9 +69,9 @@ And as above if only one projection is given, it's assumed to be coming from wgs
 proj4(firstProjection).forward([-71,41]);
 // [242075.00535055372, 750123.32090043]
 proj4(firstProjection).inverse([242075.00535055372, 750123.32090043]);
-//[-71, 40.99999999999986]
-//the floating points to answer your question
+// [-71, 40.99999999999986]
 ```
+Note: The generation of the floating point value `40.99999999999986` in this example represents the fact that some variance in precision is involved in any conversion between one coordinate reference system and another.
 
 ## Named Projections
 
@@ -151,31 +158,31 @@ $ npm install --save @types/proj4
 ## Developing
 To set up build tools make sure you have node and grunt-cli installed and then run `npm install`.
 
-To do the complete build and browser tests run:
+To do the complete build and browser tests run
 
 ```bash
 node_modules/.bin/grunt
 ```
 
-To run node tests run:
+To run node tests run
 
 ```bash
 npm test
 ```
 
-To run node tests with coverage run:
+To run node tests with coverage run
 
 ```bash
 npm test --coverage
 ```
 
-To create a build with only default projections (latlon and Mercator) run:
+To create a build with only default projections (latlon and Mercator) run
 
 ```bash
 node_modules/.bin/grunt build
 ```
 
-To create a build with only custom projections include a comma separated list of projections codes (the file name in 'lib/projections' without the '.js') after a colon, e.g.:
+To create a build with only custom projections include a comma separated list of projections codes (the file name in 'lib/projections' without the '.js') after a colon, e.g.
 
 ```bash
 node_modules/.bin/grunt build:tmerc

package/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "proj4",
-  "version": "2.7.5",
+  "version": "2.8.1",
   "description": "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",
   "homepage": "https://github.com/proj4js/proj4js",
   "main": "dist/proj4.js",

package/component.json

@@ -1,6 +1,6 @@
 {
   "name": "proj4",
-  "version": "2.7.5",
+  "version": "2.8.1",
   "description": "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",
   "repo": "proj4js/proj4js",
   "keywords": [

package/dist/proj4-src.js

@@ -229,7 +229,7 @@
     var ENDED = -1;
     var whitespace = /\s/;
     var latin = /[A-Za-z]/;
-    var keyword = /[A-Za-z84]/;
+    var keyword = /[A-Za-z84_]/;
     var endThings = /[,\]]/;
     var digets = /[\d\.E\-\+]/;
     // const ignoredChar = /[\s_\-\/\(\)]/g;
@@ -1631,7 +1631,7 @@
       extend(this, json); // transfer everything over from the projection because we don't know what we'll need
       extend(this, ourProj); // transfer all the methods from the projection
 
-      // copy the 4 things over we calulated in deriveConstants.sphere
+      // copy the 4 things over we calculated in deriveConstants.sphere
       this.a = sphere_.a;
       this.b = sphere_.b;
       this.rf = sphere_.rf;
@@ -2172,14 +2172,25 @@
     }
 
     function checkNotWGS(source, dest) {
-      return ((source.datum.datum_type === PJD_3PARAM || source.datum.datum_type === PJD_7PARAM) && dest.datumCode !== 'WGS84') || ((dest.datum.datum_type === PJD_3PARAM || dest.datum.datum_type === PJD_7PARAM) && source.datumCode !== 'WGS84');
+      return (
+        (source.datum.datum_type === PJD_3PARAM || source.datum.datum_type === PJD_7PARAM || source.datum.datum_type === PJD_GRIDSHIFT) && dest.datumCode !== 'WGS84') ||
+        ((dest.datum.datum_type === PJD_3PARAM || dest.datum.datum_type === PJD_7PARAM || dest.datum.datum_type === PJD_GRIDSHIFT) && source.datumCode !== 'WGS84');
     }
 
     function transform(source, dest, point, enforceAxis) {
       var wgs84;
       if (Array.isArray(point)) {
         point = toPoint(point);
+      } else {
+        // Clone the point object so inputs don't get modified
+        point = {
+          x: point.x,
+          y: point.y,
+          z: point.z,
+          m: point.m
+        };
       }
+      var hasZ = point.z !== undefined;
       checkSanity(point);
       // Workaround for datum shifts towgs84, if either source or destination projection is not wgs84
       if (source.datum && dest.datum && checkNotWGS(source, dest)) {
@@ -2254,6 +2265,9 @@
         return adjust_axis(dest, true, point);
       }
 
+      if (!hasZ) {
+        delete point.z;
+      }
       return point;
     }
 
@@ -4370,7 +4384,9 @@
       "Lambert_Conformal_Conic",
       "Lambert_Conformal_Conic_1SP",
       "Lambert_Conformal_Conic_2SP",
-      "lcc"
+      "lcc",
+      "Lambert Conic Conformal (1SP)",
+      "Lambert Conic Conformal (2SP)"
     ];
 
     var lcc = {
@@ -4954,18 +4970,18 @@
       this.t1 = this.sin_po;
       this.con = this.sin_po;
       this.ms1 = msfnz(this.e3, this.sin_po, this.cos_po);
-      this.qs1 = qsfnz(this.e3, this.sin_po, this.cos_po);
+      this.qs1 = qsfnz(this.e3, this.sin_po);
 
       this.sin_po = Math.sin(this.lat2);
       this.cos_po = Math.cos(this.lat2);
       this.t2 = this.sin_po;
       this.ms2 = msfnz(this.e3, this.sin_po, this.cos_po);
-      this.qs2 = qsfnz(this.e3, this.sin_po, this.cos_po);
+      this.qs2 = qsfnz(this.e3, this.sin_po);
 
       this.sin_po = Math.sin(this.lat0);
       this.cos_po = Math.cos(this.lat0);
       this.t3 = this.sin_po;
-      this.qs0 = qsfnz(this.e3, this.sin_po, this.cos_po);
+      this.qs0 = qsfnz(this.e3, this.sin_po);
 
       if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
         this.ns0 = (this.ms1 * this.ms1 - this.ms2 * this.ms2) / (this.qs2 - this.qs1);
@@ -4987,7 +5003,7 @@
       this.sin_phi = Math.sin(lat);
       this.cos_phi = Math.cos(lat);
 
-      var qs = qsfnz(this.e3, this.sin_phi, this.cos_phi);
+      var qs = qsfnz(this.e3, this.sin_phi);
       var rh1 = this.a * Math.sqrt(this.c - this.ns0 * qs) / this.ns0;
       var theta = this.ns0 * adjust_lon(lon - this.long0);
       var x = rh1 * Math.sin(theta) + this.x0;
@@ -7126,6 +7142,163 @@
       names: names$31
     };
 
+    function init$31() {
+        this.flip_axis = (this.sweep === 'x' ? 1 : 0);
+        this.h = Number(this.h);
+        this.radius_g_1 = this.h / this.a;
+
+        if (this.radius_g_1 <= 0 || this.radius_g_1 > 1e10) {
+            throw new Error();
+        }
+
+        this.radius_g = 1.0 + this.radius_g_1;
+        this.C = this.radius_g * this.radius_g - 1.0;
+
+        if (this.es !== 0.0) {
+            var one_es = 1.0 - this.es;
+            var rone_es = 1 / one_es;
+
+            this.radius_p = Math.sqrt(one_es);
+            this.radius_p2 = one_es;
+            this.radius_p_inv2 = rone_es;
+
+            this.shape = 'ellipse'; // Use as a condition in the forward and inverse functions.
+        } else {
+            this.radius_p = 1.0;
+            this.radius_p2 = 1.0;
+            this.radius_p_inv2 = 1.0;
+
+            this.shape = 'sphere';  // Use as a condition in the forward and inverse functions.
+        }
+
+        if (!this.title) {
+            this.title = "Geostationary Satellite View";
+        }
+    }
+
+    function forward$30(p) {
+        var lon = p.x;
+        var lat = p.y;
+        var tmp, v_x, v_y, v_z;
+        lon = lon - this.long0;
+
+        if (this.shape === 'ellipse') {
+            lat = Math.atan(this.radius_p2 * Math.tan(lat));
+            var r = this.radius_p / hypot(this.radius_p * Math.cos(lat), Math.sin(lat));
+
+            v_x = r * Math.cos(lon) * Math.cos(lat);
+            v_y = r * Math.sin(lon) * Math.cos(lat);
+            v_z = r * Math.sin(lat);
+
+            if (((this.radius_g - v_x) * v_x - v_y * v_y - v_z * v_z * this.radius_p_inv2) < 0.0) {
+                p.x = Number.NaN;
+                p.y = Number.NaN;
+                return p;
+            }
+
+            tmp = this.radius_g - v_x;
+            if (this.flip_axis) {
+                p.x = this.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+                p.y = this.radius_g_1 * Math.atan(v_z / tmp);
+            } else {
+                p.x = this.radius_g_1 * Math.atan(v_y / tmp);
+                p.y = this.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+            }
+        } else if (this.shape === 'sphere') {
+            tmp = Math.cos(lat);
+            v_x = Math.cos(lon) * tmp;
+            v_y = Math.sin(lon) * tmp;
+            v_z = Math.sin(lat);
+            tmp = this.radius_g - v_x;
+
+            if (this.flip_axis) {
+                p.x = this.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+                p.y = this.radius_g_1 * Math.atan(v_z / tmp);
+            } else {
+                p.x = this.radius_g_1 * Math.atan(v_y / tmp);
+                p.y = this.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+            }
+        }
+        p.x = p.x * this.a;
+        p.y = p.y * this.a;
+        return p;
+    }
+
+    function inverse$30(p) {
+        var v_x = -1.0;
+        var v_y = 0.0;
+        var v_z = 0.0;
+        var a, b, det, k;
+
+        p.x = p.x / this.a;
+        p.y = p.y / this.a;
+
+        if (this.shape === 'ellipse') {
+            if (this.flip_axis) {
+                v_z = Math.tan(p.y / this.radius_g_1);
+                v_y = Math.tan(p.x / this.radius_g_1) * hypot(1.0, v_z);
+            } else {
+                v_y = Math.tan(p.x / this.radius_g_1);
+                v_z = Math.tan(p.y / this.radius_g_1) * hypot(1.0, v_y);
+            }
+
+            var v_zp = v_z / this.radius_p;
+            a = v_y * v_y + v_zp * v_zp + v_x * v_x;
+            b = 2 * this.radius_g * v_x;
+            det = (b * b) - 4 * a * this.C;
+
+            if (det < 0.0) {
+                p.x = Number.NaN;
+                p.y = Number.NaN;
+                return p;
+            }
+
+            k = (-b - Math.sqrt(det)) / (2.0 * a);
+            v_x = this.radius_g + k * v_x;
+            v_y *= k;
+            v_z *= k;
+
+            p.x = Math.atan2(v_y, v_x);
+            p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+            p.y = Math.atan(this.radius_p_inv2 * Math.tan(p.y));
+        } else if (this.shape === 'sphere') {
+            if (this.flip_axis) {
+                v_z = Math.tan(p.y / this.radius_g_1);
+                v_y = Math.tan(p.x / this.radius_g_1) * Math.sqrt(1.0 + v_z * v_z);
+            } else {
+                v_y = Math.tan(p.x / this.radius_g_1);
+                v_z = Math.tan(p.y / this.radius_g_1) * Math.sqrt(1.0 + v_y * v_y);
+            }
+
+            a = v_y * v_y + v_z * v_z + v_x * v_x;
+            b = 2 * this.radius_g * v_x;
+            det = (b * b) - 4 * a * this.C;
+            if (det < 0.0) {
+                p.x = Number.NaN;
+                p.y = Number.NaN;
+                return p;
+            }
+
+            k = (-b - Math.sqrt(det)) / (2.0 * a);
+            v_x = this.radius_g + k * v_x;
+            v_y *= k;
+            v_z *= k;
+
+            p.x = Math.atan2(v_y, v_x);
+            p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+        }
+        p.x = p.x + this.long0;
+        return p;
+    }
+
+    var names$32 = ["Geostationary Satellite View", "Geostationary_Satellite", "geos"];
+    var geos = {
+        init: init$31,
+        forward: forward$30,
+        inverse: inverse$30,
+        names: names$32,
+    };
+
     var includedProjections = function(proj4){
       proj4.Proj.projections.add(tmerc);
       proj4.Proj.projections.add(etmerc);
@@ -7155,6 +7328,7 @@
       proj4.Proj.projections.add(robin);
       proj4.Proj.projections.add(geocent);
       proj4.Proj.projections.add(tpers);
+      proj4.Proj.projections.add(geos);
     };
 
     proj4$1.defaultDatum = 'WGS84'; //default datum
@@ -7166,7 +7340,7 @@
     proj4$1.nadgrid = nadgrid;
     proj4$1.transform = transform;
     proj4$1.mgrs = mgrs;
-    proj4$1.version = '2.7.5';
+    proj4$1.version = '2.8.1';
     includedProjections(proj4$1);
 
     return proj4$1;