skymap 0.0.1 → 0.2.0

data/lib/skymap/canvas.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skymap
+  Canvas = Data.define(:size, :padding) do
+    def center
+      Point.new(x: size / 2.0, y: size / 2.0)
+    end
+
+    def radius
+      size / 2.0 - padding
+    end
+  end
+end

data/lib/skymap/catalog/constellation_boundaries.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Skymap
+  module Catalog
+    class ConstellationBoundaries
+      include Enumerable
+
+      PATH = File.expand_path(
+        "../../../data/constellations/iau/boundaries.csv",
+        __dir__
+      )
+
+      def each
+        CSV.foreach(PATH, headers: true).chunk_while do |previous, row|
+          previous["border"] == row["border"]
+        end.each do |rows|
+          yield boundary_from(rows)
+        end
+      end
+
+      private
+
+      def boundary_from(rows)
+        ConstellationBoundary.new(
+          constellations: rows.first["constellations"].split,
+          points: rows.map { |row| coordinates_from(row) }
+        )
+      end
+
+      def coordinates_from(row)
+        Astronoby::Coordinates::Equatorial.new(
+          right_ascension: Astronoby::Angle.from_hours(
+            row["right_ascension"].to_f
+          ),
+          declination: Astronoby::Angle.from_degrees(row["declination"].to_f),
+          epoch: Astronoby::JulianDate::J2000
+        )
+      end
+    end
+  end
+end

data/lib/skymap/catalog/constellation_lines.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Skymap
+  module Catalog
+    class ConstellationLines
+      include Enumerable
+
+      PATH = File.expand_path(
+        "../../../data/constellations/iau/lines.csv",
+        __dir__
+      )
+
+      def each
+        CSV.foreach(PATH, headers: true) do |row|
+          yield line_from(row)
+        end
+      end
+
+      private
+
+      def line_from(row)
+        ConstellationLine.new(
+          constellation: row["constellation"],
+          from: hr_numbers(row["from_hr"]),
+          to: hr_numbers(row["to_hr"]),
+          weight: row["weight"].to_sym
+        )
+      end
+
+      def hr_numbers(value)
+        value.split.map(&:to_i)
+      end
+    end
+  end
+end

data/lib/skymap/catalog/stars.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Skymap
+  module Catalog
+    class Stars
+      include Enumerable
+
+      PATH = File.expand_path("../../../data/stars.csv", __dir__)
+
+      def each
+        CSV.foreach(PATH, headers: true) do |row|
+          yield star_from(row)
+        end
+      end
+
+      private
+
+      def star_from(row)
+        Star.new(
+          hr: row["hr"].to_i,
+          equatorial_coordinates: Astronoby::Coordinates::Equatorial.new(
+            right_ascension: Astronoby::Angle.from_hours(
+              row["right_ascension"].to_f
+            ),
+            declination: Astronoby::Angle.from_degrees(row["declination"].to_f),
+            epoch: Astronoby::JulianDate::J2000
+          ),
+          magnitude: row["magnitude"].to_f
+        )
+      end
+    end
+  end
+end

data/lib/skymap/chart.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Skymap
+  class Chart
+    def initialize(observer:, instant:, canvas:)
+      @observer = observer
+      @instant = instant
+      @canvas = canvas
+    end
+
+    def render(*layers)
+      context = Context.new(
+        observer: @observer,
+        instant: @instant,
+        canvas: @canvas
+      )
+      elements = layers.flat_map { |layer| layer.elements(context) }
+
+      Renderer::SVG.new(canvas: @canvas).render(elements)
+    end
+  end
+end

data/lib/skymap/constellation_boundary.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skymap
+  ConstellationBoundary = Data.define(:constellations, :points)
+end

data/lib/skymap/constellation_line.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skymap
+  ConstellationLine = Data.define(:constellation, :from, :to, :weight)
+end

data/lib/skymap/context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Skymap
+  class Context
+    attr_reader :observer, :instant, :canvas
+
+    def initialize(observer:, instant:, canvas:)
+      @observer = observer
+      @instant = instant
+      @canvas = canvas
+      @horizontal = {}
+      @projections = {}
+    end
+
+    def horizontal(star)
+      horizontal_coordinates(star.equatorial_coordinates)
+    end
+
+    def horizontal_coordinates(coordinates)
+      key = [
+        coordinates.right_ascension,
+        coordinates.declination,
+        coordinates.epoch
+      ]
+
+      @horizontal[key] ||= Astronoby::DeepSkyObject
+        .new(equatorial_coordinates: coordinates)
+        .at(@instant)
+        .observed_by(@observer)
+        .horizontal
+    end
+
+    def position(star)
+      horizontal = horizontal(star)
+      project(altitude: horizontal.altitude, azimuth: horizontal.azimuth)
+    end
+
+    def project(altitude:, azimuth:, radius: @canvas.radius)
+      projection(radius).project(altitude: altitude, azimuth: azimuth)
+    end
+
+    private
+
+    def projection(radius)
+      @projections[radius] ||= Projection::Stereographic.new(
+        center: @canvas.center,
+        radius: radius
+      )
+    end
+  end
+end

data/lib/skymap/horizon.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Horizon
+    module_function
+
+    def direction(horizontals)
+      vectors = horizontals.map do |horizontal|
+        [
+          horizontal.altitude.cos * horizontal.azimuth.cos,
+          horizontal.altitude.cos * horizontal.azimuth.sin,
+          horizontal.altitude.sin
+        ]
+      end
+      vectors.transpose.map(&:sum)
+    end
+
+    def crossing(above, below)
+      above.zip(below).map do |from, to|
+        above.last * to - below.last * from
+      end
+    end
+
+    def project(context, direction)
+      x, y, = direction
+      context.project(
+        altitude: Astronoby::Angle.zero,
+        azimuth: Astronoby::Angle.from_radians(Math.atan2(y, x))
+      )
+    end
+  end
+end

data/lib/skymap/layers/cardinal_directions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class CardinalDirections
+      CARDINAL_DIRECTIONS = {"N" => 0, "E" => 90, "S" => 180, "W" => 270}
+      CARDINAL_SIZE_RATIO = 0.6
+
+      def elements(context)
+        canvas = context.canvas
+
+        CARDINAL_DIRECTIONS.map do |text, azimuth|
+          position = context.project(
+            altitude: Astronoby::Angle.zero,
+            azimuth: Astronoby::Angle.from_degrees(azimuth),
+            radius: canvas.radius + canvas.padding / 2.0
+          )
+          Renderer::Label.new(
+            position: position,
+            text: text,
+            size: canvas.padding * CARDINAL_SIZE_RATIO
+          )
+        end
+      end
+    end
+  end
+end

data/lib/skymap/layers/constellation_boundaries.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class ConstellationBoundaries
+      LINE_WIDTH_RATIO = 0.0017
+
+      def initialize(boundaries:)
+        @boundaries = boundaries
+      end
+
+      def elements(context)
+        width = LINE_WIDTH_RATIO * context.canvas.radius
+
+        @boundaries.flat_map do |boundary|
+          visible_runs(context, boundary.points).map do |points|
+            Renderer::Boundary.new(points: points, width: width)
+          end
+        end
+      end
+
+      private
+
+      def visible_runs(context, coordinates)
+        horizontals = coordinates.map do |point|
+          context.horizontal_coordinates(point)
+        end
+        path = [position(context, horizontals.first)] +
+          horizontals.each_cons(2).flat_map do |from, to|
+            crossing(context, from, to) + [position(context, to)]
+          end
+
+        path.chunk { |point| !point.nil? }.filter_map do |visible, points|
+          points if visible && points.size > 1
+        end
+      end
+
+      def position(context, horizontal)
+        return if below?(horizontal)
+
+        context.project(
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+      end
+
+      def crossing(context, from, to)
+        return [] if below?(from) == below?(to)
+
+        above, below = below?(from) ? [to, from] : [from, to]
+        [
+          Horizon.project(
+            context,
+            Horizon.crossing(
+              Horizon.direction([above]),
+              Horizon.direction([below])
+            )
+          )
+        ]
+      end
+
+      def below?(horizontal)
+        horizontal.altitude.negative?
+      end
+    end
+  end
+end

data/lib/skymap/layers/constellation_lines.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class ConstellationLines
+      LINE_WIDTH_RATIOS = {bold: 0.0044, normal: 0.003, thin: 0.0017}
+
+      def initialize(lines:, stars:)
+        @lines = lines
+        @stars = stars
+      end
+
+      def elements(context)
+        stars_by_hr = @stars.to_h { |star| [star.hr, star] }
+
+        @lines.filter_map do |line|
+          ends = [line.from, line.to].map { |hrs| stars_by_hr.values_at(*hrs) }
+          next if ends.flatten.include?(nil)
+
+          directions = ends.map do |end_stars|
+            Horizon.direction(
+              end_stars.map { |star| context.horizontal(star) }
+            )
+          end
+          next if directions.all? { |direction| direction.last.negative? }
+
+          from, to = ends.each_with_index.map do |end_stars, index|
+            if directions[index].last.negative?
+              Horizon.project(
+                context,
+                Horizon.crossing(directions[1 - index], directions[index])
+              )
+            else
+              Point.midpoint(end_stars.map { |star| context.position(star) })
+            end
+          end
+          Renderer::Line.new(
+            from: from,
+            to: to,
+            width: LINE_WIDTH_RATIOS.fetch(line.weight) * context.canvas.radius
+          )
+        end
+      end
+    end
+  end
+end

data/lib/skymap/layers/moon.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class Moon
+      MOON_RADIUS_RATIO = 0.03
+
+      def initialize(ephem:)
+        @ephem = ephem
+      end
+
+      def elements(context)
+        moon = Astronoby::Moon.at(context.instant, ephem: @ephem)
+        horizontal = moon.observed_by(context.observer).horizontal
+        return [] if horizontal.altitude.negative?
+
+        [
+          Renderer::Moon.new(
+            center: context.project(
+              altitude: horizontal.altitude,
+              azimuth: horizontal.azimuth
+            ),
+            radius: MOON_RADIUS_RATIO * context.canvas.radius,
+            illuminated_fraction: moon.illuminated_fraction,
+            rotation: rotation(moon, context.observer)
+          )
+        ]
+      end
+
+      private
+
+      def rotation(moon, observer)
+        from_zenith = moon.bright_limb_position_angle.degrees -
+          moon.parallactic_angle(observer: observer).degrees
+
+        -90 - from_zenith
+      end
+    end
+  end
+end

data/lib/skymap/layers/stars.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class Stars
+      DEFAULT_MAGNITUDE_LIMIT = 5
+      MAX_RADIUS_MAGNITUDE = -1.5
+      MIN_STAR_RADIUS_RATIO = 0.0025
+      MAX_STAR_RADIUS_RATIO = 0.02
+      STAR_SIZE_EXPONENT = 1.5
+
+      def initialize(stars:, magnitude_limit: DEFAULT_MAGNITUDE_LIMIT)
+        @stars = stars
+        @magnitude_limit = magnitude_limit
+      end
+
+      def elements(context)
+        star_size = StarSize.new(
+          brightest_magnitude: MAX_RADIUS_MAGNITUDE,
+          faintest_magnitude: @magnitude_limit,
+          min_radius: MIN_STAR_RADIUS_RATIO * context.canvas.radius,
+          max_radius: MAX_STAR_RADIUS_RATIO * context.canvas.radius,
+          exponent: STAR_SIZE_EXPONENT
+        )
+
+        @stars.filter_map do |star|
+          next if star.magnitude > @magnitude_limit
+
+          next if context.horizontal(star).altitude.negative?
+
+          Renderer::Dot.new(
+            center: context.position(star),
+            radius: star_size.radius(star.magnitude)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/skymap/point.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Skymap
+  Point = Data.define(:x, :y) do
+    def self.midpoint(points)
+      new(
+        x: points.sum(&:x).fdiv(points.size),
+        y: points.sum(&:y).fdiv(points.size)
+      )
+    end
+  end
+end

data/lib/skymap/projection/stereographic.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Projection
+    class Stereographic
+      def initialize(center:, radius:)
+        @center = center
+        @radius = radius
+      end
+
+      def project(altitude:, azimuth:)
+        distance = @radius * altitude.cos / (1 + altitude.sin)
+
+        Point.new(
+          x: @center.x - distance * azimuth.sin,
+          y: @center.y - distance * azimuth.cos
+        )
+      end
+    end
+  end
+end

data/lib/skymap/renderer/boundary.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    Boundary = Data.define(:points, :width)
+  end
+end

data/lib/skymap/renderer/dot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    Dot = Data.define(:center, :radius)
+  end
+end

data/lib/skymap/renderer/label.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    Label = Data.define(:position, :text, :size)
+  end
+end

data/lib/skymap/renderer/line.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    Line = Data.define(:from, :to, :width)
+  end
+end

data/lib/skymap/renderer/moon.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    Moon = Data.define(:center, :radius, :illuminated_fraction, :rotation)
+  end
+end

data/lib/skymap/renderer/svg.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "victor"
+
+module Skymap
+  module Renderer
+    class SVG
+      SKY_COLOR = "#000000"
+      HORIZON_COLOR = "#3262a8"
+      HORIZON_WIDTH = 3
+      STAR_COLOR = "#ffffff"
+      LINE_COLOR = "#46689c"
+      BOUNDARY_COLOR = "#2b3f5e"
+      BOUNDARY_DASH_RATIO = 4
+      MOON_COLOR = "#f1ecd6"
+      MOON_SHADOW_COLOR = "#232a35"
+      MOON_SHADOW_OPACITY = 0.6
+      LABEL_COLOR = HORIZON_COLOR
+      LABEL_FONT = "sans-serif"
+
+      def initialize(canvas:)
+        @canvas = canvas
+      end
+
+      def render(elements)
+        svg = Victor::SVG.new(
+          viewBox: "0 0 #{@canvas.size} #{@canvas.size}",
+          width: @canvas.size,
+          height: @canvas.size
+        )
+
+        svg.circle(
+          cx: @canvas.center.x.round(2),
+          cy: @canvas.center.y.round(2),
+          r: @canvas.radius.round(2),
+          fill: SKY_COLOR,
+          stroke: HORIZON_COLOR,
+          stroke_width: HORIZON_WIDTH
+        )
+
+        elements.each do |element|
+          case element
+          when Boundary then draw_boundary(svg, element)
+          when Line then draw_line(svg, element)
+          when Dot then draw_dot(svg, element)
+          when Label then draw_label(svg, element)
+          when Moon then draw_moon(svg, element)
+          else raise ArgumentError, "unknown element: #{element.class}"
+          end
+        end
+
+        svg.render
+      end
+
+      private
+
+      def draw_line(svg, line)
+        svg.line(
+          x1: line.from.x.round(2),
+          y1: line.from.y.round(2),
+          x2: line.to.x.round(2),
+          y2: line.to.y.round(2),
+          stroke: LINE_COLOR,
+          stroke_width: line.width.round(2),
+          stroke_linecap: "round"
+        )
+      end
+
+      def draw_boundary(svg, boundary)
+        dash = (boundary.width * BOUNDARY_DASH_RATIO).round(2)
+
+        svg.polyline(
+          points: boundary.points.map { |point|
+            "#{point.x.round(2)},#{point.y.round(2)}"
+          }.join(" "),
+          fill: "none",
+          stroke: BOUNDARY_COLOR,
+          stroke_width: boundary.width.round(2),
+          stroke_dasharray: "#{dash} #{dash}"
+        )
+      end
+
+      def draw_dot(svg, dot)
+        svg.circle(
+          cx: dot.center.x.round(2),
+          cy: dot.center.y.round(2),
+          r: dot.radius.round(2),
+          fill: STAR_COLOR
+        )
+      end
+
+      def draw_moon(svg, moon)
+        x = moon.center.x.round(2)
+        y = moon.center.y.round(2)
+        radius = moon.radius.round(2)
+        fraction = moon.illuminated_fraction
+        terminator = (radius * (1 - 2 * fraction).abs).round(2)
+        bulge = (fraction > 0.5) ? 1 : 0
+        top = "#{x},#{(y - radius).round(2)}"
+        bottom = "#{x},#{(y + radius).round(2)}"
+        lit = "M #{top} A #{radius},#{radius} 0 0 1 #{bottom} " \
+          "A #{terminator},#{radius} 0 0 #{bulge} #{top} Z"
+
+        svg.build do
+          g(transform: "rotate(#{moon.rotation.round(2)} #{x} #{y})") do
+            circle(
+              cx: x,
+              cy: y,
+              r: radius,
+              fill: MOON_SHADOW_COLOR,
+              fill_opacity: MOON_SHADOW_OPACITY
+            )
+            path(d: lit, fill: MOON_COLOR)
+          end
+        end
+      end
+
+      def draw_label(svg, label)
+        svg.text(
+          label.text,
+          x: label.position.x.round(2),
+          y: label.position.y.round(2),
+          font_size: label.size.round(2),
+          font_family: LABEL_FONT,
+          text_anchor: "middle",
+          dominant_baseline: "central",
+          fill: LABEL_COLOR
+        )
+      end
+    end
+  end
+end

data/lib/skymap/star.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skymap
+  Star = Data.define(:hr, :equatorial_coordinates, :magnitude)
+end