sun_calc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a3f04d3ad8fb0b03c8aa0944f880e38aef08d21
+  data.tar.gz: fbfa83fc6d4e7b9a6d1507cb5d6d5e39c34b0ab1
+SHA512:
+  metadata.gz: 647287232b4fa0ba2548789ca692811bb222a71ee883910e23207f8cd249519870134508e5c62c2c57fcaf3b9b05418409f28fc2fdbd595b0f9811b4923862ac
+  data.tar.gz: b9acc4bc213f343686ec17a265a52239cec0b4a656767fd63cd949e338c8758282a85fe1a578dca697532621c24b98747528a194ca40206584a19ed8cc8d8717

data/LICENSE

@@ -0,0 +1,49 @@
+MIT License
+
+Copyright (c) 2018, Fishbrain AB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+License for original art (https://github.com/mourner/suncalc):
+
+BSD 2-Clause "Simplified" License
+
+Copyright (c) 2014, Vladimir Agafonkin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,36 @@
+# sun\_calc
+
+[![Build Status](https://travis-ci.com/fishbrain/sun_calc.svg?token=AahQSHRoAYGzTHE366Lz&branch=master)](https://travis-ci.com/fishbrain/sun_calc)
+
+A Ruby library, translated from the
+[SunCalc](https://github.com/mourner/suncalc) JavaScript library, for
+calculating sun positions, sunlight phases, moon positions, and lunar phase for
+a given time and location.
+
+## Installing
+
+```
+gem install sun_calc
+```
+
+## Using
+
+```ruby
+require 'sun_calc'
+SunCalc.sun_position(Time.now, 59.3345, 18.0662)
+#=> {:azimuth=>0.5724083892517442, :altitude=>0.6713233729313038}
+```
+
+The library shares a similar API as the JavaScript library.
+
+| JavaScript        | Ruby            |
+|-------------------|-----------------|
+| `getPosition`     | `sun_position`  |
+| `getTimes`        | `sun_times`     |
+| `addTime`         | `add_sun_time`  |
+| `getMoonPosition` | `moon_position` |
+| `getMoonTimes`    | `moon_times`    |
+
+## Maintainer
+
+- Alexander Cederblad (<mailto:alexander@fishbrain.com>)

data/lib/sun_calc/constants.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class SunCalc
+  ONE_RADIAN = Math::PI / 180
+  ONE_DAY_IN_SECONDS = 60 * 60 * 24
+  J0 = 0.0009
+  J1970 = 2_440_588
+  J2000 = 2_451_545
+  OBLIQUITY_OF_THE_EARTH = ONE_RADIAN * 23.4397
+end

data/lib/sun_calc/helpers.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class SunCalc
+  # :nodoc:
+  module Helpers
+    def to_julian(date)
+      date.to_f / ONE_DAY_IN_SECONDS - 0.5 + J1970
+    end
+
+    def from_julian(j)
+      Time.at((j + 0.5 - J1970) * ONE_DAY_IN_SECONDS).utc
+    end
+
+    def to_days(date)
+      to_julian(date) - J2000
+    end
+
+    def right_ascension(l, b)
+      Math.atan2(
+        Math.sin(l) * Math.cos(OBLIQUITY_OF_THE_EARTH) -
+          Math.tan(b) * Math.sin(OBLIQUITY_OF_THE_EARTH),
+        Math.cos(l)
+      )
+    end
+
+    def declination(l, b)
+      Math.asin(Math.sin(b) * Math.cos(OBLIQUITY_OF_THE_EARTH) +
+        Math.cos(b) * Math.sin(OBLIQUITY_OF_THE_EARTH) * Math.sin(l))
+    end
+
+    def azimuth(h, phi, dec)
+      Math.atan2(Math.sin(h),
+                 Math.cos(h) * Math.sin(phi) - Math.tan(dec) * Math.cos(phi))
+    end
+
+    def altitude(h, phi, dec)
+      Math.asin(Math.sin(phi) * Math.sin(dec) +
+                Math.cos(phi) * Math.cos(dec) * Math.cos(h))
+    end
+
+    def sidereal_time(d, lw)
+      ONE_RADIAN * (280.16 + 360.9856235 * d) - lw
+    end
+
+    def astro_refraction(h)
+      # The following formula works for positive altitudes only.
+      h = 0 if h < 0
+      # Based on forumla 16.4 of "Astronomical Algorithms" 2nd edition by Jean
+      # Meeus (Willmann-Bell, Richmond) 1998.
+      0.0002967 / Math.tan(h + 0.00312536 / (h + 0.08901179))
+    end
+
+    def solar_mean_anomaly(d)
+      ONE_RADIAN * (357.5291 + 0.98560028 * d)
+    end
+
+    def ecliptic_longitude(m)
+      # Equation of center.
+      c = ONE_RADIAN * (1.9148 * Math.sin(m) +
+                        0.02 * Math.sin(2 * m) + 0.0003 * Math.sin(3 * m))
+      # Perihelion of Earth.
+      p = ONE_RADIAN * 102.9372
+      m + c + p + Math::PI
+    end
+
+    def sun_coords(d)
+      m = solar_mean_anomaly(d)
+      l = ecliptic_longitude(m)
+      { dec: declination(l, 0),
+        ra: right_ascension(l, 0) }
+    end
+
+    def julian_cycle(d, lw)
+      (d - J0 - lw / (2 * Math::PI)).round
+    end
+
+    def approx_transit(ht, lw, n)
+      J0 + (ht + lw) / (2 * Math::PI) + n
+    end
+
+    def solar_transit_j(ds, m, l)
+      J2000 + ds + 0.0053 * Math.sin(m) - 0.0069 * Math.sin(2 * l)
+    end
+
+    def hour_angle(h0, phi, dec)
+      Math.acos(
+        (Math.sin(h0) - Math.sin(phi) * Math.sin(dec)) /
+        (Math.cos(phi) * Math.cos(dec))
+      )
+    end
+
+    def get_set_j(h0, lw, phi, dec, n, m, l)
+      w = hour_angle(h0, phi, dec)
+      a = approx_transit(w, lw, n)
+      solar_transit_j(a, m, l)
+    end
+
+    def moon_coords(d)
+      # Geocentric ecliptic coordinates of the moon
+      l  = ONE_RADIAN * (218.316 + 13.176396 * d) # ecliptic longitude
+      m  = ONE_RADIAN * (134.963 + 13.064993 * d) # mean anomaly
+      f  = ONE_RADIAN * (93.272 + 13.229350 * d)  # mean distance
+      l += ONE_RADIAN * 6.289 * Math.sin(m) # longitude
+      b  = ONE_RADIAN * 5.128 * Math.sin(f) # latitude
+      dt = 385_001 - 20_905 * Math.cos(m) # distance to the moon in km
+      { ra: right_ascension(l, b),
+        dec: declination(l, b),
+        dist: dt }
+    end
+
+    def hours_later(date, h)
+      Time.at(date.to_f + h * ONE_DAY_IN_SECONDS / 24).utc
+    end
+  end
+end

data/lib/sun_calc/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# :nodoc:
+class SunCalc
+  VERSION = '0.0.1'.freeze
+end

data/lib/sun_calc.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require 'sun_calc/constants'
+require 'sun_calc/helpers'
+
+# SunCalc provides methods for calculating sun/moon positions and phases.
+#
+# Most of the formulas are based on:
+# - http://aa.quae.nl/en/reken/zonpositie.html
+# - http://aa.quae.nl/en/reken/hemelpositie.html
+class SunCalc
+  extend Helpers
+
+  # Sun times configuration (angle, morning name, evening name).
+  DEFAULT_SUN_TIMES = [
+    [-0.833, 'sunrise', 'sunset'],
+    [-0.3, 'sunrise_end', 'sunset_start'],
+    [-6, 'dawn', 'dusk'],
+    [-12, 'nautical_dawn', 'nautical_dusk'],
+    [-18, 'night_end', 'night_start'],
+    [6, 'golden_hour_end', 'golden_hour_start']
+  ].freeze
+
+  @__sun_times__ = DEFAULT_SUN_TIMES.dup
+
+  # Calculates sun position for a given date, latitude, and longitude.
+  def self.sun_position(date, lat, lng)
+    lw  = ONE_RADIAN * -lng
+    phi = ONE_RADIAN * lat
+    d   = to_days(date)
+    c   = sun_coords(d)
+    h   = sidereal_time(d, lw) - c[:ra]
+    { azimuth: azimuth(h, phi, c[:dec]),
+      altitude: altitude(h, phi, c[:dec]) }
+  end
+
+  # Calculates sun times for a given date, latitude, and longitude.
+  def self.sun_times(date, lat, lng)
+    lw     = ONE_RADIAN * -lng
+    phi    = ONE_RADIAN * lat
+    d      = to_days(date)
+    n      = julian_cycle(d, lw)
+    ds     = approx_transit(0, lw, n)
+    m      = solar_mean_anomaly(ds)
+    l      = ecliptic_longitude(m)
+    dec    = declination(l, 0)
+    j_noon = solar_transit_j(ds, m, l)
+    { solar_noon: from_julian(j_noon),
+      nadir: from_julian(j_noon - 0.5) }.tap do |result|
+      @__sun_times__.each do |time|
+        begin
+          j_set = get_set_j(time[0] * ONE_RADIAN, lw, phi, dec, n, m, l)
+          j_rise = j_noon - (j_set - j_noon)
+          result[time[1].to_sym] = from_julian(j_rise)
+          result[time[2].to_sym] = from_julian(j_set)
+        rescue Math::DomainError
+          result[time[1].to_sym] = nil
+          result[time[2].to_sym] = nil
+        end
+      end
+    end
+  end
+
+  # Adds a custom time to the times configuration.
+  def self.add_sun_time(angle, rise_name, set_name)
+    @__sun_times__.push([angle, rise_name, set_name])
+  end
+
+  # Calculates moon position for a gived date, latitude, and longitude.
+  def self.moon_position(date, lat, lng)
+    lw  = ONE_RADIAN * -lng
+    phi = ONE_RADIAN * lat
+    d   = to_days(date)
+    c   = moon_coords(d)
+    h_  = sidereal_time(d, lw) - c[:ra]
+    h   = altitude(h_, phi, c[:dec])
+    # Formula 14.1 from "Astronomical Algorithms" 2nd edition by Jean Meeus
+    # (Willmann-Bell, Richmond) 1998.
+    pa  = Math.atan2(Math.sin(h_),
+                     Math.tan(phi) * Math.cos(c[:dec]) -
+                       Math.sin(c[:dec]) * Math.cos(h_))
+    h += astro_refraction(h) # altitude correction for refraction
+
+    { azimuth: azimuth(h_, phi, c[:dec]),
+      altitude: h,
+      distance: c[:dist],
+      parallacticAngle: pa }
+  end
+
+  # Calculates moon times for a given date, latitude, and longitude.
+  #
+  # Calculations for moon rise and set times are based on:
+  # - http://www.stargazing.net/kepler/moonrise.html
+  def self.moon_times(date, lat, lng)
+    t = Time.utc(date.year, date.month, date.day)
+    hc = 0.133 * ONE_RADIAN
+    h0 = SunCalc.moon_position(t, lat, lng)[:altitude] - hc
+    ye = 0
+    rise = nil
+    set = nil
+    # Iterate in 2-hour steps checking if a 3-point quadratic curve crosses zero
+    # (which means rise or set).
+    (1...24).step(2).each do |i|
+      h1 = SunCalc.moon_position(hours_later(t, i), lat, lng)[:altitude] - hc
+      h2 = SunCalc.moon_position(
+        hours_later(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
+      x1 = 0
+      x2 = 0
+      if d >= 0
+        dx = Math.sqrt(d) / (a.abs * 2)
+        x1 = xe - dx
+        x2 = xe + dx
+        roots += 1 if x1.abs <= 1
+        roots += 1 if x2.abs <= 1
+        x1 = x2 if x1 < -1
+      end
+      if roots == 1
+        if h0 < 0
+          rise = i + x1
+        else
+          set = i + x1
+        end
+      elsif roots == 2
+        rise = i + (ye < 0 ? x2 : x1)
+        set = i + (ye < 0 ? x1 : x2)
+      end
+      break if rise && set
+      h0 = h2
+    end
+    {}.tap do |result|
+      result[:moonrise] = hours_later(t, rise) if rise
+      result[:moonset] = hours_later(t, set) if set
+      result[ye > 0 ? :always_up : :always_down] = true if !rise && !set
+    end
+  end
+
+  # Calculates illumination parameters for the moon for a given date.
+  #
+  # Formulas are based on:
+  # - http://idlastro.gsfc.nasa.gov/ftp/pro/astro/mphase.pro
+  # - Chapter 48 of "Astronomical Algorithms" 2nd edition by Jean Meeus
+  #   (Willmann-Bell, Richmond) 1998.
+  def self.moon_illumination(date = Time.now)
+    d = to_days(date)
+    s = sun_coords(d)
+    m = moon_coords(d)
+    sdist = 149_598_000 # Distance from Earth to Sun in kilometers
+    phi = Math.acos(Math.sin(s[:dec]) * Math.sin(m[:dec]) +
+               Math.cos(s[:dec]) * Math.cos(m[:dec]) * Math.cos(s[:ra] -
+                                                                m[:ra]))
+    inc = Math.atan2(sdist * Math.sin(phi), m[:dist] - sdist * Math.cos(phi))
+    angle = Math.atan2(Math.cos(s[:dec]) * Math.sin(s[:ra] - m[:ra]),
+                       Math.sin(s[:dec]) * Math.cos(m[:dec]) -
+                         Math.cos(s[:dec]) * Math.sin(m[:dec]) *
+                           Math.cos(s[:ra] - m[:ra]))
+    { fraction: (1 + Math.cos(inc)) / 2,
+      phase: 0.5 + 0.5 * inc * (angle < 0 ? -1 : 1) / Math::PI,
+      angle: angle }
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: sun_calc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexander Cederblad
+- Fishbrain AB
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-04 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- alexander@fishbrain.com
+- developer@fishbrain.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.markdown
+- lib/sun_calc.rb
+- lib/sun_calc/constants.rb
+- lib/sun_calc/helpers.rb
+- lib/sun_calc/version.rb
+homepage: https://www.github.com/fishbrain/sun_calc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Library for calculating sun/moon positions and phases.
+test_files: []