proj4 2.15.0 → 2.16.1

package/lib/projections/mill.js

@@ -6,20 +6,19 @@ import adjust_lon from '../common/adjust_lon';
     The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
   */
 
-
 /* Initialize the Miller Cylindrical projection
-  -------------------------------------------*/
+  ------------------------------------------- */
 export function init() {
-  //no-op
+  // no-op
 }
 
 /* Miller Cylindrical forward equations--mapping lat,long to x,y
-    ------------------------------------------------------------*/
+    ------------------------------------------------------------ */
 export function forward(p) {
   var lon = p.x;
   var lat = p.y;
   /* Forward equations
-      -----------------*/
+      ----------------- */
   var dlon = adjust_lon(lon - this.long0);
   var x = this.x0 + this.a * dlon;
   var y = this.y0 + this.a * Math.log(Math.tan((Math.PI / 4) + (lat / 2.5))) * 1.25;
@@ -30,7 +29,7 @@ export function forward(p) {
 }
 
 /* Miller Cylindrical inverse equations--mapping x,y to lat/long
-    ------------------------------------------------------------*/
+    ------------------------------------------------------------ */
 export function inverse(p) {
   p.x -= this.x0;
   p.y -= this.y0;
@@ -43,7 +42,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["Miller_Cylindrical", "mill"];
+export var names = ['Miller_Cylindrical', 'mill'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/moll.js

@@ -1,12 +1,11 @@
 import adjust_lon from '../common/adjust_lon';
 export function init() {}
-import {EPSLN} from '../constants/values';
+import { EPSLN } from '../constants/values';
 /* Mollweide forward equations--mapping lat,long to x,y
-    ----------------------------------------------------*/
+    ---------------------------------------------------- */
 export function forward(p) {
-
   /* Forward equations
-      -----------------*/
+      ----------------- */
   var lon = p.x;
   var lat = p.y;
 
@@ -15,7 +14,7 @@ export function forward(p) {
   var con = Math.PI * Math.sin(lat);
 
   /* Iterate using the Newton-Raphson method to find theta
-      -----------------------------------------------------*/
+      ----------------------------------------------------- */
   while (true) {
     var delta_theta = -(theta + Math.sin(theta) - con) / (1 + Math.cos(theta));
     theta += delta_theta;
@@ -27,7 +26,7 @@ export function forward(p) {
 
   /* If the latitude is 90 deg, force the x coordinate to be "0 + false easting"
        this is done here because of precision problems with "cos(theta)"
-       --------------------------------------------------------------------------*/
+       -------------------------------------------------------------------------- */
   if (Math.PI / 2 - Math.abs(lat) < EPSLN) {
     delta_lon = 0;
   }
@@ -44,14 +43,14 @@ export function inverse(p) {
   var arg;
 
   /* Inverse equations
-      -----------------*/
+      ----------------- */
   p.x -= this.x0;
   p.y -= this.y0;
   arg = p.y / (1.4142135623731 * this.a);
 
   /* Because of division by zero problems, 'arg' can not be 1.  Therefore
        a number very close to one is used instead.
-       -------------------------------------------------------------------*/
+       ------------------------------------------------------------------- */
   if (Math.abs(arg) > 0.999999999999) {
     arg = 0.999999999999;
   }
@@ -74,7 +73,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["Mollweide", "moll"];
+export var names = ['Mollweide', 'moll'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/nzmg.js

@@ -1,4 +1,4 @@
-import {SEC_TO_RAD} from '../constants/values';
+import { SEC_TO_RAD } from '../constants/values';
 
 /*
   reference
@@ -217,7 +217,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["New_Zealand_Map_Grid", "nzmg"];
+export var names = ['New_Zealand_Map_Grid', 'nzmg'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/omerc.js

@@ -1,47 +1,47 @@
 import tsfnz from '../common/tsfnz';
 import adjust_lon from '../common/adjust_lon';
 import phi2z from '../common/phi2z';
-import { D2R, EPSLN, HALF_PI, TWO_PI, FORTPI } from '../constants/values';
+import { EPSLN, HALF_PI, TWO_PI, FORTPI } from '../constants/values';
+import { getNormalizedProjName } from '../projections';
 
 var TOL = 1e-7;
 
 function isTypeA(P) {
-  var typeAProjections = ['Hotine_Oblique_Mercator','Hotine_Oblique_Mercator_Azimuth_Natural_Origin'];
-  var projectionName = typeof P.PROJECTION === "object" ? Object.keys(P.PROJECTION)[0] : P.PROJECTION;
-  
-  return 'no_uoff' in P || 'no_off' in P || typeAProjections.indexOf(projectionName) !== -1;
-}
+  var typeAProjections = ['Hotine_Oblique_Mercator', 'Hotine_Oblique_Mercator_variant_A', 'Hotine_Oblique_Mercator_Azimuth_Natural_Origin'];
+  var projectionName = typeof P.projName === 'object' ? Object.keys(P.projName)[0] : P.projName;
 
+  return 'no_uoff' in P || 'no_off' in P || typeAProjections.indexOf(projectionName) !== -1 || typeAProjections.indexOf(getNormalizedProjName(projectionName)) !== -1;
+}
 
 /* Initialize the Oblique Mercator  projection
-    ------------------------------------------*/
-export function init() {  
+    ------------------------------------------ */
+export function init() {
   var con, com, cosph0, D, F, H, L, sinph0, p, J, gamma = 0,
-    gamma0, lamc = 0, lam1 = 0, lam2 = 0, phi1 = 0, phi2 = 0, alpha_c = 0, AB;
-  
+    gamma0, lamc = 0, lam1 = 0, lam2 = 0, phi1 = 0, phi2 = 0, alpha_c = 0;
+
   // only Type A uses the no_off or no_uoff property
   // https://github.com/OSGeo/proj.4/issues/104
   this.no_off = isTypeA(this);
   this.no_rot = 'no_rot' in this;
-  
+
   var alp = false;
-  if ("alpha" in this) {
+  if ('alpha' in this) {
     alp = true;
   }
 
   var gam = false;
-  if ("rectified_grid_angle" in this) {
+  if ('rectified_grid_angle' in this) {
     gam = true;
   }
 
   if (alp) {
     alpha_c = this.alpha;
   }
-  
+
   if (gam) {
-    gamma = (this.rectified_grid_angle * D2R);
+    gamma = this.rectified_grid_angle;
   }
-  
+
   if (alp || gam) {
     lamc = this.longc;
   } else {
@@ -49,17 +49,17 @@ export function init() {
     phi1 = this.lat1;
     lam2 = this.long2;
     phi2 = this.lat2;
-    
-    if (Math.abs(phi1 - phi2) <= TOL || (con = Math.abs(phi1)) <= TOL ||
-        Math.abs(con - HALF_PI) <= TOL || Math.abs(Math.abs(this.lat0) - HALF_PI) <= TOL ||
-        Math.abs(Math.abs(phi2) - HALF_PI) <= TOL) {
+
+    if (Math.abs(phi1 - phi2) <= TOL || (con = Math.abs(phi1)) <= TOL
+      || Math.abs(con - HALF_PI) <= TOL || Math.abs(Math.abs(this.lat0) - HALF_PI) <= TOL
+      || Math.abs(Math.abs(phi2) - HALF_PI) <= TOL) {
       throw new Error();
     }
   }
-  
+
   var one_es = 1.0 - this.es;
   com = Math.sqrt(one_es);
-  
+
   if (Math.abs(this.lat0) > EPSLN) {
     sinph0 = Math.sin(this.lat0);
     cosph0 = Math.cos(this.lat0);
@@ -68,8 +68,8 @@ export function init() {
     this.B = Math.sqrt(1 + this.es * this.B * this.B / one_es);
     this.A = this.B * this.k0 * com / con;
     D = this.B * com / (cosph0 * Math.sqrt(con));
-    F = D * D -1;
-    
+    F = D * D - 1;
+
     if (F <= 0) {
       F = 0;
     } else {
@@ -78,7 +78,7 @@ export function init() {
         F = -F;
       }
     }
-    
+
     this.E = F += D;
     this.E *= Math.pow(tsfnz(this.e, this.lat0, sinph0), this.B);
   } else {
@@ -86,7 +86,7 @@ export function init() {
     this.A = this.k0;
     this.E = D = F = 1;
   }
-  
+
   if (alp || gam) {
     if (alp) {
       gamma0 = Math.asin(Math.sin(alpha_c) / D);
@@ -106,77 +106,75 @@ export function init() {
     J = this.E * this.E;
     J = (J - L * H) / (J + L * H);
     con = lam1 - lam2;
-    
+
     if (con < -Math.pi) {
-      lam2 -=TWO_PI;
+      lam2 -= TWO_PI;
     } else if (con > Math.pi) {
       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));
     gamma = alpha_c = Math.asin(D * Math.sin(gamma0));
   }
-  
+
   this.singam = Math.sin(gamma0);
   this.cosgam = Math.cos(gamma0);
   this.sinrot = Math.sin(gamma);
   this.cosrot = Math.cos(gamma);
-  
+
   this.rB = 1 / this.B;
   this.ArB = this.A * this.rB;
   this.BrA = 1 / this.ArB;
-  AB = this.A * this.B;
-  
+
   if (this.no_off) {
     this.u_0 = 0;
   } else {
     this.u_0 = Math.abs(this.ArB * Math.atan(Math.sqrt(D * D - 1) / Math.cos(alpha_c)));
-    
+
     if (this.lat0 < 0) {
-      this.u_0 = - this.u_0;
-    }  
+      this.u_0 = -this.u_0;
+    }
   }
-    
+
   F = 0.5 * gamma0;
   this.v_pole_n = this.ArB * Math.log(Math.tan(FORTPI - F));
   this.v_pole_s = this.ArB * Math.log(Math.tan(FORTPI + F));
 }
 
-
 /* Oblique Mercator forward equations--mapping lat,long to x,y
-    ----------------------------------------------------------*/
+    ---------------------------------------------------------- */
 export function forward(p) {
   var coords = {};
   var S, T, U, V, W, temp, u, v;
   p.x = p.x - this.lam0;
-  
+
   if (Math.abs(Math.abs(p.y) - HALF_PI) > EPSLN) {
     W = this.E / Math.pow(tsfnz(this.e, p.y, Math.sin(p.y)), this.B);
-    
+
     temp = 1 / W;
     S = 0.5 * (W - temp);
     T = 0.5 * (W + temp);
     V = Math.sin(this.B * p.x);
     U = (S * this.singam - V * this.cosgam) / T;
-        
+
     if (Math.abs(Math.abs(U) - 1.0) < EPSLN) {
       throw new Error();
     }
-    
-    v = 0.5 * this.ArB * Math.log((1 - U)/(1 + U));
+
+    v = 0.5 * this.ArB * Math.log((1 - U) / (1 + U));
     temp = Math.cos(this.B * p.x);
-    
+
     if (Math.abs(temp) < TOL) {
       u = this.A * p.x;
     } else {
       u = this.ArB * Math.atan2((S * this.cosgam + V * this.singam), temp);
-    }    
+    }
   } else {
     v = p.y > 0 ? this.v_pole_n : this.v_pole_s;
     u = this.ArB * p.y;
   }
-     
+
   if (this.no_rot) {
     coords.x = u;
     coords.y = v;
@@ -185,17 +183,17 @@ export function forward(p) {
     coords.x = v * this.cosrot + u * this.sinrot;
     coords.y = u * this.cosrot - v * this.sinrot;
   }
-  
+
   coords.x = (this.a * coords.x + this.x0);
   coords.y = (this.a * coords.y + this.y0);
-  
+
   return coords;
 }
 
 export function inverse(p) {
   var u, v, Qp, Sp, Tp, Vp, Up;
   var coords = {};
-  
+
   p.x = (p.x - this.x0) * (1.0 / this.a);
   p.y = (p.y - this.y0) * (1.0 / this.a);
 
@@ -206,33 +204,33 @@ export function inverse(p) {
     v = p.x * this.cosrot - p.y * this.sinrot;
     u = p.y * this.cosrot + p.x * this.sinrot + this.u_0;
   }
-  
+
   Qp = Math.exp(-this.BrA * v);
   Sp = 0.5 * (Qp - 1 / Qp);
   Tp = 0.5 * (Qp + 1 / Qp);
   Vp = Math.sin(this.BrA * u);
   Up = (Vp * this.cosgam + Sp * this.singam) / Tp;
-  
+
   if (Math.abs(Math.abs(Up) - 1) < EPSLN) {
     coords.x = 0;
     coords.y = Up < 0 ? -HALF_PI : HALF_PI;
   } else {
     coords.y = this.E / Math.sqrt((1 + Up) / (1 - Up));
     coords.y = phi2z(this.e, Math.pow(coords.y, 1 / this.B));
-    
+
     if (coords.y === Infinity) {
       throw new Error();
     }
-        
+
     coords.x = -this.rB * Math.atan2((Sp * this.cosgam - Vp * this.singam), Math.cos(this.BrA * u));
   }
-  
+
   coords.x += this.lam0;
-  
+
   return coords;
 }
 
-export var names = ["Hotine_Oblique_Mercator", "Hotine Oblique Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin", "Hotine_Oblique_Mercator_Two_Point_Natural_Origin", "Hotine_Oblique_Mercator_Azimuth_Center", "Oblique_Mercator", "omerc"];
+export var names = ['Hotine_Oblique_Mercator', 'Hotine Oblique Mercator', 'Hotine_Oblique_Mercator_variant_A', 'Hotine_Oblique_Mercator_Variant_B', 'Hotine_Oblique_Mercator_Azimuth_Natural_Origin', 'Hotine_Oblique_Mercator_Two_Point_Natural_Origin', 'Hotine_Oblique_Mercator_Azimuth_Center', 'Oblique_Mercator', 'omerc'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/ortho.js

@@ -1,18 +1,18 @@
 import adjust_lon from '../common/adjust_lon';
 import asinz from '../common/asinz';
-import {EPSLN, HALF_PI} from '../constants/values';
+import { EPSLN, HALF_PI } from '../constants/values';
 
 export function init() {
-  //double temp;      /* temporary variable    */
+  // double temp;      /* temporary variable    */
 
   /* Place parameters in static storage for common use
-      -------------------------------------------------*/
+      ------------------------------------------------- */
   this.sin_p14 = Math.sin(this.lat0);
   this.cos_p14 = Math.cos(this.lat0);
 }
 
 /* Orthographic forward equations--mapping lat,long to x,y
-    ---------------------------------------------------*/
+    --------------------------------------------------- */
 export function forward(p) {
   var sinphi, cosphi; /* sin and cos value        */
   var dlon; /* delta longitude value      */
@@ -22,7 +22,7 @@ export function forward(p) {
   var lon = p.x;
   var lat = p.y;
   /* Forward equations
-      -----------------*/
+      ----------------- */
   dlon = adjust_lon(lon - this.long0);
 
   sinphi = Math.sin(lat);
@@ -47,7 +47,7 @@ export function inverse(p) {
   var con;
   var lon, lat;
   /* Inverse equations
-      -----------------*/
+      ----------------- */
   p.x -= this.x0;
   p.y -= this.y0;
   rh = Math.sqrt(p.x * p.x + p.y * p.y);
@@ -67,9 +67,8 @@ 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));
-    }
-    else {
+      lon = adjust_lon(this.long0 + Math.atan2(p.x, -p.y));
+    } else {
       lon = adjust_lon(this.long0 - Math.atan2(-p.x, p.y));
     }
     p.x = lon;
@@ -82,7 +81,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["ortho"];
+export var names = ['ortho'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/poly.js

@@ -5,14 +5,14 @@ import e3fn from '../common/e3fn';
 import adjust_lon from '../common/adjust_lon';
 import adjust_lat from '../common/adjust_lat';
 import mlfn from '../common/mlfn';
-import {EPSLN} from '../constants/values';
+import { EPSLN } from '../constants/values';
 
 import gN from '../common/gN';
 var MAX_ITER = 20;
 
 export function init() {
   /* Place parameters in static storage for common use
-      -------------------------------------------------*/
+      ------------------------------------------------- */
   this.temp = this.b / this.a;
   this.es = 1 - Math.pow(this.temp, 2); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles
   this.e = Math.sqrt(this.es);
@@ -20,11 +20,11 @@ export function init() {
   this.e1 = e1fn(this.es);
   this.e2 = e2fn(this.es);
   this.e3 = e3fn(this.es);
-  this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0); //si que des zeros le calcul ne se fait pas
+  this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0); // si que des zeros le calcul ne se fait pas
 }
 
 /* Polyconic forward equations--mapping lat,long to x,y
-    ---------------------------------------------------*/
+    --------------------------------------------------- */
 export function forward(p) {
   var lon = p.x;
   var lat = p.y;
@@ -35,23 +35,19 @@ export function forward(p) {
     if (Math.abs(lat) <= EPSLN) {
       x = this.a * dlon;
       y = -1 * this.a * this.lat0;
-    }
-    else {
+    } else {
       x = this.a * Math.sin(el) / Math.tan(lat);
       y = this.a * (adjust_lat(lat - this.lat0) + (1 - Math.cos(el)) / Math.tan(lat));
     }
-  }
-  else {
+  } else {
     if (Math.abs(lat) <= EPSLN) {
       x = this.a * dlon;
       y = -1 * this.ml0;
-    }
-    else {
+    } else {
       var nl = gN(this.a, this.e, Math.sin(lat)) / Math.tan(lat);
       x = nl * Math.sin(el);
       y = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, lat) - this.ml0 + nl * (1 - Math.cos(el));
     }
-
   }
   p.x = x + this.x0;
   p.y = y + this.y0;
@@ -59,7 +55,7 @@ export function forward(p) {
 }
 
 /* Inverse equations
-  -----------------*/
+  ----------------- */
 export function inverse(p) {
   var lon, lat, x, y, i;
   var al, bl;
@@ -71,8 +67,7 @@ export function inverse(p) {
     if (Math.abs(y + this.a * this.lat0) <= EPSLN) {
       lon = adjust_lon(x / this.a + this.long0);
       lat = 0;
-    }
-    else {
+    } else {
       al = this.lat0 + y / this.a;
       bl = x * x / this.a / this.a + al * al;
       phi = al;
@@ -88,14 +83,11 @@ export function inverse(p) {
       }
       lon = adjust_lon(this.long0 + (Math.asin(x * Math.tan(phi) / this.a)) / Math.sin(lat));
     }
-  }
-  else {
+  } else {
     if (Math.abs(y + this.ml0) <= EPSLN) {
       lat = 0;
       lon = adjust_lon(this.long0 + x / this.a);
-    }
-    else {
-
+    } else {
       al = (this.ml0 + y) / this.a;
       bl = x * x / this.a / this.a + al * al;
       phi = al;
@@ -115,7 +107,7 @@ export function inverse(p) {
         }
       }
 
-      //lat=phi4z(this.e,this.e0,this.e1,this.e2,this.e3,al,bl,0,0);
+      // 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));
     }
@@ -126,7 +118,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["Polyconic", "poly"];
+export var names = ['Polyconic', 'American_Polyconic', 'poly'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/qsc.js

@@ -1,33 +1,32 @@
 // QSC projection rewritten from the original PROJ4
 // https://github.com/OSGeo/proj.4/blob/master/src/PJ_qsc.c
 
-import {EPSLN, TWO_PI, SPI, HALF_PI, FORTPI} from '../constants/values';
+import { EPSLN, TWO_PI, SPI, HALF_PI, FORTPI } from '../constants/values';
 
 /* constants */
 var FACE_ENUM = {
-    FRONT: 1,
-    RIGHT: 2,
-    BACK: 3,
-    LEFT: 4,
-    TOP: 5,
-    BOTTOM: 6
+  FRONT: 1,
+  RIGHT: 2,
+  BACK: 3,
+  LEFT: 4,
+  TOP: 5,
+  BOTTOM: 6
 };
 
 var AREA_ENUM = {
-    AREA_0: 1,
-    AREA_1: 2,
-    AREA_2: 3,
-    AREA_3: 4
+  AREA_0: 1,
+  AREA_1: 2,
+  AREA_2: 3,
+  AREA_3: 4
 };
 
 export function init() {
-
   this.x0 = this.x0 || 0;
   this.y0 = this.y0 || 0;
   this.lat0 = this.lat0 || 0;
   this.long0 = this.long0 || 0;
   this.lat_ts = this.lat_ts || 0;
-  this.title = this.title || "Quadrilateralized Spherical Cube";
+  this.title = this.title || 'Quadrilateralized Spherical Cube';
 
   /* Determine the cube face from the center of projection. */
   if (this.lat0 >= HALF_PI - FORTPI / 2.0) {
@@ -53,12 +52,12 @@ export function init() {
 // QSC forward equations--mapping lat,long to x,y
 // -----------------------------------------------------------------
 export function forward(p) {
-  var xy = {x: 0, y: 0};
+  var xy = { x: 0, y: 0 };
   var lat, lon;
   var theta, phi;
   var t, mu;
   /* nu; */
-  var area = {value: 0};
+  var area = { value: 0 };
 
   // move lon according to projection's lon
   p.x -= this.long0;
@@ -66,7 +65,7 @@ export function forward(p) {
   /* Convert the geodetic latitude to a geocentric latitude.
    * This corresponds to the shift from the ellipsoid to the sphere
    * described in [LK12]. */
-  if (this.es !== 0) {//if (P->es != 0) {
+  if (this.es !== 0) { // if (P->es != 0) {
     lat = Math.atan(this.one_minus_f_squared * Math.tan(p.y));
   } else {
     lat = p.y;
@@ -77,7 +76,7 @@ export function forward(p) {
    * For the top and bottom face, we can compute theta and phi
    * directly from phi, lam. For the other faces, we must use
    * unit sphere cartesian coordinates as an intermediate step. */
-  lon = p.x; //lon = lp.lam;
+  lon = p.x; // lon = lp.lam;
   if (this.face === FACE_ENUM.TOP) {
     phi = HALF_PI - lat;
     if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
@@ -176,11 +175,11 @@ export function forward(p) {
 // QSC inverse equations--mapping x,y to lat/long
 // -----------------------------------------------------------------
 export function inverse(p) {
-  var lp = {lam: 0, phi: 0};
+  var lp = { lam: 0, phi: 0 };
   var mu, nu, cosmu, tannu;
   var tantheta, theta, cosphi, phi;
   var t;
-  var area = {value: 0};
+  var area = { value: 0 };
 
   /* de-offset */
   p.x = (p.x - this.x0) / this.a;
@@ -358,11 +357,10 @@ function qsc_shift_lon_origin(lon, offset) {
   return slon;
 }
 
-export var names = ["Quadrilateralized Spherical Cube", "Quadrilateralized_Spherical_Cube", "qsc"];
+export var names = ['Quadrilateralized Spherical Cube', 'Quadrilateralized_Spherical_Cube', 'qsc'];
 export default {
   init: init,
   forward: forward,
   inverse: inverse,
   names: names
 };
-