suncalc 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec49609bd57c26eb9641e01e94e2fd9bdf43fe1c
+  data.tar.gz: 49800b56abb05f9e98a82054b981821e52846ac2
+SHA512:
+  metadata.gz: eb35b29bb651e268853f01c0b484e5550bcb9dcf9fd4c45d9ee60b2e69b3702c95f35a3440e1ab2b7d506696a300e8aec233894e115b8b985f3a2ba0b4678f54
+  data.tar.gz: ed6add76cedfd70c0f218a9a3c3d8f052364621382c490154ae9cd0991fd52fcce758c1800e3e6648d9d7d7c01913d59c996b6db4efad6652cd92fab17d71d9a

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in suncalc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Greg Mundy
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,34 @@
+# SunCalc
+
+SunCalc is a tiny Ruby library for calculating sun position, 
+sunlight phases (times for sunrise, sunset, dusk, etc.), moon position and
+lunar phase for the given location and time. This library is a port of 
+[Vladmir Agafonkin](http://agafonkin.com/en)'s ([@mourner](https://github.com/mourner)) excellent SunCalc.js library.  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'suncalc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install suncalc
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/suncalc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+Dir.glob('tasks/**/*.rake').each(&method(:import))

data/lib/suncalc.rb

@@ -0,0 +1,290 @@
+require "suncalc/version"
+
+module SunCalc
+    # Shortcuts for easier to read equations
+    RAD = Math::PI / 180
+    DAY_MS = 1000 * 60 * 60 * 24
+    J1970 = 2440588
+    J2000 = 2451545
+    E = RAD * 23.4397
+    J0 = 0.0009
+    SDIST = 149598000
+    HC = 0.133 * RAD
+
+    TIMES = [
+        [-0.833, :sunrise, :sunset],
+        [-0.3, :sunrise_end, :sunset_start],
+        [-6, :dawn, :dusk],
+        [-12, :nautical_dawn, :nautical_dusk],
+        [-18, :night_end, :night],
+        [6, :golden_hour_end, :golden_hour]
+    ]
+
+    # Date/time constants and conversions
+    
+    def self.to_julian(date)
+        (date.to_f * 1000) / DAY_MS - 0.5 + J1970
+    end
+
+    def self.from_julian(j)
+        Time.at(((j + 0.5 - J1970) * DAY_MS)/1000).utc
+    end
+
+    def self.to_days(date)
+        to_julian(date) - J2000
+    end
+
+
+    # General calculations for position
+
+    def self.right_ascension(l, b)
+        Math::atan2(Math::sin(l) * Math::cos(E) - Math::tan(b) * Math::sin(E), Math::cos(l))
+    end
+
+    def self.declination(l, b)
+        Math::asin(Math::sin(b) * Math::cos(E) + Math::cos(b) * Math::sin(E) * Math::sin(l))
+    end
+
+    def self.azimuth(h, phi, dec)
+        Math::atan2(Math::sin(h), Math::cos(h) * Math::sin(phi) - Math::tan(dec) * Math::cos(phi))
+    end
+
+    def self.altitude(h, phi, dec)
+        Math::asin(Math::sin(phi) * Math::sin(dec) + Math::cos(phi) * Math::cos(dec) * Math::cos(h))
+    end
+
+    def self.sidereal_time(d, lw)
+        RAD * (280.16 + 360.9856235 * d) - lw
+    end
+
+    # General sun calculations
+    def self.solar_mean_anomaly(d)
+        RAD * (357.5291 + 0.98560028 * d)
+    end
+
+    def self.ecliptic_longitude(m)
+        c = RAD * (1.9148 * Math::sin(m) + 0.02 * Math::sin(2 * m) + 0.0003 * Math::sin(3 * m))
+        p = RAD * 102.9372
+
+        m + c + p + Math::PI
+    end
+
+    def self.sun_coords(d)
+        @result = []
+        sM = solar_mean_anomaly(d)
+        eL = ecliptic_longitude(sM)
+
+
+        { :dec => declination(eL, 0),
+          :ra => right_ascension(eL, 0)
+        }
+    end
+
+    # Calculate sun position for a given date and latitude/longitude
+    def self.get_position(date, lat, lng)
+        lw = RAD * -lng
+        phi = RAD * 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
+
+    # Sun times configuration (angle, morning name, evening name)
+
+    def self.add_time(angle, rise_name, set_name)
+        TIMES << [angle, rise_name, set_name]
+    end
+
+    # Calculations for sun times
+    def self.julian_cycle(d, lw)
+        (d - J0 - lw / (2 * Math::PI)).round
+    end
+
+    def self.approx_transit(ht, lw, n)
+        J0 + (ht + lw) / (2 * Math::PI) + n
+    end
+
+    def self.solar_transit_j(ds, m, l)
+        J2000 + ds + 0.0053 * Math::sin(m) - 0.0069 * Math::sin(2 * l)
+    end
+
+    def self.hour_angle(h, phi, d)
+        Math::acos((Math::sin(h) - Math::sin(phi) * Math::sin(d)) / (Math::cos(phi) * Math::cos(d)))
+    end
+
+    # Returns set time for the given sun altitude
+    def self.get_set_j(h, lw, phi, dec, n, m, l)
+        w = hour_angle(h, phi, dec)
+        a = approx_transit(w, lw, n)
+        solar_transit_j(a, m, l)
+    end
+
+    # Calculate sun times for a given date and latitude/longitude
+    def self.get_times(date, lat, lng)
+        lw = RAD * -lng
+        phi = RAD * 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)
+
+        jnoon = solar_transit_j(ds, m, l)
+
+        result = {
+            :solar_noon => from_julian(jnoon),
+            :nadir => from_julian(jnoon - 0.5)
+        }
+
+        TIMES.each do |time|
+            jset = get_set_j(time[0] * RAD, lw, phi, dec, n, m, l)
+            jrise = jnoon - (jset - jnoon)
+           
+            result[time[1]] = from_julian(jrise)
+            result[time[2]] = from_julian(jset)
+        end
+
+        result
+    end
+
+    # Moon calculations
+    def self.moon_coords(d)
+        el = RAD * (218.316 + 13.176396 * d)
+        m = RAD * (134.963 + 13.064993 * d)
+        f = RAD * (93.272 + 13.229350 * d)
+
+        l = el + RAD * 6.289 * Math::sin(m)
+        b = RAD * 5.128 * Math::sin(f)
+        dt = 385001 - 20905 * Math::cos(m)
+        
+
+        result = {
+            :ra => right_ascension(l, b),
+            :dec => declination(l, b),
+            :dist => dt
+        }
+
+        result
+    end
+
+    def self.get_moon_position(date, lat, lng)
+        lw = RAD * -lng
+        phi = RAD * lat
+        d = to_days(date)
+
+        c = moon_coords(d)
+        th = sidereal_time(d, lw) - c[:ra]
+        h = altitude(th, phi, c[:dec])
+        
+        h = h + RAD * 0.017 / Math::tan(h + RAD * 10.26 / (h + RAD * 5.10))
+        
+        result = {
+            :azimuth => azimuth(th, phi, c[:dec]),
+            :altitude => h,
+            :distance => c[:dist]
+        }
+
+        result
+    end
+
+    # Calculations for illumination parameters of the moon
+    def self.get_moon_illumination(date)
+        d = to_days(date)
+        s = sun_coords(d)
+        m = moon_coords(d)
+
+        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]))
+
+        result = {
+            :fraction => (1 + Math::cos(inc)) / 2,
+            :phase => 0.5 + 0.5 * inc * (angle < 0 ? -1 : 1) / Math::PI,
+            :angle => angle
+        }
+
+        result
+    end
+
+    def self.hours_later(date, h)
+        Time.at(date.to_f + (h * (DAY_MS/1000)) / 24).utc 
+    end
+
+    def self.get_moon_times(date, lat, lng)
+        t = Time.new(date.year.to_i, date.month.to_i, date.day.to_i).utc
+        h0 = get_moon_position(t, lat, lng)[:altitude] - HC
+
+        rise = false
+        set = false
+        ye = 0
+
+        (1..24).step(2) do |i|
+            h1 = get_moon_position(hours_later(t, i), lat, lng)[:altitude] - HC
+            h2 = get_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
+
+            if d >= 0
+                dx = Math::sqrt(d) / (a.abs * 2)
+
+                x1 = xe - dx
+                x2 = xe + dx
+
+                if x1.abs <= 1 
+                    roots += 1
+                end
+                
+                if x2.abs <= 1
+                    roots += 1
+                end
+
+                if x1 < -1
+                    x1 = x2
+                end
+            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 and set
+
+            h0 = h2
+        end
+
+        result = {}
+        if rise
+            result[:rise] = hours_later(t, rise)
+        end
+        
+        if set
+            result[:set] = hours_later(t, set)
+        end
+
+        if not rise and not set
+            result[ye > 0 ? :alwaysUp : :alwaysDown] = true
+        end
+
+        result
+    end
+end

data/lib/suncalc/version.rb

@@ -0,0 +1,3 @@
+module SunCalc
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'suncalc'
+
+LAT = 50.5
+LNG = 30.5
+DATE = Time.utc(2013,03,05)
+
+TEST_TIMES = { 
+    :solar_noon => Time.utc(2013,03,05,10,10,57),
+    :nadir => Time.utc(2013,03,04,22,10,57),
+    :sunrise => Time.utc(2013,03,05,04,34,56),
+    :sunset => Time.utc(2013,03,05,15,46,57),
+    :sunrise_end => Time.utc(2013,03,05,04,38,19),
+    :sunset_start => Time.utc(2013,03,05,15,43,34),
+    :dawn => Time.utc(2013,03,05,04,02,17),
+    :dusk => Time.utc(2013,03,05,16,19,36),
+    :nautical_dawn => Time.utc(2013,03,05,03,24,31),
+    :nautical_dusk => Time.utc(2013,03,05,16,57,22),
+    :night_end => Time.utc(2013,03,05,02,46,17),
+    :night => Time.utc(2013,03,05,17,35,36),
+    :golden_hour_end => Time.utc(2013,03,05,05,19,01),
+    :golden_hour => Time.utc(2013,03,05,15,02,52)
+}
+
+MOON_RISE = Time.utc(2013,03,04,23,57,55)
+MOON_SET = Time.utc(2013, 03, 05,8,41,31)
+
+def near(val1, val2, margin)
+    @compare = margin.nil? ? 0.000000000000001 : margin
+    (val1 - val2).abs < @compare
+end

data/spec/suncalc_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe SunCalc do
+    it "calculates azimuth and altitude for the given time and location" do
+        @sun_pos = SunCalc.get_position(DATE, LAT, LNG)
+        expect(near(@sun_pos[:azimuth], -2.5003175907168385, nil)).to be true 
+        expect(near(@sun_pos[:altitude], -0.7000406838781611, nil)).to be true
+    end
+
+    it "can return sun phases for the given date and location" do
+        @times = SunCalc.get_times(DATE, LAT, LNG)
+
+        TEST_TIMES.each do |k,v|
+            expect(@times[k].to_s).to eq(v.to_s)
+        end
+    end
+
+    it "can return moon position data given time and location" do
+        @moon_pos = SunCalc.get_moon_position(DATE, LAT, LNG)
+        expect(near(@moon_pos[:azimuth], -0.9783999522438226, nil)).to be true
+        expect(near(@moon_pos[:altitude], 0.006969727754891917, nil)).to be true
+        expect(near(@moon_pos[:distance], 364121.37256256194, nil)).to be true
+    end
+
+    it "can return fraction and angle of moon's illuminated limb and phase" do
+        @moon_illum = SunCalc.get_moon_illumination(DATE)
+        expect(near(@moon_illum[:fraction], 0.4848068202456373, nil)).to be true
+        expect(near(@moon_illum[:phase], 0.7548368838538762, nil)).to be true
+        expect(near(@moon_illum[:angle], 1.6732942678578346, nil)).to be true
+    end
+
+    it "can return moon rise and set times" do
+        @moon_times = SunCalc.get_moon_times(DATE, LAT, LNG)
+        expect(@moon_times[:rise].to_i).to be_within(1000).of(MOON_RISE.to_i)
+        expect(@moon_times[:set].to_i).to be_within(1000).of(MOON_SET.to_i)
+    end
+end

data/suncalc.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'suncalc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "suncalc"
+  spec.version       = SunCalc::VERSION
+  spec.authors       = ["Greg Mundy"]
+  spec.email         = ["gregmundy@gmail.com"]
+  spec.summary       = %q{Ruby port of Vladimir Agafonkin's excellent suncalc.js library.}
+  spec.description   = %q{A Ruby library for calculating sun/moon positions and phases.}
+  spec.homepage      = "https://bitbucket.org/greg_mundy/suncalc.git"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/tasks/rspec.rake

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: suncalc
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Greg Mundy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby library for calculating sun/moon positions and phases.
+email:
+- gregmundy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/suncalc.rb
+- lib/suncalc/version.rb
+- spec/spec_helper.rb
+- spec/suncalc_spec.rb
+- suncalc.gemspec
+- tasks/rspec.rake
+homepage: https://bitbucket.org/greg_mundy/suncalc.git
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby port of Vladimir Agafonkin's excellent suncalc.js library.
+test_files:
+- spec/spec_helper.rb
+- spec/suncalc_spec.rb