@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/src/experimental/kernels/moll.ts

@@ -0,0 +1,105 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {};
+import adjust_lon from '../common/adjust_lon';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  state.x0 = state.x0 !== undefined ? state.x0 : 0;
+  state.y0 = state.y0 !== undefined ? state.y0 : 0;
+  state.long0 = state.long0 !== undefined ? state.long0 : 0;
+}
+
+/* Mollweide forward equations--mapping lat,long to x,y
+    ---------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  /* Forward equations
+      ----------------- */
+  var lon = p.x;
+  var lat = p.y;
+
+  var delta_lon = adjust_lon(lon - state.long0, state.over);
+  var theta = lat;
+  var con = Math.PI * Math.sin(lat);
+
+  /* Iterate using the Newton-Raphson method to find theta
+      ----------------------------------------------------- */
+  for (let iteration = 0; iteration < 50; iteration++) {
+    if (Math.abs(Math.abs(lat) - Math.PI / 2) < EPSLN) {
+      theta = Math.sign(lat) * Math.PI;
+      break;
+    }
+    var delta_theta = -(theta + Math.sin(theta) - con) / (1 + Math.cos(theta));
+    theta += delta_theta;
+    if (iteration === 49) throw new Error('Mollweide forward did not converge');
+    if (Math.abs(delta_theta) < EPSLN) {
+      break;
+    }
+  }
+  theta /= 2;
+
+  /* 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;
+  }
+  var x = 0.900316316158 * state.a * delta_lon * Math.cos(theta) + state.x0;
+  var y = 1.4142135623731 * state.a * Math.sin(theta) + state.y0;
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var theta;
+  var arg;
+
+  /* Inverse equations
+      ----------------- */
+  p.x -= state.x0;
+  p.y -= state.y0;
+  arg = p.y / (1.4142135623731 * state.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 = Math.sign(arg) * 0.999999999999;
+  }
+  theta = Math.asin(arg);
+  var lon = adjust_lon(
+    state.long0 + p.x / (0.900316316158 * state.a * Math.cos(theta)),
+    state.over
+  );
+  if (!state.over && lon < -Math.PI) {
+    lon = -Math.PI;
+  }
+  if (!state.over && lon > Math.PI) {
+    lon = Math.PI;
+  }
+  arg = (2 * theta + Math.sin(2 * theta)) / Math.PI;
+  if (Math.abs(arg) > 1) {
+    arg = Math.sign(arg);
+  }
+  var lat = Math.asin(arg);
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+
+    ...options
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/nzmg.ts

@@ -0,0 +1,249 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  A: number[];
+  B_re: number[];
+  B_im: number[];
+  C_re: number[];
+  C_im: number[];
+  D: number[];
+  iterations: number;
+};
+import {SEC_TO_RAD} from '../common/constants';
+
+/*
+  reference
+    Department of Land and Survey Technical Circular 1973/32
+      http://www.linz.govt.nz/docs/miscellaneous/nz-map-definition.pdf
+    OSG Technical Report 4.1
+      http://www.linz.govt.nz/docs/miscellaneous/nzmg.pdf
+  */
+
+/**
+ * iterations: Number of iterations to refine inverse transform.
+ *     0 -> km accuracy
+ *     1 -> m accuracy -- suitable for most mapping applications
+ *     2 -> mm accuracy
+ */
+export var iterations = 1;
+
+function initialize(state: State): void {
+  state.A = [];
+  state.A[1] = 0.6399175073;
+  state.A[2] = -0.1358797613;
+  state.A[3] = 0.063294409;
+  state.A[4] = -0.02526853;
+  state.A[5] = 0.0117879;
+  state.A[6] = -0.0055161;
+  state.A[7] = 0.0026906;
+  state.A[8] = -0.001333;
+  state.A[9] = 0.00067;
+  state.A[10] = -0.00034;
+
+  state.B_re = [];
+  state.B_im = [];
+  state.B_re[1] = 0.7557853228;
+  state.B_im[1] = 0;
+  state.B_re[2] = 0.249204646;
+  state.B_im[2] = 0.003371507;
+  state.B_re[3] = -0.001541739;
+  state.B_im[3] = 0.04105856;
+  state.B_re[4] = -0.10162907;
+  state.B_im[4] = 0.01727609;
+  state.B_re[5] = -0.26623489;
+  state.B_im[5] = -0.36249218;
+  state.B_re[6] = -0.6870983;
+  state.B_im[6] = -1.1651967;
+
+  state.C_re = [];
+  state.C_im = [];
+  state.C_re[1] = 1.3231270439;
+  state.C_im[1] = 0;
+  state.C_re[2] = -0.577245789;
+  state.C_im[2] = -0.007809598;
+  state.C_re[3] = 0.508307513;
+  state.C_im[3] = -0.112208952;
+  state.C_re[4] = -0.15094762;
+  state.C_im[4] = 0.18200602;
+  state.C_re[5] = 1.01418179;
+  state.C_im[5] = 1.64497696;
+  state.C_re[6] = 1.9660549;
+  state.C_im[6] = 2.5127645;
+
+  state.D = [];
+  state.D[1] = 1.5627014243;
+  state.D[2] = 0.5185406398;
+  state.D[3] = -0.03333098;
+  state.D[4] = -0.1052906;
+  state.D[5] = -0.0368594;
+  state.D[6] = 0.007317;
+  state.D[7] = 0.0122;
+  state.D[8] = 0.00394;
+  state.D[9] = -0.0013;
+}
+
+/**
+    New Zealand Map Grid Forward  - long/lat to x/y
+    long/lat in radians
+  */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var n;
+  var lon = p.x;
+  var lat = p.y;
+
+  var delta_lat = lat - state.lat0;
+  var delta_lon = lon - state.long0;
+
+  // 1. Calculate d_phi and d_psi    ...                          // and d_lambda
+  // For this algorithm, delta_latitude is in seconds of arc x 10-5, so we need to scale to those units. Longitude is radians.
+  var d_phi = (delta_lat / SEC_TO_RAD) * 1e-5;
+  var d_lambda = delta_lon;
+  var d_phi_n = 1; // d_phi^0
+
+  var d_psi = 0;
+  for (n = 1; n <= 10; n++) {
+    d_phi_n = d_phi_n * d_phi;
+    d_psi = d_psi + state.A[n] * d_phi_n;
+  }
+
+  // 2. Calculate theta
+  var th_re = d_psi;
+  var th_im = d_lambda;
+
+  // 3. Calculate z
+  var th_n_re = 1;
+  var th_n_im = 0; // theta^0
+  var th_n_re1;
+  var th_n_im1;
+
+  var z_re = 0;
+  var z_im = 0;
+  for (n = 1; n <= 6; n++) {
+    th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+    th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+    th_n_re = th_n_re1;
+    th_n_im = th_n_im1;
+    z_re = z_re + state.B_re[n] * th_n_re - state.B_im[n] * th_n_im;
+    z_im = z_im + state.B_im[n] * th_n_re + state.B_re[n] * th_n_im;
+  }
+
+  // 4. Calculate easting and northing
+  p.x = z_im * state.a + state.x0;
+  p.y = z_re * state.a + state.y0;
+
+  return p;
+}
+
+/**
+    New Zealand Map Grid Inverse  -  x/y to long/lat
+  */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var n;
+  var x = p.x;
+  var y = p.y;
+
+  var delta_x = x - state.x0;
+  var delta_y = y - state.y0;
+
+  // 1. Calculate z
+  var z_re = delta_y / state.a;
+  var z_im = delta_x / state.a;
+
+  // 2a. Calculate theta - first approximation gives km accuracy
+  var z_n_re = 1;
+  var z_n_im = 0; // z^0
+  var z_n_re1;
+  var z_n_im1;
+
+  var th_re = 0;
+  var th_im = 0;
+  for (n = 1; n <= 6; n++) {
+    z_n_re1 = z_n_re * z_re - z_n_im * z_im;
+    z_n_im1 = z_n_im * z_re + z_n_re * z_im;
+    z_n_re = z_n_re1;
+    z_n_im = z_n_im1;
+    th_re = th_re + state.C_re[n] * z_n_re - state.C_im[n] * z_n_im;
+    th_im = th_im + state.C_im[n] * z_n_re + state.C_re[n] * z_n_im;
+  }
+
+  // 2b. Iterate to refine the accuracy of the calculation
+  //        0 iterations gives km accuracy
+  //        1 iteration gives m accuracy -- good enough for most mapping applications
+  //        2 iterations bives mm accuracy
+  for (var i = 0; i < state.iterations; i++) {
+    var th_n_re = th_re;
+    var th_n_im = th_im;
+    var th_n_re1;
+    var th_n_im1;
+
+    var num_re = z_re;
+    var num_im = z_im;
+    for (n = 2; n <= 6; n++) {
+      th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+      th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+      th_n_re = th_n_re1;
+      th_n_im = th_n_im1;
+      num_re = num_re + (n - 1) * (state.B_re[n] * th_n_re - state.B_im[n] * th_n_im);
+      num_im = num_im + (n - 1) * (state.B_im[n] * th_n_re + state.B_re[n] * th_n_im);
+    }
+
+    th_n_re = 1;
+    th_n_im = 0;
+    var den_re = state.B_re[1];
+    var den_im = state.B_im[1];
+    for (n = 2; n <= 6; n++) {
+      th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+      th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+      th_n_re = th_n_re1;
+      th_n_im = th_n_im1;
+      den_re = den_re + n * (state.B_re[n] * th_n_re - state.B_im[n] * th_n_im);
+      den_im = den_im + n * (state.B_im[n] * th_n_re + state.B_re[n] * th_n_im);
+    }
+
+    // Complex division
+    var den2 = den_re * den_re + den_im * den_im;
+    th_re = (num_re * den_re + num_im * den_im) / den2;
+    th_im = (num_im * den_re - num_re * den_im) / den2;
+  }
+
+  // 3. Calculate d_phi              ...                                    // and d_lambda
+  var d_psi = th_re;
+  var d_lambda = th_im;
+  var d_psi_n = 1; // d_psi^0
+
+  var d_phi = 0;
+  for (n = 1; n <= 9; n++) {
+    d_psi_n = d_psi_n * d_psi;
+    d_phi = d_phi + state.D[n] * d_psi_n;
+  }
+
+  // 4. Calculate latitude and longitude
+  // d_phi is calcuated in second of arc * 10^-5, so we need to scale back to radians. d_lambda is in radians.
+  var lat = state.lat0 + d_phi * SEC_TO_RAD * 1e5;
+  var lon = state.long0 + d_lambda;
+
+  p.x = lon;
+  p.y = lat;
+
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    A: [],
+    B_re: [],
+    B_im: [],
+    C_re: [],
+    C_im: [],
+    D: [],
+    iterations: 1,
+    ...options
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/omerc.ts

@@ -0,0 +1,343 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to reuse the caller-owned point instead of allocating coordinate results. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  no_off: boolean;
+  no_rot: boolean;
+  alpha: number;
+  rectified_grid_angle: number;
+  longc: number;
+  long1: number;
+  long2: number;
+  B: number;
+  A: number;
+  E: number;
+  lam0: number;
+  singam: number;
+  cosgam: number;
+  sinrot: number;
+  cosrot: number;
+  rB: number;
+  ArB: number;
+  BrA: number;
+  u_0: number;
+  v_pole_n: number;
+  v_pole_s: number;
+  no_uoff: boolean;
+  projName: string;
+};
+import tsfnz from '../common/tsfnz';
+import adjust_lon from '../common/adjust_lon';
+import phi2z from '../common/phi2z';
+import {EPSLN, HALF_PI, TWO_PI, FORTPI} from '../common/constants';
+
+var TOL = 1e-7;
+
+function isTypeA(P: State): boolean {
+  return (
+    P.no_uoff ||
+    P.no_off ||
+    [
+      'hotineobliquemercator',
+      'hotineobliquemercatorvarianta',
+      'hotineobliquemercatorazimuthnaturalorigin'
+    ].includes(P.projName.toLowerCase().replace(/[ _-]/g, ''))
+  );
+}
+
+function initialize(state: State): void {
+  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;
+
+  if (!state.k0) {
+    state.k0 = 1;
+  }
+
+  // only Type A uses the no_off or no_uoff property
+  // https://github.com/OSGeo/proj.4/issues/104
+  state.no_off = isTypeA(state);
+  state.no_rot = state.no_rot;
+
+  var alp = false;
+  if (Number.isFinite(state.alpha)) {
+    alp = true;
+  }
+
+  var gam = false;
+  if (Number.isFinite(state.rectified_grid_angle)) {
+    gam = true;
+  }
+
+  if (alp) {
+    alpha_c = state.alpha;
+  }
+
+  if (gam) {
+    gamma = state.rectified_grid_angle;
+    if (!alp) {
+      alpha_c = 0;
+      alp = true;
+    }
+  }
+
+  if (alp || gam) {
+    lamc = state.longc;
+  } else {
+    lam1 = state.long1;
+    phi1 = state.lat1;
+    lam2 = state.long2;
+    phi2 = state.lat2;
+
+    if (
+      Math.abs(phi1 - phi2) <= TOL ||
+      Math.abs(phi1) <= TOL ||
+      Math.abs(Math.abs(phi1) - HALF_PI) <= TOL ||
+      Math.abs(Math.abs(state.lat0) - HALF_PI) <= TOL ||
+      Math.abs(Math.abs(phi2) - HALF_PI) <= TOL
+    ) {
+      throw new Error();
+    }
+  }
+
+  var one_es = 1.0 - state.es;
+  com = Math.sqrt(one_es);
+
+  if (Math.abs(state.lat0) > EPSLN) {
+    sinph0 = Math.sin(state.lat0);
+    cosph0 = Math.cos(state.lat0);
+    con = 1 - state.es * sinph0 * sinph0;
+    state.B = cosph0 * cosph0;
+    state.B = Math.sqrt(1 + (state.es * state.B * state.B) / one_es);
+    state.A = (state.B * state.k0 * com) / con;
+    D = (state.B * com) / (cosph0 * Math.sqrt(con));
+    F = D * D - 1;
+
+    if (F <= 0) {
+      F = 0;
+    } else {
+      F = Math.sqrt(F);
+      if (state.lat0 < 0) {
+        F = -F;
+      }
+    }
+
+    state.E = F += D;
+    state.E *= Math.pow(tsfnz(state.e, state.lat0, sinph0), state.B);
+  } else {
+    state.B = 1 / com;
+    state.A = state.k0;
+    state.E = D = F = 1;
+  }
+
+  if (alp || gam) {
+    if (alp) {
+      gamma0 = Math.asin(Math.sin(alpha_c) / D);
+      if (!gam) {
+        gamma = alpha_c;
+      }
+    } else {
+      gamma0 = gamma;
+      alpha_c = Math.asin(D * Math.sin(gamma0));
+    }
+    let longitudeArgument = 0.5 * (F - 1 / F) * Math.tan(gamma0);
+    if (D > 1 && Math.abs(Math.cos(alpha_c)) <= 8 * Number.EPSILON) {
+      // For a right-angle azimuth away from the equator, the exact argument
+      // is ±1. Near the equator, cancellation in F and rounding in gamma0
+      // can exceed any fixed ULP window. Use the analytic limit instead.
+      longitudeArgument = Math.sign(state.lat0) * Math.sign(Math.sin(alpha_c));
+    } else if (
+      Math.abs(longitudeArgument) > 1 &&
+      Math.abs(longitudeArgument) <= 1 + 8 * Number.EPSILON
+    ) {
+      // Preserve nearby azimuths and clamp only small domain overshoots.
+      longitudeArgument = Math.sign(longitudeArgument);
+    }
+    state.lam0 = lamc - Math.asin(longitudeArgument) / state.B;
+  } else {
+    H = Math.pow(tsfnz(state.e, phi1, Math.sin(phi1)), state.B);
+    L = Math.pow(tsfnz(state.e, phi2, Math.sin(phi2)), state.B);
+    F = state.E / H;
+    p = (L - H) / (L + H);
+    J = state.E * state.E;
+    J = (J - L * H) / (J + L * H);
+    con = lam1 - lam2;
+
+    if (con < -Math.PI) {
+      lam2 -= TWO_PI;
+    } else if (con > Math.PI) {
+      lam2 += TWO_PI;
+    }
+
+    state.lam0 = adjust_lon(
+      0.5 * (lam1 + lam2) - Math.atan((J * Math.tan(0.5 * state.B * (lam1 - lam2))) / p) / state.B,
+      state.over
+    );
+    gamma0 = Math.atan(
+      (2 * Math.sin(state.B * adjust_lon(lam1 - state.lam0, state.over))) / (F - 1 / F)
+    );
+    gamma = alpha_c = Math.asin(D * Math.sin(gamma0));
+  }
+
+  state.singam = Math.sin(gamma0);
+  state.cosgam = Math.cos(gamma0);
+  state.sinrot = Math.sin(gamma);
+  state.cosrot = Math.cos(gamma);
+
+  state.rB = 1 / state.B;
+  state.ArB = state.A * state.rB;
+  state.BrA = 1 / state.ArB;
+
+  if (state.no_off) {
+    state.u_0 = 0;
+  } else {
+    state.u_0 = Math.abs(state.ArB * Math.atan(Math.sqrt(D * D - 1) / Math.cos(alpha_c)));
+
+    if (state.lat0 < 0) {
+      state.u_0 = -state.u_0;
+    }
+  }
+
+  F = 0.5 * gamma0;
+  state.v_pole_n = state.ArB * Math.log(Math.tan(FORTPI - F));
+  state.v_pole_s = state.ArB * Math.log(Math.tan(FORTPI + F));
+}
+
+/* Oblique Mercator forward equations--mapping lat,long to x,y
+    ---------------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var coords = p;
+  var S, T, U, V, W, temp, u, v;
+  p.x = p.x - state.lam0;
+
+  if (Math.abs(Math.abs(p.y) - HALF_PI) > EPSLN) {
+    W = state.E / Math.pow(tsfnz(state.e, p.y, Math.sin(p.y)), state.B);
+
+    temp = 1 / W;
+    S = 0.5 * (W - temp);
+    T = 0.5 * (W + temp);
+    V = Math.sin(state.B * p.x);
+    U = (S * state.singam - V * state.cosgam) / T;
+
+    if (Math.abs(Math.abs(U) - 1.0) < EPSLN) {
+      throw new Error();
+    }
+
+    v = 0.5 * state.ArB * Math.log((1 - U) / (1 + U));
+    temp = Math.cos(state.B * p.x);
+
+    if (Math.abs(temp) < TOL) {
+      u = state.A * p.x;
+    } else {
+      u = state.ArB * Math.atan2(S * state.cosgam + V * state.singam, temp);
+    }
+  } else {
+    v = p.y > 0 ? state.v_pole_n : state.v_pole_s;
+    u = state.ArB * p.y;
+  }
+
+  if (state.no_rot) {
+    coords.x = u;
+    coords.y = v;
+  } else {
+    u -= state.u_0;
+    coords.x = v * state.cosrot + u * state.sinrot;
+    coords.y = u * state.cosrot - v * state.sinrot;
+  }
+
+  coords.x = state.a * coords.x + state.x0;
+  coords.y = state.a * coords.y + state.y0;
+
+  return coords;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var u, v, Qp, Sp, Tp, Vp, Up;
+  var coords = p;
+
+  p.x = (p.x - state.x0) * (1.0 / state.a);
+  p.y = (p.y - state.y0) * (1.0 / state.a);
+
+  if (state.no_rot) {
+    v = p.y;
+    u = p.x;
+  } else {
+    v = p.x * state.cosrot - p.y * state.sinrot;
+    u = p.y * state.cosrot + p.x * state.sinrot + state.u_0;
+  }
+
+  Qp = Math.exp(-state.BrA * v);
+  Sp = 0.5 * (Qp - 1 / Qp);
+  Tp = 0.5 * (Qp + 1 / Qp);
+  Vp = Math.sin(state.BrA * u);
+  Up = (Vp * state.cosgam + Sp * state.singam) / Tp;
+
+  if (Math.abs(Math.abs(Up) - 1) < EPSLN) {
+    coords.x = 0;
+    coords.y = Up < 0 ? -HALF_PI : HALF_PI;
+  } else {
+    coords.y = state.E / Math.sqrt((1 + Up) / (1 - Up));
+    coords.y = phi2z(state.e, Math.pow(coords.y, 1 / state.B));
+
+    if (coords.y === Infinity) {
+      throw new Error();
+    }
+
+    coords.x =
+      -state.rB * Math.atan2(Sp * state.cosgam - Vp * state.singam, Math.cos(state.BrA * u));
+  }
+
+  coords.x += state.lam0;
+
+  return coords;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    no_off: false,
+    no_rot: false,
+    alpha: NaN,
+    rectified_grid_angle: NaN,
+    longc: 0,
+    long1: 0,
+    long2: 0,
+    B: 0,
+    A: 0,
+    E: 0,
+    lam0: 0,
+    singam: 0,
+    cosgam: 0,
+    sinrot: 0,
+    cosrot: 0,
+    rB: 0,
+    ArB: 0,
+    BrA: 0,
+    u_0: 0,
+    v_pole_n: 0,
+    v_pole_s: 0,
+    no_uoff: false,
+    projName: '',
+    ...options
+  };
+  initialize(state);
+  return state;
+}