proj4 2.4.4 → 2.6.2

package/lib/parseCode.js

@@ -1,18 +1,35 @@
 import defs from './defs';
 import wkt from 'wkt-parser';
 import projStr from './projString';
+import match from './match';
 function testObj(code){
   return typeof code === 'string';
 }
 function testDef(code){
   return code in defs;
 }
- var codeWords = ['PROJECTEDCRS', 'PROJCRS', 'GEOGCS','GEOCCS','PROJCS','LOCAL_CS', 'GEODCRS', 'GEODETICCRS', 'GEODETICDATUM', 'ENGCRS', 'ENGINEERINGCRS']; 
+ var codeWords = ['PROJECTEDCRS', 'PROJCRS', 'GEOGCS','GEOCCS','PROJCS','LOCAL_CS', 'GEODCRS', 'GEODETICCRS', 'GEODETICDATUM', 'ENGCRS', 'ENGINEERINGCRS'];
 function testWKT(code){
   return codeWords.some(function (word) {
     return code.indexOf(word) > -1;
   });
 }
+var codes = ['3857', '900913', '3785', '102113'];
+function checkMercator(item) {
+  var auth = match(item, 'authority');
+  if (!auth) {
+    return;
+  }
+  var code = match(auth, 'epsg');
+  return code && codes.indexOf(code) > -1;
+}
+function checkProjStr(item) {
+  var ext = match(item, 'extension');
+  if (!ext) {
+    return;
+  }
+  return match(ext, 'proj4');
+}
 function testProj(code){
   return code[0] === '+';
 }
@@ -23,7 +40,16 @@ function parse(code){
       return defs[code];
     }
     if (testWKT(code)) {
-      return wkt(code);
+      var out = wkt(code);
+      // test of spetial case, due to this being a very common and often malformed
+      if (checkMercator(out)) {
+        return defs['EPSG:3857'];
+      }
+      var maybeProjStr = checkProjStr(out);
+      if (maybeProjStr) {
+        return projStr(maybeProjStr);
+      }
+      return out;
     }
     if (testProj(code)) {
       return projStr(code);

package/lib/projections/aeqd.js

@@ -41,7 +41,7 @@ export function forward(p) {
       //default case
       cos_c = this.sin_p12 * sinphi + this.cos_p12 * cosphi * Math.cos(dlon);
       c = Math.acos(cos_c);
-      kp = c / Math.sin(c);
+      kp = c ? c / Math.sin(c) : 1;
       p.x = this.x0 + this.a * kp * cosphi * Math.sin(dlon);
       p.y = this.y0 + this.a * kp * (this.cos_p12 * sinphi - this.sin_p12 * cosphi * Math.cos(dlon));
       return p;
@@ -105,7 +105,7 @@ export function forward(p) {
 export function inverse(p) {
   p.x -= this.x0;
   p.y -= this.y0;
-  var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, N1, psi, Az, cosAz, tmp, A, B, D, Ee, F;
+  var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, N1, psi, Az, cosAz, tmp, A, B, D, Ee, F, sinpsi;
   if (this.sphere) {
     rh = Math.sqrt(p.x * p.x + p.y * p.y);
     if (rh > (2 * HALF_PI * this.a)) {
@@ -189,7 +189,8 @@ export function inverse(p) {
       F = 1 - A * Ee * Ee / 2 - D * Ee * Ee * Ee / 6;
       psi = Math.asin(this.sin_p12 * Math.cos(Ee) + this.cos_p12 * Math.sin(Ee) * cosAz);
       lon = adjust_lon(this.long0 + Math.asin(Math.sin(Az) * Math.sin(Ee) / Math.cos(psi)));
-      lat = Math.atan((1 - this.es * F * this.sin_p12 / Math.sin(psi)) * Math.tan(psi) / (1 - this.es));
+      sinpsi = Math.sin(psi);
+      lat = Math.atan2((sinpsi - this.es * F * this.sin_p12) * Math.tan(psi), sinpsi * (1 - this.es));
       p.x = lon;
       p.y = lat;
       return p;

package/lib/projections/geocent.js

@@ -0,0 +1,27 @@
+import {
+    geodeticToGeocentric,
+    geocentricToGeodetic
+} from '../datumUtils';
+
+export function init() {
+    this.name = 'geocent';
+
+}
+
+export function forward(p) {
+    var point = geodeticToGeocentric(p, this.es, this.a);
+    return point;
+}
+
+export function inverse(p) {
+    var point = geocentricToGeodetic(p, this.es, this.a, this.b);
+    return point;
+}
+
+export var names = ["Geocentric", 'geocentric', "geocent", "Geocent"];
+export default {
+    init: init,
+    forward: forward,
+    inverse: inverse,
+    names: names
+};

package/lib/projections/gstmerc.js

@@ -54,7 +54,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["gstmerg"];
+export var names = ["gstmerg", "gstmerc"];
 export default {
   init: init,
   forward: forward,

package/lib/projections/laea.js

@@ -95,7 +95,7 @@ export function forward(p) {
       if (this.mode === this.N_POLE) {
         coslam = -coslam;
       }
-      if (Math.abs(phi + this.phi0) < EPSLN) {
+      if (Math.abs(phi + this.lat0) < EPSLN) {
         return null;
       }
       y = FORTPI - phi * 0.5;
@@ -194,7 +194,7 @@ export function inverse(p) {
       y = cosz * rh;
       break;
     case this.OBLIQ:
-      phi = (Math.abs(rh) <= EPSLN) ? this.phi0 : Math.asin(cosz * this.sinph0 + y * sinz * this.cosph0 / rh);
+      phi = (Math.abs(rh) <= EPSLN) ? this.lat0 : Math.asin(cosz * this.sinph0 + y * sinz * this.cosph0 / rh);
       x *= sinz * this.cosph0;
       y = (cosz - Math.sin(phi) * this.sinph0) * rh;
       break;
@@ -215,8 +215,8 @@ export function inverse(p) {
       y *= this.dd;
       rho = Math.sqrt(x * x + y * y);
       if (rho < EPSLN) {
-        p.x = 0;
-        p.y = this.phi0;
+        p.x = this.long0;
+        p.y = this.lat0;
         return p;
       }
       sCe = 2 * Math.asin(0.5 * rho / this.rq);
@@ -239,8 +239,8 @@ export function inverse(p) {
       }
       q = (x * x + y * y);
       if (!q) {
-        p.x = 0;
-        p.y = this.phi0;
+        p.x = this.long0;
+        p.y = this.lat0;
         return p;
       }
       ab = 1 - q / this.qp;

package/lib/projections/robin.js

@@ -0,0 +1,161 @@
+// Robinson projection
+// Based on https://github.com/OSGeo/proj.4/blob/master/src/PJ_robin.c
+// Polynomial coeficients from http://article.gmane.org/gmane.comp.gis.proj-4.devel/6039
+
+import {HALF_PI, D2R, R2D, EPSLN} from '../constants/values';
+import adjust_lon from '../common/adjust_lon';
+
+var COEFS_X = [
+    [1.0000, 2.2199e-17, -7.15515e-05, 3.1103e-06],
+    [0.9986, -0.000482243, -2.4897e-05, -1.3309e-06],
+    [0.9954, -0.00083103, -4.48605e-05, -9.86701e-07],
+    [0.9900, -0.00135364, -5.9661e-05, 3.6777e-06],
+    [0.9822, -0.00167442, -4.49547e-06, -5.72411e-06],
+    [0.9730, -0.00214868, -9.03571e-05, 1.8736e-08],
+    [0.9600, -0.00305085, -9.00761e-05, 1.64917e-06],
+    [0.9427, -0.00382792, -6.53386e-05, -2.6154e-06],
+    [0.9216, -0.00467746, -0.00010457, 4.81243e-06],
+    [0.8962, -0.00536223, -3.23831e-05, -5.43432e-06],
+    [0.8679, -0.00609363, -0.000113898, 3.32484e-06],
+    [0.8350, -0.00698325, -6.40253e-05, 9.34959e-07],
+    [0.7986, -0.00755338, -5.00009e-05, 9.35324e-07],
+    [0.7597, -0.00798324, -3.5971e-05, -2.27626e-06],
+    [0.7186, -0.00851367, -7.01149e-05, -8.6303e-06],
+    [0.6732, -0.00986209, -0.000199569, 1.91974e-05],
+    [0.6213, -0.010418, 8.83923e-05, 6.24051e-06],
+    [0.5722, -0.00906601, 0.000182, 6.24051e-06],
+    [0.5322, -0.00677797, 0.000275608, 6.24051e-06]
+];
+
+var COEFS_Y = [
+    [-5.20417e-18, 0.0124, 1.21431e-18, -8.45284e-11],
+    [0.0620, 0.0124, -1.26793e-09, 4.22642e-10],
+    [0.1240, 0.0124, 5.07171e-09, -1.60604e-09],
+    [0.1860, 0.0123999, -1.90189e-08, 6.00152e-09],
+    [0.2480, 0.0124002, 7.10039e-08, -2.24e-08],
+    [0.3100, 0.0123992, -2.64997e-07, 8.35986e-08],
+    [0.3720, 0.0124029, 9.88983e-07, -3.11994e-07],
+    [0.4340, 0.0123893, -3.69093e-06, -4.35621e-07],
+    [0.4958, 0.0123198, -1.02252e-05, -3.45523e-07],
+    [0.5571, 0.0121916, -1.54081e-05, -5.82288e-07],
+    [0.6176, 0.0119938, -2.41424e-05, -5.25327e-07],
+    [0.6769, 0.011713, -3.20223e-05, -5.16405e-07],
+    [0.7346, 0.0113541, -3.97684e-05, -6.09052e-07],
+    [0.7903, 0.0109107, -4.89042e-05, -1.04739e-06],
+    [0.8435, 0.0103431, -6.4615e-05, -1.40374e-09],
+    [0.8936, 0.00969686, -6.4636e-05, -8.547e-06],
+    [0.9394, 0.00840947, -0.000192841, -4.2106e-06],
+    [0.9761, 0.00616527, -0.000256, -4.2106e-06],
+    [1.0000, 0.00328947, -0.000319159, -4.2106e-06]
+];
+
+var FXC = 0.8487;
+var FYC = 1.3523;
+var C1 = R2D/5; // rad to 5-degree interval
+var RC1 = 1/C1;
+var NODES = 18;
+
+var poly3_val = function(coefs, x) {
+    return coefs[0] + x * (coefs[1] + x * (coefs[2] + x * coefs[3]));
+};
+
+var poly3_der = function(coefs, x) {
+    return coefs[1] + x * (2 * coefs[2] + x * 3 * coefs[3]);
+};
+
+function newton_rapshon(f_df, start, max_err, iters) {
+    var x = start;
+    for (; iters; --iters) {
+        var upd = f_df(x);
+        x -= upd;
+        if (Math.abs(upd) < max_err) {
+            break;
+        }
+    }
+    return x;
+}
+
+export function init() {
+    this.x0 = this.x0 || 0;
+    this.y0 = this.y0 || 0;
+    this.long0 = this.long0 || 0;
+    this.es = 0;
+    this.title = this.title || "Robinson";
+}
+
+export function forward(ll) {
+    var lon = adjust_lon(ll.x - this.long0);
+
+    var dphi = Math.abs(ll.y);
+    var i = Math.floor(dphi * C1);
+    if (i < 0) {
+        i = 0;
+    } else if (i >= NODES) {
+        i = NODES - 1;
+    }
+    dphi = R2D * (dphi - RC1 * i);
+    var xy = {
+        x: poly3_val(COEFS_X[i], dphi) * lon,
+        y: poly3_val(COEFS_Y[i], dphi)
+    };
+    if (ll.y < 0) {
+        xy.y = -xy.y;
+    }
+
+    xy.x = xy.x * this.a * FXC + this.x0;
+    xy.y = xy.y * this.a * FYC + this.y0;
+    return xy;
+}
+
+export function inverse(xy) {
+    var ll = {
+        x: (xy.x - this.x0) / (this.a * FXC),
+        y: Math.abs(xy.y - this.y0) / (this.a * FYC)
+    };
+
+    if (ll.y >= 1) { // pathologic case
+        ll.x /= COEFS_X[NODES][0];
+        ll.y = xy.y < 0 ? -HALF_PI : HALF_PI;
+    } else {
+        // find table interval
+        var i = Math.floor(ll.y * NODES);
+        if (i < 0) {
+            i = 0;
+        } else if (i >= NODES) {
+            i = NODES - 1;
+        }
+        for (;;) {
+            if (COEFS_Y[i][0] > ll.y) {
+                --i;
+            } else if (COEFS_Y[i+1][0] <= ll.y) {
+                ++i;
+            } else {
+                break;
+            }
+        }
+        // linear interpolation in 5 degree interval
+        var coefs = COEFS_Y[i];
+        var t = 5 * (ll.y - coefs[0]) / (COEFS_Y[i+1][0] - coefs[0]);
+        // find t so that poly3_val(coefs, t) = ll.y
+        t = newton_rapshon(function(x) {
+            return (poly3_val(coefs, x) - ll.y) / poly3_der(coefs, x);
+        }, t, EPSLN, 100);
+
+        ll.x /= poly3_val(COEFS_X[i], t);
+        ll.y = (5 * i + t) * D2R;
+        if (xy.y < 0) {
+            ll.y = -ll.y;
+        }
+    }
+
+    ll.x = adjust_lon(ll.x + this.long0);
+    return ll;
+}
+
+export var names = ["Robinson", "robin"];
+export default {
+  init: init,
+  forward: forward,
+  inverse: inverse,
+  names: names
+};

package/lib/projections/stere.js

@@ -103,7 +103,7 @@ export function inverse(p) {
   var lon, lat, ts, ce, Chi;
   var rh = Math.sqrt(p.x * p.x + p.y * p.y);
   if (this.sphere) {
-    var c = 2 * Math.atan(rh / (0.5 * this.a * this.k0));
+    var c = 2 * Math.atan(rh / (2 * this.a * this.k0));
     lon = this.long0;
     lat = this.lat0;
     if (rh <= EPSLN) {

package/lib/projections/sterea.js

@@ -55,7 +55,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["Stereographic_North_Pole", "Oblique_Stereographic", "Polar_Stereographic", "sterea","Oblique Stereographic Alternative"];
+export var names = ["Stereographic_North_Pole", "Oblique_Stereographic", "Polar_Stereographic", "sterea","Oblique Stereographic Alternative","Double_Stereographic"];
 export default {
   init: init,
   forward: forward,

package/lib/transform.js

@@ -29,17 +29,21 @@ export default function transform(source, dest, point) {
   if (source.projName === 'longlat') {
     point = {
       x: point.x * D2R,
-      y: point.y * D2R
+      y: point.y * D2R,
+      z: point.z || 0
     };
-  }
-  else {
+  } else {
     if (source.to_meter) {
       point = {
         x: point.x * source.to_meter,
-        y: point.y * source.to_meter
+        y: point.y * source.to_meter,
+        z: point.z || 0
       };
     }
     point = source.inverse(point); // Convert Cartesian to longlat
+    if (!point) {
+      return;
+    }
   }
   // Adjust for the prime meridian if necessary
   if (source.from_greenwich) {
@@ -53,7 +57,8 @@ export default function transform(source, dest, point) {
   if (dest.from_greenwich) {
     point = {
       x: point.x - dest.from_greenwich,
-      y: point.y
+      y: point.y,
+      z: point.z || 0
     };
   }
 
@@ -61,14 +66,16 @@ export default function transform(source, dest, point) {
     // convert radians to decimal degrees
     point = {
       x: point.x * R2D,
-      y: point.y * R2D
+      y: point.y * R2D,
+      z: point.z || 0
     };
   } else { // else project
     point = dest.forward(point);
     if (dest.to_meter) {
       point = {
         x: point.x / dest.to_meter,
-        y: point.y / dest.to_meter
+        y: point.y / dest.to_meter,
+        z: point.z || 0
       };
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proj4",
-  "version": "2.4.4",
+  "version": "2.6.2",
   "description": "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",
   "main": "dist/proj4-src.js",
   "module": "lib/index.js",
@@ -9,6 +9,7 @@
     "doc": "docs"
   },
   "scripts": {
+    "prepare": "grunt",
     "build": "grunt",
     "build:tmerc": "grunt build:tmerc",
     "test": "npm run build && istanbul test _mocha test/test.js"
@@ -20,24 +21,25 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "chai": "~1.8.1",
-    "curl": "git://github.com/cujojs/curl.git",
+    "chai": "~4.1.2",
+    "curl-amd": "github:cujojs/curl",
     "grunt": "^1.0.1",
-    "grunt-cli": "~0.1.13",
-    "grunt-contrib-connect": "~0.6.0",
+    "grunt-cli": "~1.2.0",
+    "grunt-contrib-connect": "~1.0.2",
     "grunt-contrib-jshint": "~1.1.0",
-    "grunt-contrib-uglify": "~0.11.1",
-    "grunt-mocha-phantomjs": "~0.4.0",
-    "grunt-rollup": "^1.0.1",
-    "istanbul": "~0.2.4",
-    "mocha": "~1.17.1",
-    "rollup": "^0.41.4",
-    "rollup-plugin-json": "^2.0.1",
-    "rollup-plugin-node-resolve": "^2.0.0",
-    "tin": "~0.4.0"
+    "grunt-contrib-uglify": "~3.1.0",
+    "grunt-mocha-phantomjs": "~4.0.0",
+    "grunt-rollup": "^6.0.0",
+    "istanbul": "~0.4.5",
+    "mocha": "~4.0.0",
+    "rollup": "^0.50.0",
+    "rollup-plugin-json": "^2.3.0",
+    "rollup-plugin-node-resolve": "^3.0.0",
+    "rollup-plugin-replace": "^2.0.0",
+    "tin": "~0.5.0"
   },
   "dependencies": {
     "mgrs": "1.0.0",
-    "wkt-parser": "^1.2.0"
+    "wkt-parser": "^1.2.4"
   }
 }

package/projs.js

@@ -23,6 +23,8 @@ import vandg from './lib/projections/vandg';
 import aeqd from './lib/projections/aeqd';
 import ortho from './lib/projections/ortho';
 import qsc from './lib/projections/qsc';
+import robin from './lib/projections/robin';
+import geocent from './lib/projections/geocent';
 export default function(proj4){
   proj4.Proj.projections.add(tmerc);
   proj4.Proj.projections.add(etmerc);
@@ -49,4 +51,6 @@ export default function(proj4){
   proj4.Proj.projections.add(aeqd);
   proj4.Proj.projections.add(ortho);
   proj4.Proj.projections.add(qsc);
+  proj4.Proj.projections.add(robin);
+  proj4.Proj.projections.add(geocent);
 }

package/test/test.js

@@ -122,6 +122,10 @@ function startTests(chai, proj4, testPoints) {
                 x: testPoint.xy[0],
                 y: testPoint.xy[1]
               };
+              // in case of geocentric proj we need Z value.
+              if (typeof testPoint.xy[2] === 'number') {
+                pt.z = testPoint.xy[2]
+              }
               var ll = proj4(testPoint.code, proj4.WGS84, pt);
               assert.closeTo(ll.x, testPoint.ll[0], llEPSLN, 'x is close');
               assert.closeTo(ll.y, testPoint.ll[1], llEPSLN, 'y is close');
@@ -167,42 +171,99 @@ function startTests(chai, proj4, testPoints) {
       });
     });
     describe('points', function () {
-      it('should ignore stuff it does not know', function (){
+      it('should ignore stuff it does not know', function () {
+        var sweref99tm = '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs';
+        var rt90 = '+lon_0=15.808277777799999 +lat_0=0.0 +k=1.0 +x_0=1500000.0 +y_0=0.0 +proj=tmerc +ellps=bessel +units=m +towgs84=414.1,41.3,603.1,-0.855,2.141,-7.023,0 +no_defs';
+        var rslt = proj4(sweref99tm, rt90).forward({
+          x: 319180,
+          y: 6399862,
+          z: 0,
+          m: 1000,
+          method: function () {
+            return 'correct answer';
+          }
+        });
+        assert.closeTo(rslt.x, 1271137.9275601401, 0.000001);
+        assert.closeTo(rslt.y, 6404230.291459564, 0.000001);
+        assert.equal(rslt.z, 0);
+        assert.equal(rslt.m, 1000);
+        assert.equal(rslt.method(), 'correct answer');
+      });
+      it('should be able to compute X Y Z M in geocenteric coordinates', function () {
+        var epsg4978 = '+proj=geocent +datum=WGS84 +units=m +no_defs';
+        var rslt = proj4(epsg4978).forward({
+          x: -7.76166,
+          y: 39.19685,
+          z: 0,
+          m: 1000,
+          method: function () {
+            return 'correct answer';
+          }
+        });
+        assert.closeTo(rslt.x, 4904199.584207411, 0.000001);
+        assert.closeTo(rslt.y, -668448.8153664203, 0.000001);
+        assert.closeTo(rslt.z, 4009276.930771821, 0.000001);
+        assert.equal(rslt.m, 1000);
+        assert.equal(rslt.method(), 'correct answer');
+      });
+    });
+    describe('points array', function () {
+      it('should ignore stuff it does not know', function () {
+        var sweref99tm = '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs';
+        var rt90 = '+lon_0=15.808277777799999 +lat_0=0.0 +k=1.0 +x_0=1500000.0 +y_0=0.0 +proj=tmerc +ellps=bessel +units=m +towgs84=414.1,41.3,603.1,-0.855,2.141,-7.023,0 +no_defs';
+        var rslt = proj4(sweref99tm, rt90).forward([
+          319180,
+          6399862,
+          0,
+          1000,
+        ]);
+        assert.closeTo(rslt[0], 1271137.9275601401, 0.000001);
+        assert.closeTo(rslt[1], 6404230.291459564, 0.000001);
+        assert.equal(rslt[2], 0);
+        assert.equal(rslt[3], 1000);
+      });
+      it('should be able to compute X Y Z M in geocenteric coordinates', function () {
+        var epsg4978 = '+proj=geocent +datum=WGS84 +units=m +no_defs';
+        var rslt = proj4(epsg4978).forward([
+          -7.76166,
+          39.19685,
+          0,
+          1000
+        ]);
+        assert.closeTo(rslt[0], 4904199.584207411, 0.000001);
+        assert.closeTo(rslt[1], -668448.8153664203, 0.000001);
+        assert.closeTo(rslt[2], 4009276.930771821, 0.000001);
+        assert.equal(rslt[3], 1000);
+      });
+    });
 
-          var sweref99tm = '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs';
-          var rt90 = '+lon_0=15.808277777799999 +lat_0=0.0 +k=1.0 +x_0=1500000.0 +y_0=0.0 +proj=tmerc +ellps=bessel +units=m +towgs84=414.1,41.3,603.1,-0.855,2.141,-7.023,0 +no_defs';
-          var rslt = proj4(sweref99tm, rt90).forward({
-            x: 319180,
-            y: 6399862,
-            z: 0,
-            m: 1000,
-            method: function () {
-              return 'correct answer';
-            }
-          });
-          assert.closeTo(rslt.x, 1271137.9275601401, 0.000001);
-          assert.closeTo(rslt.y, 6404230.291459564, 0.000001);
-          assert.equal(rslt.z, 0);
-          assert.equal(rslt.m, 1000);
-          assert.equal(rslt.method(), 'correct answer');
+    it('should use correct axis order', function() {
+      var enu = 'PROJCS["NAD83 / Massachusetts Mainland", GEOGCS["NAD83", DATUM["North American Datum 1983", SPHEROID["GRS 1980", 6378137.0, 298.257222101, AUTHORITY["EPSG","7019"]], TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], AUTHORITY["EPSG","6269"]], PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]], UNIT["degree", 0.017453292519943295], AXIS["Geodetic longitude", EAST], AXIS["Geodetic latitude", NORTH], AUTHORITY["EPSG","4269"]], PROJECTION["Lambert_Conformal_Conic_2SP", AUTHORITY["EPSG","9802"]], PARAMETER["central_meridian", -71.5], PARAMETER["latitude_of_origin", 41.0], PARAMETER["standard_parallel_1", 42.68333333333334], PARAMETER["false_easting", 200000.0], PARAMETER["false_northing", 750000.0], PARAMETER["scale_factor", 1.0], PARAMETER["standard_parallel_2", 41.71666666666667], UNIT["m", 1.0], AXIS["Easting", EAST], AXIS["Northing", NORTH], AUTHORITY["EPSG","26986"]]';
+      var neu = 'PROJCS["NAD83 / Massachusetts Mainland NE", GEOGCS["NAD83", DATUM["North American Datum 1983", SPHEROID["GRS 1980", 6378137.0, 298.257222101, AUTHORITY["EPSG","7019"]], TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], AUTHORITY["EPSG","6269"]], PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]], UNIT["degree", 0.017453292519943295], AXIS["Geodetic latitude", NORTH], AXIS["Geodetic longitude", EAST], AUTHORITY["EPSG","4269"]], PROJECTION["Lambert_Conformal_Conic_2SP", AUTHORITY["EPSG","9802"]], PARAMETER["central_meridian", -71.5], PARAMETER["latitude_of_origin", 41.0], PARAMETER["standard_parallel_1", 42.68333333333334], PARAMETER["false_easting", 200000.0], PARAMETER["false_northing", 750000.0], PARAMETER["scale_factor", 1.0], PARAMETER["standard_parallel_2", 41.71666666666667], UNIT["m", 1.0], AXIS["Northing", NORTH], AXIS["Easting", EAST], AUTHORITY["EPSG","26986"]]';
+      var rslt = proj4(enu, neu).forward({
+        x: 10.2,
+        y: 43.4
       });
+      assert.closeTo(rslt.x, 43.4, 0.000001);
+      assert.closeTo(rslt.y, 10.2, 0.000001);
     });
-    describe('defs', function() {
+
+    describe('defs', function () {
       assert.equal(proj4.defs('testmerc'), proj4.defs['testmerc']);
       proj4.defs('foo', '+proj=merc +lon_0=5.937 +lat_ts=45.027 +ellps=sphere');
       assert.typeOf(proj4.defs['foo'], 'object');
       proj4.defs('urn:x-ogc:def:crs:EPSG:4326', proj4.defs('EPSG:4326'));
       assert.strictEqual(proj4.defs['urn:x-ogc:def:crs:EPSG:4326'], proj4.defs['EPSG:4326']);
 
-      describe('wkt', function() {
-        it('should provide the correct conversion factor for WKT GEOGCS projections', function() {
+      describe('wkt', function () {
+        it('should provide the correct conversion factor for WKT GEOGCS projections', function () {
           proj4.defs('EPSG:4269', '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"]]');
-          assert.equal(proj4.defs['EPSG:4269'].to_meter, 6378137*0.01745329251994328);
+          assert.equal(proj4.defs['EPSG:4269'].to_meter, 6378137 * 0.01745329251994328);
 
           proj4.defs('EPSG:4279', 'GEOGCS["OS(SN)80",DATUM["OS_SN_1980",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]],AUTHORITY["EPSG","6279"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4279"]]');
-          assert.equal(proj4.defs['EPSG:4279'].to_meter, 6377563.396*0.01745329251994328);
+          assert.equal(proj4.defs['EPSG:4279'].to_meter, 6377563.396 * 0.01745329251994328);
         });
-        it('should parse wkt and proj4 of the same crs and result in the same params', function() {
+        it('should parse wkt and proj4 of the same crs and result in the same params', function () {
           var s1 = 'GEOGCS["PSD93",DATUM["PDO_Survey_Datum_1993",SPHEROID["Clarke 1880 (RGS)",6378249.145,293.465,AUTHORITY["EPSG","7012"]],TOWGS84[-180.624,-225.516,173.919,-0.81,-1.898,8.336,16.7101],AUTHORITY["EPSG","6134"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4134"]]';
           var s2 = '+proj=longlat +ellps=clrk80 +towgs84=-180.624,-225.516,173.919,-0.81,-1.898,8.336,16.7101 +no_defs';
           var crs1 = proj4(s1);