celestial-chart 0.8.0

package/src/get.js

@@ -0,0 +1,210 @@
+
+import { Kepler } from "./kepler.js";
+import { Celestial } from "./core.js";
+import { euler, transformDeg } from "./transform.js";
+import { has, isArray, isNumber } from "./util.js";
+
+//load data and transform coordinates
+
+
+function getPoint(coords, trans) {
+  return transformDeg(coords, euler[trans]);
+}
+ 
+function getData(d, trans) {
+  if (trans === "equatorial") return d;
+
+  var leo = euler[trans],
+      f = d.features;
+
+  for (var i=0; i<f.length; i++)
+    f[i].geometry.coordinates = translate(f[i], leo);
+  
+  return d;
+}
+
+// These also receive the map instance: the planet list and the grid values
+// depend on that map's own configuration, not on a shared "current map".
+function getPlanets(d, sky) {
+  var res = [];
+  
+  for (var key in d) {
+    if (!has(d, key)) continue;
+    if (sky.cfg.planets.which.indexOf(key) === -1) continue;
+    var dat = Kepler().id(key);
+    if (has(d[key], "parent")) dat.parentBody(d[key].parent);
+    dat.elements(d[key].elements[0]).params(d[key]);
+    if (key === "ter") 
+      Celestial.origin = dat;
+    else res.push(dat);
+  }
+  //res.push(Kepler().id("sol"));
+  //res.push(Kepler().id("lun"));
+  return res;
+}
+
+
+function getPlanet(id, dt, sky) {
+  dt = dt || Celestial.date();
+  if (!Celestial.origin) return;
+
+  var o = Celestial.origin(dt).spherical(), res;
+     
+  sky.container.selectAll(".planet").each(function(d) {
+    if (id === d.id()) {
+      res = d(dt).equatorial(o);
+    }
+  });
+  return res;
+}
+
+function getConstellationList(d) {
+  var res = {},
+      f = d.features;
+      
+  for (var i=0; i<f.length; i++) {
+    res[f[i].id] = {
+      center: f[i].properties.display.slice(0,2),
+      scale: f[i].properties.display[2]
+    };
+  }
+  return res;
+}
+
+function getMwbackground(d) {
+  // geoJson object to darken the mw-outside, prevent greying of whole map in some orientations 
+  var res = {'type': 'FeatureCollection', 'features': [ {'type': 'Feature', 
+              'geometry': { 'type': 'MultiPolygon', 'coordinates' : [] }
+            }]};
+
+  // reverse the polygons, inside -> outside
+  var l1 = d.features[0].geometry.coordinates[0];
+  res.features[0].geometry.coordinates[0] = [];
+  for (var i=0; i<l1.length; i++) {
+    res.features[0].geometry.coordinates[0][i] = l1[i].slice().reverse();
+  }
+
+  return res;
+}
+
+function getTimezones() {
+  
+}
+
+function translate(d, leo) {
+  var res = [];
+  switch (d.geometry.type) {
+    case "Point": res = transformDeg(d.geometry.coordinates, leo); break;
+    case "LineString": res.push(transLine(d.geometry.coordinates, leo)); break;
+    case "MultiLineString": res = transMultiLine(d.geometry.coordinates, leo); break;
+    case "Polygon": res.push(transLine(d.geometry.coordinates[0], leo)); break;
+    case "MultiPolygon": res.push(transMultiLine(d.geometry.coordinates[0], leo)); break;
+  }
+  
+  return res;
+}
+
+function getGridValues(type, loc, sky) {
+  var lines = [];
+  if (!loc) return [];
+  if (!isArray(loc)) loc = [loc];
+  //center, outline, values
+  for (var i=0; i < loc.length; i++) {
+    switch (loc[i]) {
+      case "center": 
+        if (type === "lat")
+          lines = lines.concat(getLine(type, sky.cfg.center[0], "N"));
+        else
+          lines = lines.concat(getLine(type, sky.cfg.center[1], "S")); 
+        break;
+      case "outline": 
+        if (type === "lon") { 
+          lines = lines.concat(getLine(type, sky.cfg.center[1]-89.99, "S"));
+          lines = lines.concat(getLine(type, sky.cfg.center[1]+89.99, "N"));
+        } else {
+					// TODO: hemi
+          lines = lines.concat(getLine(type, sky.cfg.center[0]-179.99, "E"));
+          lines = lines.concat(getLine(type, sky.cfg.center[0]+179.99, "W"));
+        }
+        break;
+      default: if (isNumber(loc[i])) {
+        if (type === "lat")
+          lines = lines.concat(getLine(type, loc[i], "N"));
+        else
+          lines = lines.concat(getLine(type, loc[i], "S")); 
+        break;        
+      }
+    }
+  }
+  //return [{coordinates, value, orientation}, ...]
+  return jsonGridValues(lines);
+}
+
+function jsonGridValues(lines) {
+  var res = [];
+  for (var i=0; i < lines.length; i++) {
+    var f = {type: "Feature", "id":i, properties: {}, geometry:{type:"Point"}};
+    f.properties.value = lines[i].value;
+    f.properties.orientation = lines[i].orientation;
+    f.geometry.coordinates = lines[i].coordinates;
+    res.push(f);
+  }
+  return res;
+}
+
+function getLine(type, loc, orient) {
+  var min, max, step, val, coord,
+      tp = type,
+      res = [],
+      lr = loc;
+  if (sky.cfg.transform === "equatorial" && tp === "lon") tp = "ra";
+  
+  if (tp === "ra") {
+    min = 0; max = 23; step = 1;
+  } else if (tp === "lon") {
+    min = 0; max = 350; step = 10;    
+  } else {
+    min = -80; max = 80; step = 10;    
+  }
+  for (var i=min; i<=max; i+=step) {
+    var o = orient;
+    if (tp === "lat") {
+      coord = [lr, i];
+      val = i.toString() + "\u00b0";
+      if (i < 0) o += "S"; else o += "N";
+    } else if (tp === "ra") {
+      coord = [i * 15, lr];
+      val = i.toString() + "\u02b0";
+    } else {
+      coord = [i, lr];
+      val = i.toString() + "\u00b0";
+    }
+  
+    res.push({coordinates: coord, value: val, orientation: o});
+  }
+  return res;
+}
+
+function transLine(c, leo) {
+  var line = [];
+  
+  for (var i=0; i<c.length; i++)
+    line.push(transformDeg(c[i], leo));
+  
+  return line;
+}
+
+function transMultiLine(c, leo) {
+  var lines = [];
+  
+  for (var i=0; i<c.length; i++)
+    lines.push(transLine(c[i], leo));
+  
+  return lines;
+}
+
+Celestial.getData = getData;
+Celestial.getPoint = getPoint;
+Celestial.getPlanet = getPlanet;
+
+export { getConstellationList, getData, getGridValues, getMwbackground, getPlanet, getPlanets };

package/src/global.js

@@ -0,0 +1,4 @@
+// Browser entry point: the original, global `Celestial` interface.
+// D3 is bundled in, so no separate script tag is needed.
+import { Celestial } from "./celestial.js";
+window.Celestial = Celestial;

package/src/horizontal.js

@@ -0,0 +1,98 @@
+import { Celestial } from "./core.js";
+import { deg2rad } from "./transform.js";
+
+var horizontal = function(dt, pos, loc) {
+  //dt: datetime, pos: celestial coordinates [lat,lng], loc: location [lat,lng]  
+  var ha = getMST(dt, loc[1]) - pos[0];
+  if (ha < 0) ha = ha + 360;
+  
+  ha  = ha * deg2rad;
+  var dec = pos[1] * deg2rad;
+  var lat = loc[0] * deg2rad;
+
+  var alt = Math.asin(Math.sin(dec) * Math.sin(lat) + Math.cos(dec) * Math.cos(lat) * Math.cos(ha));
+  var az = Math.acos((Math.sin(dec) - Math.sin(alt) * Math.sin(lat)) / (Math.cos(alt) * Math.cos(lat)));
+
+  if (Math.sin(ha) > 0) az = Math.PI * 2 - az;
+  
+  return [alt / deg2rad, az / deg2rad, 0];
+};
+
+horizontal.inverse = function(dt, hor, loc) {
+  
+  var alt = hor[0] * deg2rad;
+  var az = hor[1] * deg2rad;
+  var lat = loc[0] * deg2rad;
+   
+  var dec = Math.asin((Math.sin(alt) * Math.sin(lat)) + (Math.cos(alt) * Math.cos(lat) * Math.cos(az)));
+  var ha = (Math.sin(alt) - (Math.sin(dec) * Math.sin(lat))) / (Math.cos(dec) * Math.cos(lat));
+  
+  // Rounding error can push the quotient outside the domain of acos (at the
+  // zenith it comes out as 1+1e-16). The previous .toFixed(6) handled that only
+  // by accident, and in doing so truncated the input to six decimals — where
+  // acos is steep.
+  ha = Math.acos(Math.max(-1, Math.min(1, ha)));
+  // acos returns 0..180 degrees, so half the sky would be lost. The forward
+  // direction handles the same ambiguity (if (Math.sin(ha) > 0) az = 2*pi - az);
+  // the inverse needs its mirror image. See upstream issue #148.
+  if (Math.sin(az) > 0) ha = -ha;
+  ha  = ha / deg2rad;
+  
+  var ra = getMST(dt, loc[1]) - ha;
+  //if (ra < 0) ra = ra + 360;
+    
+  return [ra, dec / deg2rad, 0];
+};
+
+function getMST(dt, lng)
+{
+    var yr = dt.getUTCFullYear();
+    var mo = dt.getUTCMonth() + 1;
+    var dy = dt.getUTCDate();
+    var h = dt.getUTCHours();
+    var m = dt.getUTCMinutes();
+    var s = dt.getUTCSeconds();
+
+    if ((mo == 1)||(mo == 2)) {
+        yr  = yr - 1;
+        mo = mo + 12;
+    }
+
+    var a = Math.floor(yr / 100);
+    var b = 2 - a + Math.floor(a / 4);
+    var c = Math.floor(365.25 * yr);
+    var d = Math.floor(30.6001 * (mo + 1));
+
+    // days since J2000.0
+    var jd = b + c + d - 730550.5 + dy + (h + m/60.0 + s/3600.0)/24.0;
+    
+    // julian centuries since J2000.0
+    var jt = jd/36525.0;
+
+    // the mean sidereal time in degrees
+    var mst = 280.46061837 + 360.98564736629*jd + 0.000387933*jt*jt - jt*jt*jt/38710000 + lng;
+
+    // in degrees modulo 360.0
+    if (mst > 0.0) 
+        while (mst > 360.0) mst = mst - 360.0;
+    else
+        while (mst < 0.0)   mst = mst + 360.0;
+        
+    return mst;
+}
+
+Celestial.horizontal = horizontal;
+// Hour angle in degrees, in the range [0, 360).
+//
+// The condition was originally `ha < 180`, which is a typo: getMST returns
+// [0, 360) and so does ra, so the difference lies in (-360, 360) — it is values
+// below zero that need wrapping. With `180`, an hour angle of 100 degrees came
+// out as 460. Two lines above, horizontal() has the same normalisation written
+// correctly.
+Celestial.ha = function(dt, lng, ra) {
+  var ha = getMST(dt, lng) - ra;
+  if (ha < 0) ha = ha + 360;
+  return ha;
+};
+
+export { horizontal };

package/src/index.js

@@ -0,0 +1,8 @@
+// ESM entry point.
+//
+//   import Celestial from "celestial-chart";     // the original, global interface
+//   import { SkyMap } from "celestial-chart";    // for several independent maps
+//
+import { Celestial, SkyMap } from "./celestial.js";
+export { Celestial, SkyMap };
+export default Celestial;