Merge pull request #184 from paulcockrell/master

Astrocalc, Sun and Moon info calculator

apps.json

@@ -963,7 +963,28 @@
       {"name":"chrono.img","url":"chrono-icon.js","evaluate":true}
     ]
   },
-    { "id": "widhwt",
+  { "id": "astrocalc",
+    "name": "Astrocalc",
+    "icon": "astrocalc.png",
+    "version":"0.01",
+    "description": "Calculates interesting information on the sun and moon cycles for the current day based on your location.",
+    "tags": "app,sun,moon,cycles,tool,outdoors",
+    "allow_emulator":true,
+    "storage": [
+      {"name":"astrocalc.app.js","url":"astrocalc-app.js"},
+      {"name":"suncalc.js","url":"suncalc.js"},
+      {"name":"astrocalc.img","url":"astrocalc-icon.js","evaluate":true},
+      {"name":"first-quarter.img","url":"first-quarter-icon.js","evaluate":true},
+      {"name":"last-quarter.img","url":"last-quarter-icon.js","evaluate":true},
+      {"name":"waning-crescent.img","url":"waning-crescent-icon.js","evaluate":true},
+      {"name":"waning-gibbous.img","url":"waning-gibbous-icon.js","evaluate":true},
+      {"name":"full.img","url":"full-icon.js","evaluate":true},
+      {"name":"new.img","url":"new-icon.js","evaluate":true},
+      {"name":"waxing-gibbous.img","url":"waxing-gibbous-icon.js","evaluate":true},
+      {"name":"waxing-crescent.img","url":"waxing-crescent-icon.js","evaluate":true}
+    ]
+  },
+  { "id": "widhwt",
     "name": "Hand Wash Timer",
     "icon": "widget.png",
     "version":"0.01",

apps/astrocalc/ChangeLog

@@ -0,0 +1 @@
+0.01: Create astrocalc app

apps/astrocalc/astrocalc-app.js

@@ -0,0 +1,348 @@
+/**
+ * Inspired by: https://www.timeanddate.com
+ */
+
+const SunCalc = require("suncalc.js");
+
+function drawMoon(phase, x, y) {
+  const moonImgFiles = [
+    "new",
+    "waxing-crescent",
+    "first-quarter",
+    "waxing-gibbous",
+    "full",
+    "waning-gibbous",
+    "last-quarter",
+    "waning-crescent",
+  ];
+
+  img = require("Storage").read(`${moonImgFiles[phase]}.img`);
+  // image width & height = 92px
+  g.drawImage(img, x - parseInt(92 / 2), y);
+}
+
+// linear interpolation between two values a and b
+// u controls amount of a/b and is in range [0.0,1.0]
+function lerp(a,b,u) {
+  return (1-u) * a + u * b;
+}
+
+function titlizeKey(key) {
+  return (key[0].toUpperCase() + key.slice(1)).match(/[A-Z][a-z]+/g).join(" ");
+}
+
+function dateToTimeString(date) {
+  const hrs = ("0" + date.getHours()).substr(-2);
+  const mins = ("0" + date.getMinutes()).substr(-2);
+  const secs = ("0" + date.getMinutes()).substr(-2);
+
+  return `${hrs}:${mins}:${secs}`;
+}
+
+function drawTitle(key) {
+  const fontHeight = 16;
+  const x = 0;
+  const x2 = g.getWidth() - 1;
+  const y = fontHeight + 26;
+  const y2 = g.getHeight() - 1;
+  const title = titlizeKey(key);
+
+  g.setFont("6x8", 2);
+  g.setFontAlign(0,-1);
+  g.drawString(title,(x+x2)/2,y-fontHeight-2);
+  g.drawLine(x,y-2,x2,y-2);
+}
+
+/**
+ * @params {Number} angle Angle of point around a radius
+ * @params {Number} radius Radius of the point to be drawn, default 2
+ * @params {Object} color Color of the point
+ * @params {Number} color.r Red 0-1
+ * @params {Number} color.g Green 0-1
+ * @params {Number} color.b Blue 0-1
+ */
+function drawPoint(angle, radius, color) {
+  const pRad = Math.PI / 180;
+  const faceWidth = 80; // watch face radius
+  const centerPx = g.getWidth() / 2;
+
+  const a = angle * pRad;
+  const x = centerPx + Math.sin(a) * faceWidth;
+  const y = centerPx - Math.cos(a) * faceWidth;
+
+  if (!radius) radius = 2;
+
+  g.setColor(color.r, color.g, color.b);
+  g.fillCircle(x, y + 20, radius);
+}
+
+function drawPoints() {
+  const startColor = {r: 140, g: 255, b: 255};  // light blue
+  const endColor   = {r: 0, g: 0, b: 140};  // dark turquoise
+
+  const steps = 60;
+  const step_u = 1.0 / (steps / 2);
+  let u = 0.0;
+
+  for (let i = 0; i < steps; i++) {
+    const colR = lerp(startColor.r, endColor.r, u) / 255;
+    const colG = lerp(startColor.g, endColor.g, u) / 255;
+    const colB = lerp(startColor.b, endColor.b, u) / 255;
+    const col = {r: colR, g: colG, b: colB};
+
+    if (i >= 0 && i <= 30) {
+      u += step_u;
+    } else {
+      u -= step_u;
+    }
+
+    drawPoint((360 * i) / steps, 2, col);
+  }
+}
+
+function drawData(title, obj, startX, startY) {
+  g.clear();
+  drawTitle(title);
+
+  let xPos, yPos;
+
+  if (typeof(startX) === "undefined" || startX === null) {
+    // Center text
+    g.setFontAlign(0,-1);
+    xPos = (0 + g.getWidth() - 2) / 2;
+  } else {
+    xPos = startX;
+  }
+
+  if (typeof(startY) === "undefined") {
+    yPos = 5;
+  } else {
+    yPos = startY;
+  }
+
+  g.setFont("6x8", 1);
+
+  Object.keys(obj).forEach((key) => {
+    g.drawString(`${key}: ${obj[key]}`, xPos, yPos += 20);
+  });
+
+  g.flip();
+}
+
+function drawMoonPositionPage(gps, title) {
+  const pos = SunCalc.getMoonPosition(new Date(), gps.lat, gps.lon);
+
+  const pageData = {
+    Azimuth: pos.azimuth.toFixed(2),
+    Altitude: pos.altitude.toFixed(2),
+    Distance: `${pos.distance.toFixed(0)} km`,
+    "Parallactic Ang": pos.parallacticAngle.toFixed(2),
+  };
+  const azimuthDegrees = parseInt(pos.azimuth * 180 / Math.PI);
+
+  drawData(title, pageData, null, 80);
+  drawPoints();
+  drawPoint(azimuthDegrees, 8, {r: 1, g: 1, b: 1});
+
+  let m = setWatch(() => {
+      let m = moonIndexPageMenu(gps);
+  }, BTN3, {repeat: false, edge: "falling"});
+}
+
+function drawMoonIlluminationPage(gps, title) {
+  const phaseNames = [
+    "New Moon", "Waxing Crescent", "First Quarter", "Waxing Gibbous",
+    "Full Moon", "Waning Gibbous", "Last Quater", "Waning Crescent",
+  ];
+
+  const phase = SunCalc.getMoonIllumination(new Date());
+  const pageData = {
+    Phase: phaseNames[phase.phase],
+  };
+
+  drawData(title, pageData, null, 35);
+  drawMoon(phase.phase, g.getWidth() / 2, g.getHeight() / 2);
+
+  let m = setWatch(() => {
+    let m = moonIndexPageMenu(gps);
+  }, BTN3, {repease: false, edge: "falling"});
+}
+
+
+function drawMoonTimesPage(gps, title) {
+  const times = SunCalc.getMoonTimes(new Date(), gps.lat, gps.lon);
+
+  const pageData = {
+    Rise: dateToTimeString(times.rise),
+    Set: dateToTimeString(times.set),
+  };
+
+  drawData(title, pageData, null, 105);
+  drawPoints();
+
+  // Draw the moon rise position
+  const risePos = SunCalc.getMoonPosition(times.rise, gps.lat, gps.lon);
+  const riseAzimuthDegrees = parseInt(risePos.azimuth * 180 / Math.PI);
+  drawPoint(riseAzimuthDegrees, 8, {r: 1, g: 1, b: 1});
+
+  // Draw the moon set position
+  const setPos = SunCalc.getMoonPosition(times.set, gps.lat, gps.lon);
+  const setAzimuthDegrees = parseInt(setPos.azimuth * 180 / Math.PI);
+  drawPoint(setAzimuthDegrees, 8, {r: 1, g: 1, b: 1});
+
+  let m = setWatch(() => {
+    let m = moonIndexPageMenu(gps);
+  }, BTN3, {repease: false, edge: "falling"});
+}
+
+function drawSunShowPage(gps, key, date) {
+  const pos = SunCalc.getPosition(date, gps.lat, gps.lon);
+
+  const hrs = ("0" + date.getHours()).substr(-2);
+  const mins = ("0" + date.getMinutes()).substr(-2);
+  const secs = ("0" + date.getMinutes()).substr(-2);
+  const time = `${hrs}:${mins}:${secs}`;
+
+  const azimuth = Number(pos.azimuth.toFixed(2));
+  const azimuthDegrees = parseInt(pos.azimuth * 180 / Math.PI);
+  const altitude = Number(pos.altitude.toFixed(2));
+
+  const pageData = {
+    Time: time,
+    Altitude: altitude,
+    Azimumth: azimuth,
+    Degrees: azimuthDegrees
+  };
+
+  drawData(key, pageData, null, 85);
+
+  drawPoints();
+
+  // Draw the suns position
+  drawPoint(azimuthDegrees, 8, {r: 1, g: 1, b: 0});
+
+  m = setWatch(() => {
+      m = sunIndexPageMenu(gps);
+  }, BTN3, {repeat: false, edge: "falling"});
+
+  return null;
+}
+
+function sunIndexPageMenu(gps) {
+    const sunTimes = SunCalc.getTimes(new Date(), gps.lat, gps.lon);
+
+    const sunMenu = {
+      "": {
+        "title": "-- Sun --",
+      },
+      "Current Pos": () => {
+        m = E.showMenu();
+        drawSunShowPage(gps, "Current Pos", new Date());
+      },
+    };
+
+    Object.keys(sunTimes).sort().reduce((menu, key) => {
+      const title = titlizeKey(key);
+      menu[title] = () => {
+        m = E.showMenu();
+        drawSunShowPage(gps, key, sunTimes[key]);
+      };
+      return menu;
+    }, sunMenu);
+
+    sunMenu["< Back"] = () => m = indexPageMenu(gps);
+
+    return E.showMenu(sunMenu);
+}
+
+
+function moonIndexPageMenu(gps) {
+    const moonMenu = {
+      "": {
+        "title": "-- Moon --",
+      },
+      "Times": () => {
+        m = E.showMenu();
+        drawMoonTimesPage(gps, "Times");
+      },
+      "Position": () => {
+        m = E.showMenu();
+        drawMoonPositionPage(gps, "Position");
+      },
+      "Illumination": () => {
+        m = E.showMenu();
+        drawMoonIlluminationPage(gps, "Illumination");
+      },
+      "< Back": () => m = indexPageMenu(gps),
+    };
+
+    return E.showMenu(moonMenu);
+}
+
+function indexPageMenu(gps) {
+  const menu = {
+    "": {
+      "title": "Select",
+    },
+    "Sun": () => {
+      m = sunIndexPageMenu(gps);
+    },
+    "Moon": () => {
+      m = moonIndexPageMenu(gps);
+    },
+    "< Exit": () => { load(); }
+  };
+
+  return E.showMenu(menu);
+}
+
+/**
+ * GPS wait page, shows GPS locating animation until it gets a lock, then moves to the Sun page
+ */
+function drawGPSWaitPage() {
+    const img = require("heatshrink").decompress(atob("mEwxH+AH4A/AH4AW43GF1wwsFwYwqFwowoFw4wmFxIwdE5YAPF/4vM5nN6YAE5vMF8YtHGIgvhFpQxKF7AuOGA4vXFyAwGF63MFyIABF6xeWMC4UDLwvNGpAJG5gwSdhIIDRBLyWCIgcJHAgJJDoouQF4vMQoICBBJoeGFx6GGACIfHL6YvaX6gvZeCIdFc4gAFXogvGFxgwFDwovQCAguOGAnMMBxeG5guTGAggGGAwNKFySREcA3N5vM5gDBdpQvXEY4AKXqovGGCKbFF7AwPZQwvZGJgtGF7vGdQItG5gSIF7gASF/44WEzgwRF0wwHF1AwFF1QwDF1gvwAH4A/AFAA=="))
+   
+    g.clear();
+    g.drawImage(img, 100, 50);
+    g.setFont("6x8", 1);
+    g.drawString("Astrocalc v0.01", 80, 105);
+    g.drawString("Locating GPS", 85, 140);
+    g.drawString("Please wait...", 80, 155);
+    g.flip();
+
+    const DEBUG = false;
+    if (DEBUG) {
+      const gps = {
+        "lat": 56.45783133333,
+        "lon": -3.02188583333,
+        "alt": 75.3,
+        "speed": 0.070376,
+        "course": NaN,
+        "time":new Date(),
+        "satellites": 4,
+        "fix": 1
+       };
+
+      m = indexPageMenu(gps);
+
+      return;
+    }
+
+    Bangle.on('GPS', (gps) => {
+        if (gps.fix === 0) return;
+
+        Bangle.setGPSPower(0);
+        Bangle.buzz();
+        Bangle.setLCDPower(true);
+
+        m = indexPageMenu(gps);
+    });
+}
+
+function init() {
+    Bangle.setGPSPower(1);
+    drawGPSWaitPage();
+}
+
+let m;
+init();

apps/astrocalc/astrocalc-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("mEwxH+AH4A/AH4AW43GF1wwsFwYwqFwowoFw4wmFxIwdE5YAPF/4vM5nN6YAE5vMF8YtHGIgvhFpQxKF7AuOGA4vXFyAwGF63MFyIABF6xeWMC4UDLwvNGpAJG5gwSdhIIDRBLyWCIgcJHAgJJDoouQF4vMQoICBBJoeGFx6GGACIfHL6YvaX6gvZeCIdFc4gAFXogvGFxgwFDwovQCAguOGAnMMBxeG5guTGAggGGAwNKFySREcA3N5vM5gDBdpQvXEY4AKXqovGGCKbFF7AwPZQwvZGJgtGF7vGdQItG5gSIF7gASF/44WEzgwRF0wwHF1AwFF1QwDF1gvwAH4A/AFAA=="))

apps/astrocalc/first-quarter-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgI1ygf4BZM/BZMD//wCxP/8AWJ/+ACxP+CxQ6ICwP/4AWJERAWCEQ4WCERAWCEQ4WDOg4WCNA4WD/gWKRYwWDHI4WDHIwWDHI4WDHIwWEOYwWDHIwWEKAwWD/4WKKAwWEKAoWEYgwWPM4wWEM4oWQM4oWEPwwWbPwoWESowW/C34WOZ1vACxP8Cyv4CxWACyoKFCwiUFCwhmGCwh9FCwhmGCwhmFCwhPGCwgKFCwg4GCwZPGCwg4GCwY4GCwgKGCwY4GCwZxGCwjBFCwghHCwQhHCwYhHCwQhHCwRlHCwSHHCwYKICwI3HCwQKJAFAA=="))

apps/astrocalc/full-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgJC/AD8B//4BRILJBQP/+AKGn4LC4AKFh4KC/4KFgYKD/gLFv4LD8AKEj4KD/+AEJAiGEIgiFIYhFFOAQADOghlDNA0HBQv+Q4wADRYZaFLgg4GHIg4GHIY4GHIhxFOYhxGOYgKHKARPHKARPHKAZPHKATBFYgoWKMw5nDMw5nCCyx9IPwQKIPwIW/C34WJZ1sDBQ/8CwM/BY/ACxkfBY+AgEBBQ/4CwJ+IBQJ+IPoJnIMwRnIMwJQIJ4RQIJ4JQIJ4RQIBQQ5HHAQ5HHAY5HHARzHOIRzHOIbEHYIIACLgpaDEQwhFEQohEIopDENAplERYwKGOgZwEBYoKIAH4AXA=="))

apps/astrocalc/last-quarter-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgI0xgP8BRP/4ALI/4WJv4WJj4WJg//CxA3BCxM/CxIhCCw4hCCxAhCCw4hCCxAKCCw5lBCxEDCxSHBCxA4DCw4KCCw44DCww4DCw5xCCw44DCw5PDCw0PCxQKDCwxPDCwzBDCyRmECwxmDCyRmDCwx9ECzoKDCwyUEC34W/CyDOtn4WJgYWVgIWKj4WVPwgWFSogWGM4gWGPwYWGM4gWGM4YWGKAgWGKAYWGHIgWGKAYWHHIYWGHIYWHHIYWGHIYWHOYYWHYgQWHEQYWHEQQWIEQQWHEQQWINAQWIRYIWIOgQWIHQIWJBYIWJAFI="))

apps/astrocalc/new-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgIGDh///4RHBQQLHg4KC/wKFgIKC//4BYt/BYfgBQkfBQf/wAsHFw4HCBwXwBQc/AwYLB4AhEIARIBEQn//gECgYiEIYJ2FIoQQBE4YzBDgd/NoguBNAUPKoo/BB4YhEEQIdCAYYiECQMHUwwHDEIweBLgMPWIwiBAQSlENwQTBDIQAFFQMDHAw5BOYN/HAwfB8ANCAAofCHA45B+EPHA4UBKQQAGMgMfUYQAFv+DJ45QCn5PHKAPDJ45QB/hmICwPnT4yhC/1/Mw5nBCxZmIM4P/PpB+BC34WEVZCsB/7CIYYIWWOX4WbfiwWL/gKHgf+n/ABY8/4YWJ/k/VhF/4LDIg/4j5nI/+APxEP+EPM48BCgN/KA5CBg5QHMwINCJ4/AgY5Hh4fBj45GHAKeBAQSfFMgIZCHAoqCv45GA4QOBEQsfDwQDDEIgSC/4iFv6dCg4iFj60Dn4iEEIKRCL4K5E/5uDh4QDDgKFEv4uDj4/EE4IRCDYIzEAwIvBAQKnFEQIADMIhFBAAayFNAIACMoZtDBYa9GFwbrHBQR2EBYoKEA=="))

apps/astrocalc/suncalc.js

@@ -0,0 +1,328 @@
+/*
+ (c) 2011-2015, Vladimir Agafonkin
+ SunCalc is a JavaScript library for calculating sun/moon position and light phases.
+ https://github.com/mourner/suncalc
+*/
+
+(function () { 'use strict';
+
+// shortcuts for easier to read formulas
+
+var PI   = Math.PI,
+    sin  = Math.sin,
+    cos  = Math.cos,
+    tan  = Math.tan,
+    asin = Math.asin,
+    atan = Math.atan2,
+    acos = Math.acos,
+    rad  = PI / 180;
+
+// sun calculations are based on http://aa.quae.nl/en/reken/zonpositie.html formulas
+
+
+// date/time constants and conversions
+
+var dayMs = 1000 * 60 * 60 * 24,
+    J1970 = 2440588,
+    J2000 = 2451545;
+
+function toJulian(date) { return date.valueOf() / dayMs - 0.5 + J1970; }
+function fromJulian(j)  { return (j + 0.5 - J1970) * dayMs; }
+function toDays(date)   { return toJulian(date) - J2000; }
+
+
+// general calculations for position
+
+var e = rad * 23.4397; // obliquity of the Earth
+
+function rightAscension(l, b) { return atan(sin(l) * cos(e) - tan(b) * sin(e), cos(l)); }
+function declination(l, b)    { return asin(sin(b) * cos(e) + cos(b) * sin(e) * sin(l)); }
+
+function azimuth(H, phi, dec)  { return atan(sin(H), cos(H) * sin(phi) - tan(dec) * cos(phi)); }
+function altitude(H, phi, dec) { return asin(sin(phi) * sin(dec) + cos(phi) * cos(dec) * cos(H)); }
+
+function siderealTime(d, lw) { return rad * (280.16 + 360.9856235 * d) - lw; }
+
+function astroRefraction(h) {
+    if (h < 0) // the following formula works for positive altitudes only.
+        h = 0; // if h = -0.08901179 a div/0 would occur.
+
+    // formula 16.4 of "Astronomical Algorithms" 2nd edition by Jean Meeus (Willmann-Bell, Richmond) 1998.
+    // 1.02 / tan(h + 10.26 / (h + 5.10)) h in degrees, result in arc minutes -> converted to rad:
+    return 0.0002967 / Math.tan(h + 0.00312536 / (h + 0.08901179));
+}
+
+// general sun calculations
+
+function solarMeanAnomaly(d) { return rad * (357.5291 + 0.98560028 * d); }
+
+function eclipticLongitude(M) {
+
+    var C = rad * (1.9148 * sin(M) + 0.02 * sin(2 * M) + 0.0003 * sin(3 * M)), // equation of center
+        P = rad * 102.9372; // perihelion of the Earth
+
+    return M + C + P + PI;
+}
+
+function sunCoords(d) {
+
+    var M = solarMeanAnomaly(d),
+        L = eclipticLongitude(M);
+
+    return {
+        dec: declination(L, 0),
+        ra: rightAscension(L, 0)
+    };
+}
+
+
+var SunCalc = {};
+
+
+// calculates sun position for a given date and latitude/longitude
+
+SunCalc.getPosition = function (date, lat, lng) {
+
+    var lw  = rad * -lng,
+        phi = rad * lat,
+        d   = toDays(date),
+
+        c  = sunCoords(d),
+        H  = siderealTime(d, lw) - c.ra;
+
+    return {
+        azimuth: azimuth(H, phi, c.dec),
+        altitude: altitude(H, phi, c.dec)
+    };
+};
+
+
+// sun times configuration (angle, morning name, evening name)
+
+var times = SunCalc.times = [
+    [-0.833, 'sunrise',       'sunset'      ],
+    [  -0.3, 'sunriseEnd',    'sunsetStart' ],
+    [    -6, 'dawn',          'dusk'        ],
+    [   -12, 'nauticalDawn',  'nauticalDusk'],
+    [   -18, 'nightEnd',      'night'       ],
+    [     6, 'goldenHourEnd', 'goldenHour'  ]
+];
+
+// adds a custom time to the times config
+
+SunCalc.addTime = function (angle, riseName, setName) {
+    times.push([angle, riseName, setName]);
+};
+
+
+// calculations for sun times
+
+var J0 = 0.0009;
+
+function julianCycle(d, lw) { return Math.round(d - J0 - lw / (2 * PI)); }
+
+function approxTransit(Ht, lw, n) { return J0 + (Ht + lw) / (2 * PI) + n; }
+function solarTransitJ(ds, M, L)  { return J2000 + ds + 0.0053 * sin(M) - 0.0069 * sin(2 * L); }
+
+function hourAngle(h, phi, d) { return acos((sin(h) - sin(phi) * sin(d)) / (cos(phi) * cos(d))); }
+function observerAngle(height) { return -2.076 * Math.sqrt(height) / 60; }
+
+// returns set time for the given sun altitude
+function getSetJ(h, lw, phi, dec, n, M, L) {
+
+    var w = hourAngle(h, phi, dec),
+        a = approxTransit(w, lw, n);
+    return solarTransitJ(a, M, L);
+}
+
+
+// calculates sun times for a given date, latitude/longitude, and, optionally,
+// the observer height (in meters) relative to the horizon
+
+SunCalc.getTimes = function (date, lat, lng, height) {
+
+    height = height || 0;
+
+    var lw = rad * -lng,
+        phi = rad * lat,
+
+        dh = observerAngle(height),
+
+        d = toDays(date),
+        n = julianCycle(d, lw),
+        ds = approxTransit(0, lw, n),
+
+        M = solarMeanAnomaly(ds),
+        L = eclipticLongitude(M),
+        dec = declination(L, 0),
+
+        Jnoon = solarTransitJ(ds, M, L),
+
+        i, len, time, h0, Jset, Jrise;
+
+
+    var result = {
+        solarNoon: new Date(fromJulian(Jnoon)),
+        nadir: new Date(fromJulian(Jnoon - 0.5))
+    };
+
+    for (i = 0, len = times.length; i < len; i += 1) {
+        time = times[i];
+        h0 = (time[0] + dh) * rad;
+
+        Jset = getSetJ(h0, lw, phi, dec, n, M, L);
+        Jrise = Jnoon - (Jset - Jnoon);
+
+        result[time[1]] = new Date(fromJulian(Jrise) - (dayMs / 2));
+        result[time[2]] = new Date(fromJulian(Jset) + (dayMs / 2));
+    }
+
+    return result;
+};
+
+
+// moon calculations, based on http://aa.quae.nl/en/reken/hemelpositie.html formulas
+
+function moonCoords(d) { // geocentric ecliptic coordinates of the moon
+
+    var L = rad * (218.316 + 13.176396 * d), // ecliptic longitude
+        M = rad * (134.963 + 13.064993 * d), // mean anomaly
+        F = rad * (93.272 + 13.229350 * d),  // mean distance
+
+        l  = L + rad * 6.289 * sin(M), // longitude
+        b  = rad * 5.128 * sin(F),     // latitude
+        dt = 385001 - 20905 * cos(M);  // distance to the moon in km
+
+    return {
+        ra: rightAscension(l, b),
+        dec: declination(l, b),
+        dist: dt
+    };
+}
+
+SunCalc.getMoonPosition = function (date, lat, lng) {
+
+    var lw  = rad * -lng,
+        phi = rad * lat,
+        d   = toDays(date),
+
+        c = moonCoords(d),
+        H = siderealTime(d, lw) - c.ra,
+        h = altitude(H, phi, c.dec),
+        // formula 14.1 of "Astronomical Algorithms" 2nd edition by Jean Meeus (Willmann-Bell, Richmond) 1998.
+        pa = atan(sin(H), tan(phi) * cos(c.dec) - sin(c.dec) * cos(H));
+
+    h = h + astroRefraction(h); // altitude correction for refraction
+
+    return {
+        azimuth: azimuth(H, phi, c.dec),
+        altitude: h,
+        distance: c.dist,
+        parallacticAngle: pa
+    };
+};
+
+
+// calculations for illumination parameters of the moon,
+// based on http://idlastro.gsfc.nasa.gov/ftp/pro/astro/mphase.pro formulas and
+// Chapter 48 of "Astronomical Algorithms" 2nd edition by Jean Meeus (Willmann-Bell, Richmond) 1998.
+
+// Function updated from gist: https://gist.github.com/endel/dfe6bb2fbe679781948c
+
+SunCalc.getMoonIllumination = function (date) {
+    let month = date.getMonth();
+    let year = date.getFullYear();
+    let day = date.getDate();
+
+    let c = 0;
+    let e = 0;
+    let jd = 0;
+    let b = 0;
+
+    if (month < 3) {
+      year--;
+      month += 12;
+    }
+
+    ++month;
+    c = 365.25 * year;
+    e = 30.6 * month;
+    jd = c + e + day - 694039.09; // jd is total days elapsed
+    jd /= 29.5305882; // divide by the moon cycle
+    b = parseInt(jd); // int(jd) -> b, take integer part of jd
+    jd -= b; // subtract integer part to leave fractional part of original jd
+    b = Math.round(jd * 8); // scale fraction from 0-8 and round
+
+    if (b >= 8) b = 0; // 0 and 8 are the same so turn 8 into 0
+
+    return {phase: b};
+};
+
+
+function hoursLater(date, h) {
+    return new Date(date.valueOf() + h * dayMs / 24);
+}
+
+// calculations for moon rise/set times are based on http://www.stargazing.net/kepler/moonrise.html article
+
+SunCalc.getMoonTimes = function (date, lat, lng, inUTC) {
+    var t = date;
+    if (inUTC) t.setUTCHours(0, 0, 0, 0);
+    else t.setHours(0, 0, 0, 0);
+
+    var hc = 0.133 * rad,
+        h0 = SunCalc.getMoonPosition(t, lat, lng).altitude - hc,
+        h1, h2, rise, set, a, b, xe, ye, d, roots, x1, x2, dx;
+
+    // go in 2-hour chunks, each time seeing if a 3-point quadratic curve crosses zero (which means rise or set)
+    for (var i = 1; i <= 24; i += 2) {
+        h1 = SunCalc.getMoonPosition(hoursLater(t, i), lat, lng).altitude - hc;
+        h2 = SunCalc.getMoonPosition(hoursLater(t, i + 1), lat, lng).altitude - hc;
+
+        a = (h0 + h2) / 2 - h1;
+        b = (h2 - h0) / 2;
+        xe = -b / (2 * a);
+        ye = (a * xe + b) * xe + h1;
+        d = b * b - 4 * a * h1;
+        roots = 0;
+
+        if (d >= 0) {
+            dx = Math.sqrt(d) / (Math.abs(a) * 2);
+            x1 = xe - dx;
+            x2 = xe + dx;
+            if (Math.abs(x1) <= 1) roots++;
+            if (Math.abs(x2) <= 1) roots++;
+            if (x1 < -1) x1 = x2;
+        }
+
+        if (roots === 1) {
+            if (h0 < 0) rise = i + x1;
+            else set = i + x1;
+
+        } else if (roots === 2) {
+            rise = i + (ye < 0 ? x2 : x1);
+            set = i + (ye < 0 ? x1 : x2);
+        }
+
+        if (rise && set) break;
+
+        h0 = h2;
+    }
+
+    var result = {};
+
+    if (rise) result.rise = hoursLater(t, rise);
+    if (set) result.set = hoursLater(t, set);
+
+    if (!rise && !set) result[ye > 0 ? 'alwaysUp' : 'alwaysDown'] = true;
+
+    return result;
+};
+
+
+// export as Node module / AMD module / browser variable
+if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = SunCalc;
+else if (typeof define === 'function' && define.amd) define(SunCalc);
+else global.SunCalc = SunCalc;
+
+}());

apps/astrocalc/waning-crescent-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgJC/ABHgBRN8BRMfwAKIg/4CxP/BRM/HBMH/wKIgP/4AhJ/ghJ/5PJ/5PJj4WJgf/+AWIv5mJHAIWJ/5mJHAJ9IHAIWJn59JHAJ9JJ4IWIh4WK/4WJJ4KUIYIKUJJ4IWIMwIWgMwIWIPoLCJCwLCICxYKBCxCUBC34W/Cya3WCxr8In78JgYWhj4WJgIWKPwP8SpXAM5IWJPwIWIKAIWJM4PgKBP+CxBQBCxA5CBRBQBYZA5CBRA5BSpA5CSpA5BCxJzBPxDEBPxIiBM5MDPxJFBM5IiBKBMBKBKLBKBMAhwKJAH4ABA="))

apps/astrocalc/waning-gibbous-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgI0xgP/wAKJ/wWI///+AKHv4LBEQ8fBQP8BQ0HBQP/8A3HAAQWGn4KCHIwhDHIwhE/AhJ//AEJJQGBQZQGMoQABRQsDCwhQFQ4RnHHAgWGBQhnFHAhnFHAoWFOIhnFHAp+FJ4oWEh4WKBQp+EJ4qVEYIgWRMwwWEMwoWLVghmFVgh9GCzYKGCwaUGC34W/CxzOtn4WJgYKF/wWK8AKCgIWKj4WVPwwWDSo38BQZnG4B+JCwhnGCwhnF/AKDKA2AKBIWEHIwKEKAqrDHI4KEHIp9EHIqUEHIxmEOYp9EYgxmEEQpmFEQoKFEQhmFEQhPGNAhPFRYg4GOggKHHQSIFBYghIAFQ="))

apps/astrocalc/waxing-crescent-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgJC/ABdwBRMD8ALJj+ABREB/wWJh/wBZN/4AKIg4iKn/4KBP/ERMfERMB/5FJj//NBP//hnJ/6LJ/45Jg45Kv45JCwI5Jn5zJPwI5JCwJQICwP/CxRQISoJQJSoLEICwRQICwJnICzJnIYYJ+JCzB+ICwKVJC34W/CxbOffgIWIfgXACxP8Cyv4CxWACyUDPpU/ShIWBPpIWBPpEHMxMAv5mJCwJPICwQKIYQI4IYQJPJCwI4ISgI4JSgIKICwI4Jn5xJSgLBIMwIhJg4hJMwIKJj4hJgJlJgE+BRMHBRIA+A"))

apps/astrocalc/waxing-gibbous-icon.js

@@ -0,0 +1 @@
+require("heatshrink").decompress(atob("rlcgI1yj/4BREH/4LJ/4LJj4LB8AKGgYKB/+ABY1/BQP+BQ0PCwQuHBQX/4A4IEQ8BCwYiGn4iJJ4YiHJ4QAB+CIGAAZoFBQn8MxCLHBQg5FMwY5GMwg5GCwo5EMwhzGPog5FCwxQECwv/PpJQFSghQFCwzEECyJnECwxnDVYoWFBQpnECwx+ECzp+DCwyVEC34W/CyDOt4AKCg4KF/gWDv4WQ/AWKwAWVBQcDShMAn5mJCwx9DCwxmEgJmJgEfJ5IWGBQasGHAisFJ4gWGHAh+FHAiVGBQhnFHAp+EOIhnGYIZnGEIpQEEIxnEEIpQEEIxQDMoo5EQ4o5FFgyKDBRAiBBRAApA="))