skymap 0.4.0 → 0.5.0

data/lib/skymap/renderer/deep_sky_symbol.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Renderer
+    DeepSkySymbol = Data.define(
+      :center,
+      :kind,
+      :semi_major,
+      :semi_minor,
+      :rotation,
+      :width
+    ) do
+      def hollow?
+        DeepSkySymbol::HOLLOW_KINDS.include?(kind)
+      end
+
+      def outline
+        return corners if kind == :nebula
+
+        steps = outline_steps
+
+        Array.new(steps) do |step|
+          angle = 2 * Math::PI * step / steps
+
+          at(semi_major * Math.cos(angle), semi_minor * Math.sin(angle))
+        end
+      end
+
+      private
+
+      def outline_steps
+        flatness = [1 - DeepSkySymbol::OUTLINE_TOLERANCE / semi_major, -1].max
+
+        (Math::PI / Math.acos(flatness)).ceil
+          .clamp(DeepSkySymbol::MIN_OUTLINE_STEPS,
+            DeepSkySymbol::MAX_OUTLINE_STEPS)
+      end
+
+      def corners
+        [[-1, -1], [1, -1], [1, 1], [-1, 1]].map do |sx, sy|
+          at(sx * semi_major, sy * semi_minor)
+        end
+      end
+
+      def at(dx, dy)
+        turn = rotation * Math::PI / 180
+
+        Point.new(
+          x: center.x + dx * Math.cos(turn) - dy * Math.sin(turn),
+          y: center.y + dx * Math.sin(turn) + dy * Math.cos(turn)
+        )
+      end
+    end
+
+    DeepSkySymbol::HOLLOW_KINDS = %i[
+      galaxy
+      open_cluster
+      asterism
+      supernova_remnant
+      planetary_nebula
+      nebula
+    ].freeze
+    DeepSkySymbol::OUTLINE_TOLERANCE = 0.5
+    DeepSkySymbol::MIN_OUTLINE_STEPS = 8
+    DeepSkySymbol::MAX_OUTLINE_STEPS = 720
+  end
+end

data/lib/skymap/renderer/field_circle.rb

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

data/lib/skymap/renderer/grid.rb

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

data/lib/skymap/renderer/horizon_line.rb

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

data/lib/skymap/renderer/label.rb

@@ -2,6 +2,8 @@
 
 module Skymap
   module Renderer
-    Label = Data.define(:position, :text, :size)
+    Label = Data.define(:position, :text, :size) do
+      include TextWidth
+    end
   end
 end

data/lib/skymap/renderer/scale_bar.rb

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

data/lib/skymap/renderer/svg.rb

@@ -6,18 +6,26 @@ module Skymap
   module Renderer
     class SVG
       HORIZON_WIDTH = 3
+      FRAME_WIDTH = 1
       BOUNDARY_DASH_RATIO = 4
+      DEEP_SKY_DASH_RATIO = 3
+      DEEP_SKY_DOT_GAP_RATIO = 2.5
+      DEEP_SKY_TICK_RATIO = 0.6
+      DEEP_SKY_BAR_RATIO = 1.8
+      DEEP_SKY_CORNER_RATIO = 0.3
 
-      def initialize(canvas:, theme:)
+      def initialize(canvas:, theme:, clipped: false)
         @canvas = canvas
         @theme = theme
+        @clipped = clipped
       end
 
       def render(elements)
+        printed_size = (@canvas.print_size || @canvas.size).to_s
         svg = Victor::SVG.new(
           viewBox: "0 0 #{@canvas.size} #{@canvas.size}",
-          width: @canvas.size,
-          height: @canvas.size
+          width: printed_size,
+          height: printed_size
         )
 
         draw_background(svg)
@@ -28,16 +36,51 @@ module Skymap
           r: @canvas.radius.round(2),
           fill: @theme.sky,
           stroke: @theme.horizon,
-          stroke_width: HORIZON_WIDTH
+          stroke_width: @clipped ? FRAME_WIDTH : HORIZON_WIDTH
         )
 
+        if @clipped
+          clip_to_sky(svg)
+          svg.g(clip_path: "url(##{clip_id})") { draw_elements(svg, elements) }
+        else
+          draw_elements(svg, elements)
+        end
+
+        svg.render
+      end
+
+      private
+
+      def clip_to_sky(svg)
+        radius = @canvas.radius.round(2)
+        cx = @canvas.center.x.round(2)
+        cy = @canvas.center.y.round(2)
+
+        svg.defs do
+          svg.clipPath(id: clip_id) { svg.circle(cx: cx, cy: cy, r: radius) }
+        end
+      end
+
+      def clip_id
+        geometry = [@canvas.center.x, @canvas.center.y, @canvas.radius]
+          .map { |value| value.round(2).to_s.tr(".", "_") }
+
+        "sky-#{geometry.join("-")}"
+      end
+
+      def draw_elements(svg, elements)
         elements.each do |element|
           case element
           when Boundary then draw_boundary(svg, element)
           when Caption then draw_caption(svg, element)
           when Line then draw_line(svg, element)
+          when ScaleBar then draw_scale_bar(svg, element)
+          when DeepSkySymbol then draw_deep_sky_symbol(svg, element)
           when Dot then draw_dot(svg, element)
           when Ecliptic then draw_ecliptic(svg, element)
+          when FieldCircle then draw_field_circle(svg, element)
+          when Grid then draw_grid(svg, element)
+          when HorizonLine then draw_horizon_line(svg, element)
           when Label then draw_label(svg, element)
           when Moon then draw_moon(svg, element)
           when Planet then draw_planet(svg, element)
@@ -45,11 +88,12 @@ module Skymap
           else raise ArgumentError, "unknown element: #{element.class}"
           end
         end
-
-        svg.render
       end
 
-      private
+      def format_points(points)
+        points.map { |point| "#{point.x.round(2)},#{point.y.round(2)}" }
+          .join(" ")
+      end
 
       def draw_background(svg)
         return if @theme.background == "none"
@@ -75,13 +119,26 @@ module Skymap
         )
       end
 
+      def draw_scale_bar(svg, bar)
+        top = bar.from.y - bar.tick
+        points = [
+          Point.new(x: bar.from.x, y: top), bar.from,
+          bar.to, Point.new(x: bar.to.x, y: top)
+        ]
+
+        svg.polyline(
+          points: format_points(points),
+          fill: "none",
+          stroke: @theme.scale,
+          stroke_width: bar.width.round(2)
+        )
+      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(" "),
+          points: format_points(boundary.points),
           fill: "none",
           stroke: @theme.boundary,
           stroke_width: boundary.width.round(2),
@@ -90,13 +147,33 @@ module Skymap
       end
 
       def draw_ecliptic(svg, ecliptic)
+        draw_polyline(svg, ecliptic, @theme.ecliptic)
+      end
+
+      def draw_field_circle(svg, circle)
+        draw_polyline(svg, circle, @theme.field_circle)
+      end
+
+      def draw_grid(svg, grid)
+        draw_polyline(svg, grid, @theme.grid)
+      end
+
+      def draw_polyline(svg, element, stroke)
         svg.polyline(
-          points: ecliptic.points.map { |point|
-            "#{point.x.round(2)},#{point.y.round(2)}"
-          }.join(" "),
+          points: format_points(element.points),
           fill: "none",
-          stroke: @theme.ecliptic,
-          stroke_width: ecliptic.width.round(2),
+          stroke: stroke,
+          stroke_width: element.width.round(2),
+          stroke_linejoin: "round"
+        )
+      end
+
+      def draw_horizon_line(svg, line)
+        svg.polyline(
+          points: format_points(line.points),
+          fill: "none",
+          stroke: @theme.horizon,
+          stroke_width: HORIZON_WIDTH,
           stroke_linejoin: "round"
         )
       end
@@ -155,6 +232,115 @@ module Skymap
         end
       end
 
+      def draw_deep_sky_symbol(svg, symbol)
+        x = symbol.center.x.round(2)
+        y = symbol.center.y.round(2)
+        width = symbol.width.round(2)
+
+        svg.g(
+          transform: "rotate(#{symbol.rotation.round(2)} #{x} #{y})",
+          fill: "none",
+          stroke: @theme.deep_sky,
+          stroke_width: width,
+          stroke_linejoin: "round"
+        ) do
+          draw_deep_sky_shape(
+            svg,
+            symbol.kind,
+            x: x,
+            y: y,
+            rx: symbol.semi_major.round(2),
+            ry: symbol.semi_minor.round(2),
+            width: width
+          )
+        end
+      end
+
+      def draw_deep_sky_shape(svg, kind, **shape)
+        case kind
+        when :galaxy then draw_deep_sky_ellipse(svg, **shape)
+        when :open_cluster then draw_deep_sky_ellipse(svg, dashed: true,
+**shape)
+        when :asterism then draw_deep_sky_ellipse(svg, dotted: true, **shape)
+        when :supernova_remnant then draw_remnant(svg, **shape)
+        when :globular_cluster then draw_globular_cluster(svg, **shape)
+        when :planetary_nebula then draw_planetary_nebula(svg, **shape)
+        when :nebula then draw_nebula(svg, **shape)
+        when :double_star then draw_double_star(svg, **shape)
+        when :other then draw_cross(svg, **shape)
+        else raise ArgumentError, "unknown deep-sky object type: #{kind}"
+        end
+      end
+
+      def draw_deep_sky_ellipse(svg, x:, y:, rx:, ry:, width:, **style)
+        svg.ellipse(
+          cx: x, cy: y, rx: rx, ry: ry, **deep_sky_dashes(width, **style)
+        )
+      end
+
+      def deep_sky_dashes(width, dashed: false, dotted: false)
+        if dashed
+          dash = (width * DEEP_SKY_DASH_RATIO).round(2)
+          {stroke_dasharray: "#{dash} #{dash}"}
+        elsif dotted
+          gap = (width * DEEP_SKY_DOT_GAP_RATIO).round(2)
+          {stroke_dasharray: "0 #{gap}", stroke_linecap: "round"}
+        else
+          {}
+        end
+      end
+
+      def draw_remnant(svg, x:, y:, rx:, ry:, width:)
+        draw_deep_sky_ellipse(svg, x: x, y: y, rx: rx, ry: ry, width: width,
+          dashed: true)
+        svg.circle(cx: x, cy: y, r: width, fill: @theme.deep_sky,
+          stroke: "none")
+      end
+
+      def draw_globular_cluster(svg, x:, y:, rx:, ry:, width:)
+        draw_deep_sky_ellipse(svg, x: x, y: y, rx: rx, ry: ry, width: width)
+        draw_cross(svg, x: x, y: y, rx: rx, ry: ry, width: width)
+      end
+
+      def draw_planetary_nebula(svg, x:, y:, rx:, ry:, width:)
+        draw_deep_sky_ellipse(svg, x: x, y: y, rx: rx, ry: ry, width: width)
+        tick = (DEEP_SKY_TICK_RATIO * [rx, ry].min).round(2)
+        [[1, 0], [-1, 0], [0, 1], [0, -1]].each do |dx, dy|
+          svg.line(
+            x1: (x + dx * rx).round(2),
+            y1: (y + dy * ry).round(2),
+            x2: (x + dx * (rx + tick)).round(2),
+            y2: (y + dy * (ry + tick)).round(2)
+          )
+        end
+      end
+
+      def draw_nebula(svg, x:, y:, rx:, ry:, width:)
+        dash = (width * DEEP_SKY_DASH_RATIO).round(2)
+        corner = (DEEP_SKY_CORNER_RATIO * [rx, ry].min).round(2)
+
+        svg.rect(
+          x: (x - rx).round(2),
+          y: (y - ry).round(2),
+          width: (2 * rx).round(2),
+          height: (2 * ry).round(2),
+          rx: corner,
+          stroke_dasharray: "#{dash} #{dash}"
+        )
+      end
+
+      def draw_double_star(svg, x:, y:, rx:, ry:, width:)
+        draw_deep_sky_ellipse(svg, x: x, y: y, rx: rx, ry: ry, width: width)
+        reach = (DEEP_SKY_BAR_RATIO * rx).round(2)
+        svg.line(x1: (x - reach).round(2), y1: y, x2: (x + reach).round(2),
+          y2: y)
+      end
+
+      def draw_cross(svg, x:, y:, rx:, ry:, **)
+        svg.line(x1: (x - rx).round(2), y1: y, x2: (x + rx).round(2), y2: y)
+        svg.line(x1: x, y1: (y - ry).round(2), x2: x, y2: (y + ry).round(2))
+      end
+
       def draw_label(svg, label)
         draw_text(svg, label, @theme.label)
       end
@@ -168,6 +354,9 @@ module Skymap
         when :constellation then @theme.constellation_name
         when :star then @theme.star_name
         when :planet then @theme.planet_name
+        when :field then @theme.field_circle
+        when :scale then @theme.scale
+        when :deep_sky then @theme.deep_sky
         else raise ArgumentError, "unknown caption kind: #{kind}"
         end
       end

data/lib/skymap/setup.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Skymap
+  Setup = Data.define(:telescope, :eyepiece) do
+    def initialize(telescope:, eyepiece:)
+      unless telescope.is_a?(Telescope)
+        raise ArgumentError, "telescope must be a Skymap::Telescope"
+      end
+
+      unless eyepiece.is_a?(Eyepiece)
+        raise ArgumentError, "eyepiece must be a Skymap::Eyepiece"
+      end
+
+      super
+    end
+
+    def magnification
+      telescope.focal_length_mm.fdiv(eyepiece.focal_length_mm)
+    end
+
+    def true_field
+      Astronoby::Angle.from_degrees(
+        eyepiece.apparent_field_of_view.degrees / magnification
+      )
+    end
+
+    def label
+      "#{plain(eyepiece.focal_length_mm.to_f)} mm, " \
+        "#{magnification.round}×, #{plain_angle(true_field)}"
+    end
+
+    private
+
+    def plain_angle(angle)
+      seconds = (angle.degrees * 3600).round
+      return "#{seconds}″" if seconds < 60
+
+      minutes = (angle.degrees * 60).round
+      return "#{minutes}′" if minutes < 60
+
+      "#{plain(angle.degrees.round(1))}°"
+    end
+
+    def plain(number)
+      number.to_s.delete_suffix(".0")
+    end
+  end
+end

data/lib/skymap/star.rb

@@ -1,9 +1,134 @@
 # frozen_string_literal: true
 
 module Skymap
-  Star = Data.define(:hr, :equatorial_coordinates, :magnitude) do
+  Star = Data.define(
+    :hr,
+    :equatorial_coordinates,
+    :magnitude,
+    :proper_motion_ra,
+    :proper_motion_dec,
+    :parallax,
+    :radial_velocity
+  ) do
     def self.by_hr(stars)
-      stars.to_h { |star| [star.hr, star] }
+      stars.filter_map { |star| [star.hr, star] if star.hr }.to_h
+    end
+
+    def initialize(
+      hr:,
+      equatorial_coordinates:,
+      magnitude:,
+      proper_motion_ra: nil,
+      proper_motion_dec: nil,
+      parallax: nil,
+      radial_velocity: nil
+    )
+      unless hr?(hr)
+        raise ArgumentError, "hr must be a positive Integer or nil"
+      end
+
+      unless equatorial_coordinates.is_a?(Astronoby::Coordinates::Equatorial)
+        raise ArgumentError,
+          "equatorial_coordinates must be Astronoby::Coordinates::Equatorial"
+      end
+
+      unless magnitude?(magnitude)
+        raise ArgumentError, "magnitude must be a finite Numeric"
+      end
+
+      unless proper_motion?(proper_motion_ra)
+        raise ArgumentError,
+          "proper_motion_ra must be an Astronoby::AngularVelocity or nil"
+      end
+
+      unless proper_motion?(proper_motion_dec)
+        raise ArgumentError,
+          "proper_motion_dec must be an Astronoby::AngularVelocity or nil"
+      end
+
+      if proper_motion_ra.nil? != proper_motion_dec.nil?
+        raise ArgumentError,
+          "proper_motion_ra and proper_motion_dec must be given together"
+      end
+
+      if proper_motion_ra &&
+          equatorial_coordinates.epoch != Astronoby::JulianDate::J2000
+        raise ArgumentError,
+          "equatorial_coordinates must be at J2000 when a proper motion " \
+          "is given, as it is applied from J2000"
+      end
+
+      unless parallax?(parallax)
+        raise ArgumentError,
+          "parallax must be an Astronoby::Angle above 0 or nil"
+      end
+
+      unless radial_velocity?(radial_velocity)
+        raise ArgumentError,
+          "radial_velocity must be an Astronoby::Velocity or nil"
+      end
+
+      super
+    end
+
+    def coordinates_at(instant)
+      unless instant.is_a?(Astronoby::Instant)
+        raise ArgumentError, "instant must be an Astronoby::Instant"
+      end
+
+      return equatorial_coordinates if proper_motion_ra.nil?
+
+      propagated = Astronoby::StellarPropagation.equatorial_coordinates_for(
+        instant: instant,
+        equatorial_coordinates: equatorial_coordinates,
+        proper_motion_ra: proper_motion_ra,
+        proper_motion_dec: proper_motion_dec,
+        parallax: parallax || placeholder_parallax,
+        radial_velocity: radial_velocity || placeholder_radial_velocity
+      )
+
+      Astronoby::Coordinates::Equatorial.new(
+        right_ascension: propagated.right_ascension,
+        declination: propagated.declination,
+        epoch: Astronoby::JulianDate::J2000
+      )
+    end
+
+    placeholder_parallax = Astronoby::Angle.from_degree_arcseconds(0.001)
+    placeholder_radial_velocity =
+      Astronoby::Velocity.from_kilometers_per_second(0)
+
+    private define_method(:placeholder_parallax) { placeholder_parallax }
+    private define_method(:placeholder_radial_velocity) {
+      placeholder_radial_velocity
+    }
+
+    private
+
+    def hr?(value)
+      value.nil? || (value.is_a?(Integer) && value.positive?)
+    end
+
+    def magnitude?(value)
+      value.is_a?(Numeric) && value.real? && value.finite?
+    end
+
+    def proper_motion?(value)
+      value.nil? ||
+        (value.is_a?(Astronoby::AngularVelocity) &&
+          value.radians_per_second.finite?)
+    end
+
+    def parallax?(value)
+      value.nil? ||
+        (value.is_a?(Astronoby::Angle) &&
+          value.radians.finite? && value.positive?)
+    end
+
+    def radial_velocity?(value)
+      value.nil? ||
+        (value.is_a?(Astronoby::Velocity) &&
+          value.meters_per_second.finite?)
     end
   end
 end

data/lib/skymap/star_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Skymap
+  class StarList
+    def self.wrap(stars)
+      return stars if stars.respond_to?(:search)
+
+      new(stars)
+    end
+
+    def initialize(stars)
+      @stars = stars
+    end
+
+    def search(magnitude_limit: nil, cone: nil)
+      return @stars.to_a unless magnitude_limit
+
+      @stars.select { |star| star.magnitude <= magnitude_limit }
+    end
+
+    def by_hr
+      Star.by_hr(@stars)
+    end
+  end
+end

data/lib/skymap/telescope.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Skymap
+  Telescope = Data.define(:focal_length_mm, :aperture_mm) do
+    def initialize(focal_length_mm:, aperture_mm:)
+      {focal_length_mm: focal_length_mm, aperture_mm: aperture_mm}
+        .each do |name, value|
+          unless value.is_a?(Numeric) && value.real? && value.finite? &&
+              value > 0
+            raise ArgumentError, "#{name} must be a number above 0"
+          end
+        end
+
+      super
+    end
+  end
+end