proj4 2.19.10 → 2.20.1-alpha

package/lib/projections/ob_tran.js

@@ -0,0 +1,347 @@
+import adjust_lon from '../common/adjust_lon';
+import { D2R, HALF_PI, EPSLN } from '../constants/values';
+import Proj from '../Proj';
+
+/**
+    Original projection implementation:
+        https://github.com/OSGeo/PROJ/blob/46c47e9adf6376ae06afabe5d24a0016a05ced82/src/projections/ob_tran.cpp
+
+    Documentation:
+        https://proj.org/operations/projections/ob_tran.html
+
+    References/Formulas:
+        https://pubs.usgs.gov/pp/1395/report.pdf
+
+    Examples:
+        +proj=ob_tran +o_proj=moll +o_lat_p=45 +o_lon_p=-90
+        +proj=ob_tran +o_proj=moll +o_lat_p=45 +o_lon_p=-90 +lon_0=60
+        +proj=ob_tran +o_proj=moll +o_lat_p=45 +o_lon_p=-90 +lon_0=-90
+*/
+
+const projectionType = {
+  OBLIQUE: {
+    forward: forwardOblique,
+    inverse: inverseOblique
+  },
+  TRANSVERSE: {
+    forward: forwardTransverse,
+    inverse: inverseTransverse
+  }
+};
+
+/**
+ * @typedef {Object} LocalThis
+ * @property {number} lamp
+ * @property {number} cphip
+ * @property {number} sphip
+ * @property {Object} projectionType
+ * @property {string | undefined} o_proj
+ * @property {string | undefined} o_lon_p
+ * @property {string | undefined} o_lat_p
+ * @property {string | undefined} o_alpha
+ * @property {string | undefined} o_lon_c
+ * @property {string | undefined} o_lat_c
+ * @property {string | undefined} o_lon_1
+ * @property {string | undefined} o_lat_1
+ * @property {string | undefined} o_lon_2
+ * @property {string | undefined} o_lat_2
+ * @property {number | undefined} oLongP
+ * @property {number | undefined} oLatP
+ * @property {number | undefined} oAlpha
+ * @property {number | undefined} oLongC
+ * @property {number | undefined} oLatC
+ * @property {number | undefined} oLong1
+ * @property {number | undefined} oLat1
+ * @property {number | undefined} oLong2
+ * @property {number | undefined} oLat2
+ * @property {import('..').Converter} obliqueProjection
+ *
+ */
+
+/**
+ *    Parameters can be from the following sets:
+ *       New pole --> o_lat_p, o_lon_p
+ *       Rotate about point --> o_alpha, o_lon_c, o_lat_c
+ *       New equator points --> lon_1, lat_1, lon_2, lat_2
+ *
+ *    Per the original source code, the parameter sets are
+ *    checked in the order of the object below.
+ */
+const paramSets = {
+  ROTATE: {
+    o_alpha: 'oAlpha',
+    o_lon_c: 'oLongC',
+    o_lat_c: 'oLatC'
+  },
+  NEW_POLE: {
+    o_lat_p: 'oLatP',
+    o_lon_p: 'oLongP'
+  },
+  NEW_EQUATOR: {
+    o_lon_1: 'oLong1',
+    o_lat_1: 'oLat1',
+    o_lon_2: 'oLong2',
+    o_lat_2: 'oLat2'
+  }
+};
+
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
+export function init() {
+  this.x0 = this.x0 || 0;
+  this.y0 = this.y0 || 0;
+  this.long0 = this.long0 || 0;
+  this.title = this.title || 'General Oblique Transformation';
+
+  /** Verify required parameters exist */
+  if (!this.o_proj) {
+    throw new Error('Missing parameter: o_proj');
+  }
+
+  if (this.o_proj === `ob_tran`) {
+    throw new Error('Invalid value for o_proj: ' + this.o_proj);
+  }
+
+  const newProjStr = this.projStr.replace('+proj=ob_tran', '').replace('+o_proj=', '+proj=').trim();
+
+  /** @type {import('../defs.js').ProjectionDefinition} */
+  const oProj = Proj(newProjStr);
+  if (!oProj) {
+    throw new Error('Invalid parameter: o_proj. Unknown projection ' + this.o_proj);
+  }
+  oProj.long0 = 0; // we handle long0 before/after forward/inverse
+  this.obliqueProjection = oProj;
+
+  let matchedSet;
+  const paramSetsKeys = Object.keys(paramSets);
+
+  /**
+   * parse strings, convert to radians, throw on NaN
+   * @param {string} name
+   * @returns {number | undefined}
+   */
+  const parseParam = (name) => {
+    if (typeof this[name] === `undefined`) {
+      return undefined;
+    }
+    const val = parseFloat(this[name]) * D2R;
+    if (isNaN(val)) {
+      throw new Error('Invalid value for ' + name + ': ' + this[name]);
+    }
+    return val;
+  };
+
+  for (let i = 0; i < paramSetsKeys.length; i++) {
+    const setKey = paramSetsKeys[i];
+    const set = paramSets[setKey];
+    const params = Object.entries(set);
+    const setHasParams = params.some(
+      ([p]) => typeof this[p] !== 'undefined'
+    );
+    if (!setHasParams) {
+      continue;
+    }
+    matchedSet = set;
+    for (let ii = 0; ii < params.length; ii++) {
+      const [inputParam, param] = params[ii];
+      const val = parseParam(inputParam);
+      if (typeof val === 'undefined') {
+        throw new Error('Missing parameter: ' + inputParam + '.');
+      }
+      this[param] = val;
+    }
+    break;
+  }
+
+  if (!matchedSet) {
+    throw new Error('No valid parameters provided for ob_tran projection.');
+  }
+
+  const { lamp, phip } = createRotation(this, matchedSet);
+  this.lamp = lamp;
+
+  if (Math.abs(phip) > EPSLN) {
+    this.cphip = Math.cos(phip);
+    this.sphip = Math.sin(phip);
+    this.projectionType = projectionType.OBLIQUE;
+  } else {
+    this.projectionType = projectionType.TRANSVERSE;
+  }
+}
+
+// ob_tran forward equations--mapping (lat,long) to (x,y)
+// transverse (90 degrees from normal orientation) - forwardTransverse
+// or oblique (arbitrary angle) used based on parameters - forwardOblique
+// -----------------------------------------------------------------
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
+export function forward(p) {
+  return this.projectionType.forward(this, p);
+}
+
+// inverse equations--mapping (x,y) to (lat,long)
+// transverse: inverseTransverse
+// oblique: inverseOblique
+// -----------------------------------------------------------------
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
+export function inverse(p) {
+  return this.projectionType.inverse(this, p);
+}
+
+/**
+ * @param {import('../defs.js').ProjectionDefinition & LocalThis} params - Initialized projection definition
+ * @param {Object} how - Transformation method
+ * @returns {{phip: number, lamp: number}}
+ */
+function createRotation(params, how) {
+  let phip, lamp;
+  if (how === paramSets.ROTATE) {
+    let lamc = params.oLongC;
+    let phic = params.oLatC;
+    let alpha = params.oAlpha;
+    if (Math.abs(Math.abs(phic) - HALF_PI) <= EPSLN) {
+      throw new Error('Invalid value for o_lat_c: ' + params.o_lat_c + ' should be < 90°');
+    }
+    lamp = lamc + Math.atan2(-1 * Math.cos(alpha), -1 * Math.sin(alpha) * Math.sin(phic));
+    phip = Math.asin(Math.cos(phic) * Math.sin(alpha));
+  } else if (how === paramSets.NEW_POLE) {
+    lamp = params.oLongP;
+    phip = params.oLatP;
+  } else {
+    let lam1 = params.oLong1;
+    let phi1 = params.oLat1;
+    let lam2 = params.oLong2;
+    let phi2 = params.oLat2;
+    let con = Math.abs(phi1);
+
+    if (Math.abs(phi1) > HALF_PI - EPSLN) {
+      throw new Error('Invalid value for o_lat_1: ' + params.o_lat_1 + ' should be < 90°');
+    }
+
+    if (Math.abs(phi2) > HALF_PI - EPSLN) {
+      throw new Error('Invalid value for o_lat_2: ' + params.o_lat_2 + ' should be < 90°');
+    }
+
+    if (Math.abs(phi1 - phi2) < EPSLN) {
+      throw new Error('Invalid value for o_lat_1 and o_lat_2: o_lat_1 should be different from o_lat_2');
+    }
+    if (con < EPSLN) {
+      throw new Error('Invalid value for o_lat_1: o_lat_1 should be different from zero');
+    }
+
+    lamp = Math.atan2(
+      (Math.cos(phi1) * Math.sin(phi2) * Math.cos(lam1))
+      - (Math.sin(phi1) * Math.cos(phi2) * Math.cos(lam2)),
+      (Math.sin(phi1) * Math.cos(phi2) * Math.sin(lam2))
+      - (Math.cos(phi1) * Math.sin(phi2) * Math.sin(lam1))
+    );
+
+    phip = Math.atan(-1 * Math.cos(lamp - lam1) / Math.tan(phi1));
+  }
+
+  return { lamp, phip };
+}
+
+/**
+ * Forward (lng, lat) to (x, y) for oblique case
+ * @param {import('../defs.js').ProjectionDefinition & LocalThis} self
+ * @param {{x: number, y: number}} lp - lambda, phi
+ */
+function forwardOblique(self, lp) {
+  let { x: lam, y: phi } = lp;
+  lam += self.long0;
+  const coslam = Math.cos(lam);
+  const sinphi = Math.sin(phi);
+  const cosphi = Math.cos(phi);
+
+  lp.x = adjust_lon(
+    Math.atan2(
+      cosphi * Math.sin(lam),
+      (self.sphip * cosphi * coslam) + (self.cphip * sinphi)
+    ) + self.lamp
+  );
+  lp.y = Math.asin(
+    (self.sphip * sinphi) - (self.cphip * cosphi * coslam)
+  );
+
+  return self.obliqueProjection.forward(lp);
+}
+
+/**
+ * Forward (lng, lat) to (x, y) for transverse case
+ * @param {import('../defs.js').ProjectionDefinition & LocalThis} self
+ * @param {{x: number, y: number}} lp - lambda, phi
+ */
+function forwardTransverse(self, lp) {
+  let { x: lam, y: phi } = lp;
+  lam += self.long0;
+  const cosphi = Math.cos(phi);
+  const coslam = Math.cos(lam);
+  lp.x = adjust_lon(
+    Math.atan2(
+      cosphi * Math.sin(lam),
+      Math.sin(phi)
+    ) + self.lamp
+  );
+  lp.y = Math.asin(-1 * cosphi * coslam);
+
+  return self.obliqueProjection.forward(lp);
+}
+
+/**
+ * Inverse (x, y) to (lng, lat) for oblique case
+ * @param {import('../defs.js').ProjectionDefinition & LocalThis} self
+ * @param {{x: number, y: number}} lp - lambda, phi
+ */
+function inverseOblique(self, lp) {
+  const innerLp = self.obliqueProjection.inverse(lp);
+  let { x: lam, y: phi } = innerLp;
+
+  if (lam < Number.MAX_VALUE) {
+    lam -= self.lamp;
+    const coslam = Math.cos(lam);
+    const sinphi = Math.sin(phi);
+    const cosphi = Math.cos(phi);
+    lp.x = Math.atan2(
+      cosphi * Math.sin(lam),
+      (self.sphip * cosphi * coslam) - (self.cphip * sinphi)
+    );
+    lp.y = Math.asin(
+      (self.sphip * sinphi) + (self.cphip * cosphi * coslam)
+    );
+  }
+
+  lp.x = adjust_lon(lp.x + self.long0);
+  return lp;
+}
+
+/**
+ * Inverse (x, y) to (lng, lat) for transverse case
+ * @param {import('../defs.js').ProjectionDefinition & LocalThis} self
+ * @param {{x: number, y: number}} lp - lambda, phi
+ */
+function inverseTransverse(self, lp) {
+  const innerLp = self.obliqueProjection.inverse(lp);
+  let { x: lam, y: phi } = innerLp;
+
+  if (lam < Number.MAX_VALUE) {
+    const cosphi = Math.cos(phi);
+    lam -= self.lamp;
+    lp.x = Math.atan2(
+      cosphi * Math.sin(lam),
+      -1 * Math.sin(phi)
+    );
+    lp.y = Math.asin(
+      cosphi * Math.cos(lam)
+    );
+  }
+
+  lp.x = adjust_lon(lp.x + self.long0);
+  return lp;
+}
+
+export var names = ['General Oblique Transformation', 'General_Oblique_Transformation', 'ob_tran'];
+export default {
+  init: init,
+  forward: forward,
+  inverse: inverse,
+  names: names
+};

package/lib/projections/omerc.js

@@ -138,8 +138,8 @@ export function init() {
       lam2 += TWO_PI;
     }
 
-    this.lam0 = adjust_lon(0.5 * (lam1 + lam2) - Math.atan(J * Math.tan(0.5 * this.B * (lam1 - lam2)) / p) / this.B);
-    gamma0 = Math.atan(2 * Math.sin(this.B * adjust_lon(lam1 - this.lam0)) / (F - 1 / F));
+    this.lam0 = adjust_lon(0.5 * (lam1 + lam2) - Math.atan(J * Math.tan(0.5 * this.B * (lam1 - lam2)) / p) / this.B, this.over);
+    gamma0 = Math.atan(2 * Math.sin(this.B * adjust_lon(lam1 - this.lam0, this.over)) / (F - 1 / F));
     gamma = alpha_c = Math.asin(D * Math.sin(gamma0));
   }
 

package/lib/projections/ortho.js

@@ -30,7 +30,7 @@ export function forward(p) {
   var lat = p.y;
   /* Forward equations
       ----------------- */
-  dlon = adjust_lon(lon - this.long0);
+  dlon = adjust_lon(lon - this.long0, this.over);
 
   sinphi = Math.sin(lat);
   cosphi = Math.cos(lat);
@@ -74,15 +74,15 @@ export function inverse(p) {
   con = Math.abs(this.lat0) - HALF_PI;
   if (Math.abs(con) <= EPSLN) {
     if (this.lat0 >= 0) {
-      lon = adjust_lon(this.long0 + Math.atan2(p.x, -p.y));
+      lon = adjust_lon(this.long0 + Math.atan2(p.x, -p.y), this.over);
     } else {
-      lon = adjust_lon(this.long0 - Math.atan2(-p.x, p.y));
+      lon = adjust_lon(this.long0 - Math.atan2(-p.x, p.y), this.over);
     }
     p.x = lon;
     p.y = lat;
     return p;
   }
-  lon = adjust_lon(this.long0 + Math.atan2((p.x * sinz), rh * this.cos_p14 * cosz - p.y * this.sin_p14 * sinz));
+  lon = adjust_lon(this.long0 + Math.atan2((p.x * sinz), rh * this.cos_p14 * cosz - p.y * this.sin_p14 * sinz), this.over);
   p.x = lon;
   p.y = lat;
   return p;

package/lib/projections/poly.js

@@ -43,7 +43,7 @@ export function forward(p) {
   var lon = p.x;
   var lat = p.y;
   var x, y, el;
-  var dlon = adjust_lon(lon - this.long0);
+  var dlon = adjust_lon(lon - this.long0, this.over);
   el = dlon * Math.sin(lat);
   if (this.sphere) {
     if (Math.abs(lat) <= EPSLN) {
@@ -79,7 +79,7 @@ export function inverse(p) {
 
   if (this.sphere) {
     if (Math.abs(y + this.a * this.lat0) <= EPSLN) {
-      lon = adjust_lon(x / this.a + this.long0);
+      lon = adjust_lon(x / this.a + this.long0, this.over);
       lat = 0;
     } else {
       al = this.lat0 + y / this.a;
@@ -95,12 +95,12 @@ export function inverse(p) {
           break;
         }
       }
-      lon = adjust_lon(this.long0 + (Math.asin(x * Math.tan(phi) / this.a)) / Math.sin(lat));
+      lon = adjust_lon(this.long0 + (Math.asin(x * Math.tan(phi) / this.a)) / Math.sin(lat), this.over);
     }
   } else {
     if (Math.abs(y + this.ml0) <= EPSLN) {
       lat = 0;
-      lon = adjust_lon(this.long0 + x / this.a);
+      lon = adjust_lon(this.long0 + x / this.a, this.over);
     } else {
       al = (this.ml0 + y) / this.a;
       bl = x * x / this.a / this.a + al * al;
@@ -123,7 +123,7 @@ export function inverse(p) {
 
       // lat=phi4z(this.e,this.e0,this.e1,this.e2,this.e3,al,bl,0,0);
       cl = Math.sqrt(1 - this.es * Math.pow(Math.sin(lat), 2)) * Math.tan(lat);
-      lon = adjust_lon(this.long0 + Math.asin(x * cl / this.a) / Math.sin(lat));
+      lon = adjust_lon(this.long0 + Math.asin(x * cl / this.a) / Math.sin(lat), this.over);
     }
   }
 

package/lib/projections/robin.js

@@ -84,7 +84,7 @@ export function init() {
 }
 
 export function forward(ll) {
-  var lon = adjust_lon(ll.x - this.long0);
+  var lon = adjust_lon(ll.x - this.long0, this.over);
 
   var dphi = Math.abs(ll.y);
   var i = Math.floor(dphi * C1);
@@ -148,7 +148,7 @@ export function inverse(xy) {
     }
   }
 
-  ll.x = adjust_lon(ll.x + this.long0);
+  ll.x = adjust_lon(ll.x + this.long0, this.over);
   return ll;
 }
 

package/lib/projections/sinu.js

@@ -42,7 +42,7 @@ export function forward(p) {
   var lat = p.y;
   /* Forward equations
     ----------------- */
-  lon = adjust_lon(lon - this.long0);
+  lon = adjust_lon(lon - this.long0, this.over);
 
   if (this.sphere) {
     if (!this.m) {
@@ -87,7 +87,7 @@ export function inverse(p) {
     } else if (this.n !== 1) {
       lat = asinz(Math.sin(lat) / this.n);
     }
-    lon = adjust_lon(lon + this.long0);
+    lon = adjust_lon(lon + this.long0, this.over);
     lat = adjust_lat(lat);
   } else {
     lat = pj_inv_mlfn(p.y / this.a, this.es, this.en);
@@ -96,7 +96,7 @@ export function inverse(p) {
       s = Math.sin(lat);
       temp = this.long0 + p.x * Math.sqrt(1 - this.es * s * s) / (this.a * Math.cos(lat));
       // temp = this.long0 + p.x / (this.a * Math.cos(lat));
-      lon = adjust_lon(temp);
+      lon = adjust_lon(temp, this.over);
     } else if ((s - EPSLN) < HALF_PI) {
       lon = this.long0;
     }

package/lib/projections/stere.js

@@ -70,7 +70,7 @@ export function forward(p) {
   var sinlat = Math.sin(lat);
   var coslat = Math.cos(lat);
   var A, X, sinX, cosX, ts, rh;
-  var dlon = adjust_lon(lon - this.long0);
+  var dlon = adjust_lon(lon - this.long0, this.over);
 
   if (Math.abs(Math.abs(lon - this.long0) - Math.PI) <= EPSLN && Math.abs(lat + this.lat0) <= EPSLN) {
     // case of the origine point
@@ -131,12 +131,12 @@ export function inverse(p) {
     lat = Math.asin(Math.cos(c) * this.sinlat0 + p.y * Math.sin(c) * this.coslat0 / rh);
     if (Math.abs(this.coslat0) < EPSLN) {
       if (this.lat0 > 0) {
-        lon = adjust_lon(this.long0 + Math.atan2(p.x, -1 * p.y));
+        lon = adjust_lon(this.long0 + Math.atan2(p.x, -1 * p.y), this.over);
       } else {
-        lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y));
+        lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y), this.over);
       }
     } else {
-      lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(c), rh * this.coslat0 * Math.cos(c) - p.y * this.sinlat0 * Math.sin(c)));
+      lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(c), rh * this.coslat0 * Math.cos(c) - p.y * this.sinlat0 * Math.sin(c)), this.over);
     }
     p.x = lon;
     p.y = lat;
@@ -155,7 +155,7 @@ export function inverse(p) {
       p.y *= this.con;
       ts = rh * this.cons / (2 * this.a * this.k0);
       lat = this.con * phi2z(this.e, ts);
-      lon = this.con * adjust_lon(this.con * this.long0 + Math.atan2(p.x, -1 * p.y));
+      lon = this.con * adjust_lon(this.con * this.long0 + Math.atan2(p.x, -1 * p.y), this.over);
     } else {
       ce = 2 * Math.atan(rh * this.cosX0 / (2 * this.a * this.k0 * this.ms1));
       lon = this.long0;
@@ -163,7 +163,7 @@ export function inverse(p) {
         Chi = this.X0;
       } else {
         Chi = Math.asin(Math.cos(ce) * this.sinX0 + p.y * Math.sin(ce) * this.cosX0 / rh);
-        lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(ce), rh * this.cosX0 * Math.cos(ce) - p.y * this.sinX0 * Math.sin(ce)));
+        lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(ce), rh * this.cosX0 * Math.cos(ce) - p.y * this.sinX0 * Math.sin(ce)), this.over);
       }
       lat = -1 * phi2z(this.e, Math.tan(0.5 * (HALF_PI + Chi)));
     }

package/lib/projections/sterea.js

@@ -27,7 +27,7 @@ export function init() {
 
 export function forward(p) {
   var sinc, cosc, cosl, k;
-  p.x = adjust_lon(p.x - this.long0);
+  p.x = adjust_lon(p.x - this.long0, this.over);
   gauss.forward.apply(this, [p]);
   sinc = Math.sin(p.y);
   cosc = Math.cos(p.y);
@@ -61,7 +61,7 @@ export function inverse(p) {
   p.x = lon;
   p.y = lat;
   gauss.inverse.apply(this, [p]);
-  p.x = adjust_lon(p.x + this.long0);
+  p.x = adjust_lon(p.x + this.long0, this.over);
   return p;
 }
 

package/lib/projections/tmerc.js

@@ -37,7 +37,7 @@ export function forward(p) {
   var lon = p.x;
   var lat = p.y;
 
-  var delta_lon = adjust_lon(lon - this.long0);
+  var delta_lon = adjust_lon(lon - this.long0, this.over);
   var con;
   var x, y;
   var sin_phi = Math.sin(lat);
@@ -125,7 +125,7 @@ export function inverse(p) {
     if ((g === 0) && (h === 0)) {
       lon = 0;
     } else {
-      lon = adjust_lon(Math.atan2(g, h) + this.long0);
+      lon = adjust_lon(Math.atan2(g, h) + this.long0, this.over);
     }
   } else { // ellipsoidal form
     con = this.ml0 + y / this.k0;
@@ -152,7 +152,7 @@ export function inverse(p) {
       lon = adjust_lon(this.long0 + (d * (1
         - ds / 6 * (1 + 2 * t + c
           - ds / 20 * (5 + 28 * t + 24 * ts + 8 * c * t + 6 * c
-            - ds / 42 * (61 + 662 * t + 1320 * ts + 720 * ts * t)))) / cos_phi));
+            - ds / 42 * (61 + 662 * t + 1320 * ts + 720 * ts * t)))) / cos_phi), this.over);
     } else {
       lat = HALF_PI * sign(y);
       lon = 0;

package/lib/projections/vandg.js

@@ -24,7 +24,7 @@ export function forward(p) {
 
   /* Forward equations
     ----------------- */
-  var dlon = adjust_lon(lon - this.long0);
+  var dlon = adjust_lon(lon - this.long0, this.over);
   var x, y;
 
   if (Math.abs(lat) <= EPSLN) {
@@ -113,7 +113,7 @@ export function inverse(p) {
   if (Math.abs(xx) < EPSLN) {
     lon = this.long0;
   } else {
-    lon = adjust_lon(this.long0 + Math.PI * (xys - 1 + Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys)) / 2 / xx);
+    lon = adjust_lon(this.long0 + Math.PI * (xys - 1 + Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys)) / 2 / xx, this.over);
   }
 
   p.x = lon;

package/package.json

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

package/projs.js

@@ -29,6 +29,7 @@ import tpers from './lib/projections/tpers';
 import geos from './lib/projections/geos';
 import eqearth from './lib/projections/eqearth';
 import bonne from './lib/projections/bonne';
+import ob_tran from './lib/projections/ob_tran';
 export default function (proj4) {
   proj4.Proj.projections.add(tmerc);
   proj4.Proj.projections.add(etmerc);
@@ -61,4 +62,5 @@ export default function (proj4) {
   proj4.Proj.projections.add(geos);
   proj4.Proj.projections.add(eqearth);
   proj4.Proj.projections.add(bonne);
+  proj4.Proj.projections.add(ob_tran);
 }