astronomia/es/sundial.js

/**
 * @copyright 2013 Sonia Keys
 * @copyright 2016 commenthol
 * @license MIT
 * @module sundial
 */
/**
 * Sundial: Chapter 58, Calculation of a Planar Sundial.
 */

import base from './base';

/**
 * Point return type represents a point to be used in constructing the sundial.
 */
function Point(x, y) {
  this.x = x || 0;
  this.y = y || 0;
}

/**
 * Line holds data to draw an hour line on the sundial.
 */
function Line(hour, points) {
  this.hour = hour; // 0 to 24
  this.points = points || []; // One or more points corresponding to the hour.
}

var m = [-23.44, -20.15, -11.47, 0, 11.47, 20.15, 23.44];

/**
 * General computes data for the general case of a planar sundial.
 *
 * Argument φ is geographic latitude at which the sundial will be located.
 * D is gnomonic declination, the azimuth of the perpendicular to the plane
 * of the sundial, measured from the southern meridian towards the west.
 * Argument a is the length of a straight stylus perpendicular to the plane
 * of the sundial, z is zenithal distance of the direction defined by the
 * stylus.  Angles φ, D, and z are in radians.  Units of stylus length a
 * are arbitrary.
 *
 * Results consist of a set of lines, a center point, u, the length of a
 * polar stylus, and ψ, the angle which the polar stylus makes with the plane
 * of the sundial.  The center point, the points defining the hour lines, and
 * u are in units of a, the stylus length.  ψ is in radians.
 */
export function general(φ, D, a, z) {
  // (φ, D, a, z float64)  (lines []Line, center Point, u, ψ float64)
  var _base$sincos = base.sincos(φ),
      sφ = _base$sincos[0],
      cφ = _base$sincos[1];

  var tφ = sφ / cφ;

  var _base$sincos2 = base.sincos(D),
      sD = _base$sincos2[0],
      cD = _base$sincos2[1];

  var _base$sincos3 = base.sincos(z),
      sz = _base$sincos3[0],
      cz = _base$sincos3[1];

  var P = sφ * cz - cφ * sz * cD;
  var lines = [];
  for (var i = 0; i < 24; i++) {
    var l = new Line(i);
    var H = (i - 12) * 15 * Math.PI / 180;
    var aH = Math.abs(H);

    var _base$sincos4 = base.sincos(H),
        sH = _base$sincos4[0],
        cH = _base$sincos4[1];

    for (var _iterator = m, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var d = _ref;

      var tδ = Math.tan(d * Math.PI / 180);
      var H0 = Math.acos(-tφ * tδ);
      if (aH > H0) {
        continue; // sun below horizon
      }
      var Q = sD * sz * sH + (cφ * cz + sφ * sz * cD) * cH + P * tδ;
      if (Q < 0) {
        continue; // sun below plane of sundial
      }
      var Nx = cD * sH - sD * (sφ * cH - cφ * tδ);
      var Ny = cz * sD * sH - (cφ * sz - sφ * cz * cD) * cH - (sφ * sz + cφ * cz * cD) * tδ;
      l.points.push(new Point(a * Nx / Q, a * Ny / Q));
    }
    if (l.points.length > 0) {
      lines.push(l);
    }
  }
  var center = new Point();
  center.x = a / P * cφ * sD;
  center.y = -a / P * (sφ * sz + cφ * cz * cD);
  var aP = Math.abs(P);
  var u = a / aP;
  var ψ = Math.asin(aP);
  return {
    lines: lines,
    center: center,
    length: u,
    angle: ψ
  };
}

/**
 * Equatorial computes data for a sundial level with the equator.
 *
 * Argument φ is geographic latitude at which the sundial will be located;
 * a is the length of a straight stylus perpendicular to the plane of the
 * sundial.
 *
 * The sundial will have two sides, north and south.  Results n and s define
 * lines on the north and south sides of the sundial.  Result coordinates
 * are in units of a, the stylus length.
 */
export function equatorial(φ, a) {
  // (φ, a float64)  (n, s []Line)
  var tφ = Math.tan(φ);
  var n = [];
  var s = [];
  for (var i = 0; i < 24; i++) {
    var nl = new Line(i);
    var sl = new Line(i);
    var H = (i - 12) * 15 * Math.PI / 180;
    var aH = Math.abs(H);

    var _base$sincos5 = base.sincos(H),
        sH = _base$sincos5[0],
        cH = _base$sincos5[1];

    for (var _iterator2 = m, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
      var _ref2;

      if (_isArray2) {
        if (_i2 >= _iterator2.length) break;
        _ref2 = _iterator2[_i2++];
      } else {
        _i2 = _iterator2.next();
        if (_i2.done) break;
        _ref2 = _i2.value;
      }

      var d = _ref2;

      var tδ = Math.tan(d * Math.PI / 180);
      var H0 = Math.acos(-tφ * tδ);
      if (aH > H0) {
        continue;
      }
      var x = -a * sH / tδ;
      var yy = a * cH / tδ;
      if (tδ < 0) {
        sl.points.push(new Point(x, yy));
      } else {
        nl.points.push(new Point(x, -yy));
      }
    }
    if (nl.points.length > 0) {
      n.push(nl);
    }
    if (sl.points.length > 0) {
      s.push(sl);
    }
  }
  return {
    north: n,
    south: s
  };
}

/**
 * Horizontal computes data for a horizontal sundial.
 *
 * Argument φ is geographic latitude at which the sundial will be located,
 * a is the length of a straight stylus perpendicular to the plane of the
 * sundial.
 *
 * Results consist of a set of lines, a center point, and u, the length of a
 * polar stylus.  They are in units of a, the stylus length.
 */
export function horizontal(φ, a) {
  // (φ, a float64)  (lines []Line, center Point, u float64)
  var _base$sincos6 = base.sincos(φ),
      sφ = _base$sincos6[0],
      cφ = _base$sincos6[1];

  var tφ = sφ / cφ;
  var lines = [];
  for (var i = 0; i < 24; i++) {
    var l = new Line(i);
    var H = (i - 12) * 15 * Math.PI / 180;
    var aH = Math.abs(H);

    var _base$sincos7 = base.sincos(H),
        sH = _base$sincos7[0],
        cH = _base$sincos7[1];

    for (var _iterator3 = m, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
      var _ref3;

      if (_isArray3) {
        if (_i3 >= _iterator3.length) break;
        _ref3 = _iterator3[_i3++];
      } else {
        _i3 = _iterator3.next();
        if (_i3.done) break;
        _ref3 = _i3.value;
      }

      var d = _ref3;

      var tδ = Math.tan(d * Math.PI / 180);
      var H0 = Math.acos(-tφ * tδ);
      if (aH > H0) {
        continue; // sun below horizon
      }
      var Q = cφ * cH + sφ * tδ;
      var x = a * sH / Q;
      var y = a * (sφ * cH - cφ * tδ) / Q;
      l.points.push(new Point(x, y));
    }
    if (l.points.length > 0) {
      lines.push(l);
    }
  }
  var center = new Point(0, -a / tφ);
  var u = a / Math.abs(sφ);
  return {
    lines: lines,
    center: center,
    length: u
  };
}

/**
 * Vertical computes data for a vertical sundial.
 *
 * Argument φ is geographic latitude at which the sundial will be located.
 * D is gnomonic declination, the azimuth of the perpendicular to the plane
 * of the sundial, measured from the southern meridian towards the west.
 * Argument a is the length of a straight stylus perpendicular to the plane
 * of the sundial.
 *
 * Results consist of a set of lines, a center point, and u, the length of a
 * polar stylus.  They are in units of a, the stylus length.
 */
export function vertical(φ, D, a) {
  // (φ, D, a float64)  (lines []Line, center Point, u float64)
  var _base$sincos8 = base.sincos(φ),
      sφ = _base$sincos8[0],
      cφ = _base$sincos8[1];

  var tφ = sφ / cφ;

  var _base$sincos9 = base.sincos(D),
      sD = _base$sincos9[0],
      cD = _base$sincos9[1];

  var lines = [];
  for (var i = 0; i < 24; i++) {
    var l = new Line(i);
    var H = (i - 12) * 15 * Math.PI / 180;
    var aH = Math.abs(H);

    var _base$sincos10 = base.sincos(H),
        sH = _base$sincos10[0],
        cH = _base$sincos10[1];

    for (var _iterator4 = m, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
      var _ref4;

      if (_isArray4) {
        if (_i4 >= _iterator4.length) break;
        _ref4 = _iterator4[_i4++];
      } else {
        _i4 = _iterator4.next();
        if (_i4.done) break;
        _ref4 = _i4.value;
      }

      var d = _ref4;

      var tδ = Math.tan(d * Math.PI / 180);
      var H0 = Math.acos(-tφ * tδ);
      if (aH > H0) {
        continue; // sun below horizon
      }
      var Q = sD * sH + sφ * cD * cH - cφ * cD * tδ;
      if (Q < 0) {
        continue; // sun below plane of sundial
      }
      var x = a * (cD * sH - sφ * sD * cH + cφ * sD * tδ) / Q;
      var y = -a * (cφ * cH + sφ * tδ) / Q;
      l.points.push(new Point(x, y));
    }
    if (l.points.length > 0) {
      lines.push(l);
    }
  }
  var center = new Point();
  center.x = -a * sD / cD;
  center.y = a * tφ / cD;
  var u = a / Math.abs(cφ * cD);
  return {
    lines: lines,
    center: center,
    length: u
  };
}

export default {
  general: general,
  equatorial: equatorial,
  horizontal: horizontal,
  vertical: vertical
};