celestial-chart 0.8.0

package/src/timezones.js

@@ -0,0 +1,71 @@
+/* NOT PART OF THE BUILD.
+ *
+ * Nothing in the library calls `timezones()`, and it is never attached to the
+ * `Celestial` object either — it was unreachable upstream as well.
+ * Modularisation made that visible: no module imports it, so the bundler leaves
+ * it out. Its `topojson` dependency would only have been in the bundle for this.
+ *
+ * Kept rather than deleted: if timezone lookup is ever needed, this is where to
+ * start. It would then have to become an ES module, with topojson-client added
+ * as a dependency.
+ */
+function timezones() {
+  var cfg = settings.set(),
+       world, timezone;
+  loadJson(cfg.datapath + "timezones.json", function(error, json) {
+    world = topojson.feature(json, json.objects.timezones);
+    
+    Celestial.container.selectAll(".timezones")
+         .data(world.features)
+         .enter().append("path")
+         .attr("class", "tz");
+  });
+
+  function getTimezone(pos) {
+    var tz;
+    Celestial.container.selectAll(".tz").each( function(d,i) {
+      if (pointInPolygon(pos, d.geometry.coordinates[0])) {
+        tz = getMinutes(d.properties.zone);
+        return false;  
+      }
+    });
+    return tz;
+  }
+
+  function getMinutes(s) {
+    if (!s) return;
+    /*var tza = s.match(/UTC([\+\-])(\d+)\:(\d+)/);
+    if (tza === null) return;
+    var tzm = parseInt(tza[2]) * 60 + parseInt(tza[3]);
+    if (tza[1] === "-") tzm *= -1;*/
+    return parseFloat(s) * 60;
+  }
+
+  function pointInPolygon(p, polygon) {
+    var isInside = false;
+    var minX = polygon[0][0], maxX = polygon[0][0];
+    var minY = polygon[0][1], maxY = polygon[0][1];
+    for (var n = 1; n < polygon.length; n++) {
+      var q = polygon[n];
+      minX = Math.min(q[0], minX);
+      maxX = Math.max(q[0], maxX);
+      minY = Math.min(q[1], minY);
+      maxY = Math.max(q[1], maxY);
+    }
+
+    if (p[0] < minX || p[0] > maxX || p[1] < minY || p[1] > maxY) {
+      return false;
+    }
+
+    var i = 0, j = polygon.length - 1;
+    for (i, j; i < polygon.length; j = i++) {
+      if ( (polygon[i][1] > p[1]) != (polygon[j][1] > p[1]) &&
+            p[0] < (polygon[j][0] - polygon[i][0]) * (p[1] - polygon[i][1]) / (polygon[j][1] - polygon[i][1]) + polygon[i][0] ) {
+        isInside = !isInside;
+      }
+    }
+
+    return isInside;
+  }
+  Celestial.getTimezone = getTimezone;
+}

package/src/transform.js

@@ -0,0 +1,94 @@
+import { Celestial } from "./core.js";
+import { eulerAngles } from "./projection.js";
+
+var τ = Math.PI*2,
+    halfπ = Math.PI/2,
+    deg2rad = Math.PI/180;
+
+
+//Transform equatorial into any coordinates, degrees
+function transformDeg(c, euler) {
+  var res = transform( c.map( function(d) { return d * deg2rad; } ), euler);
+  return res.map( function(d) { return d / deg2rad; } );
+}
+
+//Transform equatorial into any coordinates, radians
+function transform(c, euler) {
+  var x, y, z, β, γ, λ, φ, dψ, ψ, θ,
+      ε = 1.0e-5;
+
+  if (!euler) return c; 
+
+  λ = c[0];  // celestial longitude 0..2pi
+  if (λ < 0) λ += τ; 
+  φ = c[1];  // celestial latitude  -pi/2..pi/2
+  
+  λ -= euler[0];  // celestial longitude - celestial coordinates of the native pole
+  β = euler[1];  // inclination between the poles (colatitude)
+  γ = euler[2];  // native coordinates of the celestial pole
+  
+  x = Math.sin(φ) * Math.sin(β) - Math.cos(φ) * Math.cos(β) * Math.cos(λ);
+  if (Math.abs(x) < ε) {
+    x = -Math.cos(φ + β) + Math.cos(φ) * Math.cos(β) * (1 - Math.cos(λ));
+  }
+  y = -Math.cos(φ) * Math.sin(λ);
+  
+  if (x !== 0 || y !== 0) {
+    dψ = Math.atan2(y, x);
+  } else {
+    dψ = λ - Math.PI;
+  }
+  ψ = (γ + dψ); 
+  if (ψ > Math.PI) ψ -= τ; 
+  
+  if (λ % Math.PI === 0) {
+    θ = φ + Math.cos(λ) * β;
+    if (θ > halfπ) θ = Math.PI - θ; 
+    if (θ < -halfπ) θ = -Math.PI - θ; 
+  } else {
+    z = Math.sin(φ) * Math.cos(β) + Math.cos(φ) * Math.sin(β) * Math.cos(λ);
+    if (Math.abs(z) > 0.99) {
+      θ = Math.abs(Math.acos(Math.sqrt(x*x+y*y)));
+      if (z < 0) θ *= -1; 
+    } else {
+      θ = Math.asin(z);
+    }
+  }
+  
+  return [ψ, θ];
+}
+
+  
+function getAngles(coords) {
+  if (coords === null || coords.length <= 0) return [0,0,0];
+  var rot = eulerAngles.equatorial; 
+  if (!coords[2]) coords[2] = 0;
+  return [rot[0] - coords[0], rot[1] - coords[1], rot[2] + coords[2]];
+}
+
+
+var euler = {
+  "ecliptic": [-90.0, 23.4393, 90.0],
+  "inverse ecliptic": [90.0, 23.4393, -90.0],
+  "galactic": [-167.1405, 62.8717, 122.9319], 
+  "inverse galactic": [122.9319, 62.8717, -167.1405],
+  "supergalactic": [283.7542, 74.2911, 26.4504],
+  "inverse supergalactic": [26.4504, 74.2911, 283.7542],
+  "init": function () {
+    for (var key in this) {
+      if (this[key].constructor == Array) { 
+        this[key] = this[key].map( function(val) { return val * deg2rad; } );
+      }
+    }
+  },
+  "add": function(name, ang) {
+    if (!ang || !name || ang.length !== 3 || this.hasOwnProperty(name)) return; 
+    this[name] = ang.map( function(val) { return val * deg2rad; } );
+    return this[name];
+  }
+};
+
+euler.init();
+Celestial.euler = function () { return euler; };
+
+export { deg2rad, euler, getAngles, halfπ, transformDeg, τ };

package/src/util.js

@@ -0,0 +1,275 @@
+import * as d3 from "./d3.js";
+import { deg2rad, halfπ, τ } from "./transform.js";
+
+function px(n) { return n + "px"; } 
+function Round(x, dg) { return(Math.round(Math.pow(10,dg)*x)/Math.pow(10,dg)); }
+function sign(x) { return x ? x < 0 ? -1 : 1 : 0; }
+function pad(n) { return n < 10 ? '0' + n : n; }
+
+
+// The bare `hasOwnProperty` resolved through the global object; in a module
+// that is misleading, so it is spelled out.
+var hasOwn = Object.prototype.hasOwnProperty;
+function has(o, key) { return o !== null && hasOwn.call(o, key); }
+function when(o, key, val) { return o !== null && hasOwn.call(o, key) ? o[key] : val; }
+function isNumber(n) { return n !== null && !isNaN(parseFloat(n)) && isFinite(n); }
+function isArray(o) { return o !== null && Object.prototype.toString.call(o) === "[object Array]"; }
+function isObject(o) { var type = typeof o;  return type === 'function' || type === 'object' && !!o; }
+function isFunction(o) { return typeof o == 'function' || false; }
+// d3.functor was removed in v4. It did exactly one thing: turned anything that
+// was not a function into a constant function.
+function functor(o) { return isFunction(o) ? o : function() { return o; }; }
+
+// Since v5 d3.json returns a Promise instead of invoking a callback. The shape
+// of the call sites is preserved — the old (error, json) form stays — so that
+// the loading logic is unchanged and the effect of the D3 upgrade stays
+// separable from everything else.
+// d3-queue was a separate package, unmaintained since v5. This is all the
+// library uses of its interface: defer(fn) to enqueue a task, await(cb) for the
+// end. Every defer runs synchronously, before the await.
+// The v3 selection.classed({name: boolean, ...}) form was removed in v4;
+// v7 only understands a classed(names, boolean) pair.
+function classes_(sel, obj) {
+  for (var k in obj) { if (has(obj, k)) sel.classed(k, obj[k]); }
+  return sel;
+}
+
+// The same for the object form of attr and style: v3 accepted a whole property
+// map, v4+ only a (name, value) pair. Left unhandled, the call runs AS A GETTER
+// and the next link in the chain is no longer working on a selection — silently,
+// without an exception, right up to the first use.
+function attrs(sel, obj) {
+  for (var k in obj) { if (has(obj, k)) sel.attr(k, obj[k]); }
+  return sel;
+}
+
+function styles_(sel, obj) {
+  for (var k in obj) { if (has(obj, k)) sel.style(k, obj[k]); }
+  return sel;
+}
+
+function taskQueue(concurrency) {
+  var tasks = [], running = 0, next = 0, error_ = null, done = null;
+
+  function startNext() {
+    while (!error_ && running < concurrency && next < tasks.length) {
+      running++;
+      tasks[next++](function (e) {
+        running--;
+        if (e && !error_) { error_ = e; return done(error_); }
+        if (error_) return;
+        if (running === 0 && next === tasks.length) return done(null);
+        startNext();
+      });
+    }
+  }
+
+  return {
+    defer: function (fn) { tasks.push(fn); return this; },
+    await: function (cb) {
+      done = cb;
+      if (!tasks.length) cb(null);
+      else startNext();
+      return this;
+    }
+  };
+}
+
+function loadJson(url, callback) {
+  return d3.json(url).then(
+    function(json) { callback(null, json); },
+    function(error) { callback(error || new Error("failed to load: " + url)); }
+  );
+}
+function isValidDate(d) { return d && d instanceof Date && !isNaN(d); }
+function fileExists(url) {
+  var http = new XMLHttpRequest();
+  http.open('HEAD', url, false);
+  http.send();
+  return http.status != 404;
+}
+
+function findPos(o) {
+  var l = 0, t = 0;
+  if (o.offsetParent) {
+    do {
+      l += o.offsetLeft;
+      t += o.offsetTop;
+    } while ((o = o.offsetParent) !== null);
+  }
+  return [l, t];
+}
+
+function hasParent(t, id){
+  while(t.parentNode){
+    if(t.id === id) return true;
+    t = t.parentNode;
+  }
+  return false;
+}
+
+function attach(node, event, func) {
+  if (node.addEventListener) node.addEventListener(event, func, false);
+  else node.attachEvent("on" + event, func); 
+}
+
+function stopPropagation(e) {
+  if (typeof e.stopPropagation != "undefined") e.stopPropagation();
+  else e.cancelBubble = true;
+}
+
+function dateDiff(dt1, dt2, type) {
+  var diff = dt2.valueOf() - dt1.valueOf(),
+      tp = type || "d";
+  switch (tp) {
+    case 'y': case 'yr': diff /= 31556926080; break;
+    case 'm': case 'mo': diff /= 2629800000; break;
+    case 'd': case 'dy': diff /= 86400000; break;
+    case 'h': case 'hr': diff /= 3600000; break;
+    case 'n': case 'mn': diff /= 60000; break;
+    case 's': case 'sec': diff /= 1000; break;
+    case 'ms': break;    
+  }
+  return Math.floor(diff);
+}
+
+function dateParse(s) {
+  if (!s) return; 
+  var t = s.split(".");
+  if (t.length < 1) return; 
+  t = t[0].split("-");
+  t[0] = t[0].replace(/\D/g, "");
+  if (!t[0]) return; 
+  t[1] = t[1] ? t[1].replace(/\D/g, "") : "1";
+  t[2] = t[2] ? t[2].replace(/\D/g, "") : "1";
+  //Fraction -> h:m:s
+  return new Date(Date.UTC(t[0], t[1]-1, t[2]));
+}
+
+
+function interpolateAngle(a1, a2, t) {
+  a1 = (a1*deg2rad +τ) % τ;
+  a2 = (a2*deg2rad + τ) % τ;
+  if (Math.abs(a1 - a2) > Math.PI) {
+    if (a1 > a2) a1 = a1 - τ;
+    else if (a2 > a1) a2 = a2 - τ;
+  }
+  return d3.interpolateNumber(a1/deg2rad, a2/deg2rad);
+}
+
+var Trig = {
+  sinh: function (val) { return (Math.pow(Math.E, val)-Math.pow(Math.E, -val))/2; },
+  cosh: function (val) { return (Math.pow(Math.E, val)+Math.pow(Math.E, -val))/2; },
+  tanh: function (val) { return 2.0 / (1.0 + Math.exp(-2.0 * val)) - 1.0; },
+  asinh: function (val) { return Math.log(val + Math.sqrt(val * val + 1)); },
+  acosh: function (val) { return Math.log(val + Math.sqrt(val * val - 1)); },
+  // The JS `%` keeps the sign of the dividend, so a single shift is only enough
+  // while the input does not go below -2*pi (respectively -3*pi). The mean
+  // orbital elements do grow large as one moves away from J2000, and there the
+  // old formula returned a negative — that is, un-normalised — angle. Shifting
+  // twice is correct for every input.
+  normalize0: function(val) { return (((val + Math.PI) % (Math.PI*2)) + Math.PI*2) % (Math.PI*2) - Math.PI; },
+  normalize: function(val) { return ((val % (Math.PI*2)) + Math.PI*2) % (Math.PI*2); },
+
+  cartesian: function(p) {
+    var ϕ = p[0], θ = halfπ - p[1], r = p[2];
+    return {"x": r * Math.sin(θ) * Math.cos(ϕ), "y": r * Math.sin(θ) * Math.sin(ϕ), "z": r * Math.cos(θ)};
+  },
+  // WARNING: nothing in the library calls the following four methods.
+  // `spherical` is moreover not the inverse of `cartesian`: it uses `atan`
+  // instead of `atan2` (losing the quadrant, and dividing by zero when x = 0),
+  // and the second value it returns is a polar distance, not a latitude. Left
+  // untouched because it has no callers — but no new code should build on it
+  // until somebody puts it right.
+  spherical: function(p) {
+    var r = Math.sqrt(p.x * p.x + p.y * p.y + p.z * p.z),
+        θ = Math.atan(p.y / p.x),
+        ϕ = Math.acos(p.z / r);
+    return  [θ / deg2rad, ϕ / deg2rad, r];
+  },
+  distance: function(p1, p2) {
+    return Math.acos(Math.sin(p1[1])*Math.sin(p2[1]) + Math.cos(p1[1])*Math.cos(p2[1])*Math.cos(p1[0]-p2[0]));
+  }
+};
+
+var epsilon = 1e-6, 
+    halfPi =  Math.PI / 2, 
+    quarterPi =  Math.PI / 4, 
+    tau =  Math.PI * 2;
+    
+function cartesian(spherical) {
+  var lambda = spherical[0], phi = spherical[1], cosPhi = Math.cos(phi);
+  return [cosPhi * Math.cos(lambda), cosPhi * Math.sin(lambda), Math.sin(phi)];
+}
+
+function cartesianCross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+function cartesianNormalizeInPlace(d) {
+  var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+  d[0] /= l; d[1] /= l; d[2] /= l;
+}
+
+function longitude(point) {
+  if (Math.abs(point[0]) <= Math.PI)
+    return point[0];
+  else
+    return sign(point[0]) * ((Math.abs(point[0]) +  Math.PI) % tau -  Math.PI);
+}
+
+function polygonContains(polygon, point) {
+  var lambda = longitude(point),
+      phi = point[1],
+      sinPhi = Math.sin(phi),
+      normal = [Math.sin(lambda), -Math.cos(lambda), 0],
+      angle = 0,
+      winding = 0,
+      sum = 0;
+
+  if (sinPhi === 1) phi = halfPi + epsilon;
+  else if (sinPhi === -1) phi = -halfPi - epsilon;
+
+  for (var i = 0, n = polygon.length; i < n; ++i) {
+    if (!(m = (ring = polygon[i]).length)) continue;
+    var ring,
+        m,
+        point0 = ring[m - 1],
+        lambda0 = longitude(point0),
+        phi0 = point0[1] / 2 + quarterPi,
+        sinPhi0 = Math.sin(phi0),
+        cosPhi0 = Math.cos(phi0),
+        point1, cosPhi1, sinPhi1, lambda1;
+
+    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {
+      point1 = ring[j];
+      lambda1 = longitude(point1);
+      var phi1 = point1[1] / 2 + quarterPi;
+      sinPhi1 = Math.sin(phi1);
+      cosPhi1 = Math.cos(phi1);
+      var delta = lambda1 - lambda0,
+          sign = delta >= 0 ? 1 : -1,
+          absDelta = sign * delta,
+          antimeridian = absDelta > Math.PI,
+          k = sinPhi0 * sinPhi1;
+
+      sum += Math.atan2(k * sign * Math.sin(absDelta), cosPhi0 * cosPhi1 + k * Math.cos(absDelta));
+      angle += antimeridian ? delta + sign * tau : delta;
+
+      if ((antimeridian ^ lambda0) >= (lambda ^ lambda1) >= lambda) {
+        var arc = cartesianCross(cartesian(point0), cartesian(point1));
+        cartesianNormalizeInPlace(arc);
+        var intersection = cartesianCross(normal, arc);
+        cartesianNormalizeInPlace(intersection);
+        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * Math.asin(intersection[2]);
+        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
+          winding += antimeridian ^ delta >= 0 ? 1 : -1;
+        }
+      }
+    }
+  }
+
+  return (angle < -epsilon || angle < epsilon && sum < -epsilon) ^ (winding & 1);
+}
+
+export { Round, Trig, attrs, dateDiff, dateParse, taskQueue, findPos, functor, has, hasParent, interpolateAngle, isArray, isNumber, isObject, isValidDate, loadJson, classes_, pad, px, styles_ };