skymap 0.4.0 → 0.5.0

data/lib/skymap/layers/grid.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class Grid
+      DEFAULT_STEP = Astronoby::Angle.from_degrees(30)
+      LINE_WIDTH_RATIO = 0.0025
+      SAMPLING_STEP_IN_DEGREES = 1
+      TOLERANCE_IN_DEGREES = 1e-9
+      EPOCHS = %i[j2000 of_date].freeze
+      CULL_MARGIN = Astronoby::Angle.from_degrees(
+        2 * SAMPLING_STEP_IN_DEGREES
+      ).radians
+      AXES = [[0, 0], [90, 0], [0, 90]].freeze
+
+      Line = Data.define(:kind, :degrees) do
+        def parallel?
+          kind == :parallel
+        end
+
+        def radians
+          Astronoby::Angle.from_degrees(degrees).radians
+        end
+      end
+
+      def initialize(step: DEFAULT_STEP, epoch: :j2000)
+        divisions = divisions_of(step)
+        unless divisions
+          raise ArgumentError,
+            "step must be an Astronoby::Angle between 1 and 90 degrees " \
+            "that divides 360 degrees"
+        end
+
+        unless EPOCHS.include?(epoch)
+          raise ArgumentError, "epoch must be :j2000 or :of_date"
+        end
+
+        @divisions = divisions
+        @step = 360.0 / divisions
+        @epoch = epoch
+        @specs = (parallels + meridians).freeze
+        if j2000?
+          @lines = @specs.to_h { |spec|
+            [spec, points_of(spec, Astronoby::JulianDate::J2000)]
+          }.freeze
+        end
+      end
+
+      def elements(context)
+        width = LINE_WIDTH_RATIO * context.canvas.radius
+
+        lines_for(context).flat_map { |line|
+          Horizon.joined(Horizon.visible_runs(context, line))
+        }.map do |points|
+          Renderer::Grid.new(points: points, width: width)
+        end
+      end
+
+      private
+
+      def j2000?
+        @epoch == :j2000
+      end
+
+      def lines_for(context)
+        epoch = j2000? ? Astronoby::JulianDate::J2000 : context.instant.tt
+
+        specs_near(context, epoch).map do |spec|
+          j2000? ? @lines.fetch(spec) : points_of(spec, epoch)
+        end
+      end
+
+      def specs_near(context, epoch)
+        return @specs if context.full_sky?
+
+        center = view_center(context, epoch)
+        limit = context.view.field_of_view.radians / 2 + CULL_MARGIN
+
+        @specs.select { |spec| distance_to(spec, center) <= limit }
+      end
+
+      def view_center(context, epoch)
+        direction = Horizon.direction(
+          [context.to_horizontal(context.view.center)]
+        )
+
+        AXES.map do |right_ascension, declination|
+          axis = point_at(right_ascension, declination, epoch)
+          Geometry.dot(
+            Horizon.direction([context.horizontal_coordinates(axis)]),
+            direction
+          )
+        end
+      end
+
+      def distance_to(spec, center)
+        x, y, z = center
+        if spec.parallel?
+          return (Math.asin(z.clamp(-1, 1)) - spec.radians).abs
+        end
+
+        along = x * Math.cos(spec.radians) + y * Math.sin(spec.radians)
+        reach = along.negative? ? z.abs : Math.hypot(along, z)
+
+        Math.acos(reach.clamp(-1, 1))
+      end
+
+      def divisions_of(step)
+        return unless step.is_a?(Astronoby::Angle) && step.positive?
+
+        divisions = (360 / step.degrees).round
+        return unless divisions.between?(4, 360)
+
+        divisions if (360.0 / divisions - step.degrees).abs <
+          TOLERANCE_IN_DEGREES
+      end
+
+      def parallels
+        circles = ((90 - TOLERANCE_IN_DEGREES) / @step).floor
+        declinations = (1..circles).flat_map { |index|
+          [index * @step, -index * @step]
+        } + [0]
+
+        declinations.map { |declination| Line.new(:parallel, declination) }
+      end
+
+      def meridians
+        @divisions.times.map { |index| Line.new(:meridian, index * @step) }
+      end
+
+      def points_of(spec, epoch)
+        if spec.parallel?
+          points = (0...360).step(SAMPLING_STEP_IN_DEGREES).map do |degrees|
+            point_at(degrees, spec.degrees, epoch)
+          end
+          points + points.first(1)
+        else
+          (-90..90).step(SAMPLING_STEP_IN_DEGREES).map do |declination|
+            point_at(spec.degrees, declination, epoch)
+          end
+        end
+      end
+
+      def point_at(right_ascension, declination, epoch)
+        Astronoby::Coordinates::Equatorial.new(
+          right_ascension: Astronoby::Angle.from_degrees(right_ascension),
+          declination: Astronoby::Angle.from_degrees(declination),
+          epoch: epoch
+        )
+      end
+    end
+  end
+end

data/lib/skymap/layers/moon.rb

@@ -11,29 +11,39 @@ module Skymap
 
       def elements(context)
         moon = Astronoby::Moon.at(context.instant, ephem: @ephem)
-        horizontal = moon.observed_by(context.observer).horizontal
+        equatorial = moon.observed_by(context.observer).equatorial
+        horizontal = context.horizontal_coordinates(equatorial)
         return [] if horizontal.altitude.negative?
 
+        center = context.project(
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+        radius = context.disk_radius(
+          MOON_RADIUS_RATIO * context.canvas.radius,
+          angular_diameter: moon.angular_diameter,
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+        return [] unless context.in_view?(center, radius)
+
         [
           Renderer::Moon.new(
-            center: context.project(
-              altitude: horizontal.altitude,
-              azimuth: horizontal.azimuth
-            ),
-            radius: MOON_RADIUS_RATIO * context.canvas.radius,
+            center: center,
+            radius: radius,
             illuminated_fraction: moon.illuminated_fraction,
-            rotation: rotation(moon, context.observer)
+            rotation: rotation(moon, equatorial, context)
           )
         ]
       end
 
       private
 
-      def rotation(moon, observer)
-        from_zenith = moon.bright_limb_position_angle.degrees -
-          moon.parallactic_angle(observer: observer).degrees
-
-        -90 - from_zenith
+      def rotation(moon, equatorial, context)
+        context.rotation_at(
+          equatorial,
+          position_angle: moon.bright_limb_position_angle
+        ).degrees
       end
     end
   end

data/lib/skymap/layers/planets.rb

@@ -22,6 +22,8 @@ module Skymap
         labels: false,
         names: NAMES
       )
+        MagnitudeLimit.check(magnitude_limit)
+
         @ephem = ephem
         @magnitude_limit = magnitude_limit
         @labels = labels
@@ -47,6 +49,8 @@ module Skymap
             azimuth: horizontal.azimuth
           )
           radius = star_size.radius(magnitude)
+          next [] unless context.in_view?(center, radius)
+
           caption = caption(planet, center, radius, context) if @labels
           [Renderer::Planet.new(center: center, radius: radius), caption]
             .compact

data/lib/skymap/layers/scale.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class Scale
+      UNITS = [["″", 1 / 3600.0], ["′", 1 / 60.0], ["°", 1.0]].freeze
+      STEPS = [1, 2, 5, 10, 20, 30].freeze
+      MAX_LENGTH_RATIO = 0.2
+      LINE_WIDTH_RATIO = 0.005
+      TICK_SIZE_RATIO = 0.5
+      LEFT_RATIO = -0.5
+      BOTTOM_RATIO = 0.76
+      LABEL_GAP_RATIO = 0.7
+      LENGTH_ITERATIONS = 8
+
+      def elements(context)
+        return [] if context.full_sky?
+
+        canvas = context.canvas
+        left = canvas.center.x + LEFT_RATIO * canvas.radius
+        y = canvas.center.y + BOTTOM_RATIO * canvas.radius
+        max_length = MAX_LENGTH_RATIO * 2 * canvas.radius
+        length, text = longest_fitting(context, left, y, max_length)
+        return [] unless length
+
+        size = Renderer::Caption.size_for(canvas)
+        tick = TICK_SIZE_RATIO * size
+
+        [
+          Renderer::ScaleBar.new(
+            from: Point.new(x: left, y: y),
+            to: Point.new(x: left + length, y: y),
+            tick: tick,
+            width: LINE_WIDTH_RATIO * canvas.radius
+          ),
+          Renderer::Caption.new(
+            position: Point.new(
+              x: left + length / 2,
+              y: y - tick - LABEL_GAP_RATIO * size
+            ),
+            text: text,
+            size: size,
+            kind: :scale
+          )
+        ]
+      end
+
+      private
+
+      def longest_fitting(context, left, y, max_length)
+        UNITS.product(STEPS).reverse_each do |(symbol, degrees), step|
+          radians = Astronoby::Angle.from_degrees(step * degrees).radians
+          length = pixels_for(context, radians, left, y)
+          return [length, "#{step}#{symbol}"] if length <= max_length
+        end
+
+        nil
+      end
+
+      def pixels_for(context, radians, left, y)
+        length = radians * context.scale_at_point(Point.new(x: left, y: y))
+
+        LENGTH_ITERATIONS.times do
+          inverses = [0, 0.5, 1].map do |along|
+            point = Point.new(x: left + along * length, y: y)
+            1 / context.scale_at_point(point)
+          end
+          length = radians * 6 / (inverses[0] + 4 * inverses[1] + inverses[2])
+        end
+
+        length
+      end
+    end
+  end
+end

data/lib/skymap/layers/star_names.rb

@@ -11,6 +11,12 @@ module Skymap
         stars_magnitude_limit: Stars::DEFAULT_MAGNITUDE_LIMIT,
         names: Catalog::StarNames.new
       )
+        MagnitudeLimit.check(magnitude_limit, allow_nil: true)
+        MagnitudeLimit.check(
+          stars_magnitude_limit,
+          name: :stars_magnitude_limit
+        )
+
         @stars = stars
         @magnitude_limit = magnitude_limit
         @stars_magnitude_limit = stars_magnitude_limit
@@ -23,17 +29,28 @@ module Skymap
           magnitude_limit: @stars_magnitude_limit
         )
 
-        @stars.filter_map do |star|
-          next if star.magnitude > @magnitude_limit
+        candidates = StarList.wrap(@stars).search(
+          magnitude_limit: @magnitude_limit,
+          cone: context.cone
+        )
+
+        candidates.filter_map do |star|
+          next unless star.hr
 
           name = @names[star.hr]
           next unless name
 
+          radius = star_size.radius(star.magnitude)
+          next unless context.possibly_visible?(star, radius)
+
           next if context.horizontal(star).altitude.negative?
 
+          center = context.position(star)
+          next unless context.in_view?(center, radius)
+
           Renderer::Caption.beside(
-            center: context.position(star),
-            radius: star_size.radius(star.magnitude),
+            center: center,
+            radius: radius,
             canvas: context.canvas,
             text: name,
             kind: :star

data/lib/skymap/layers/stars.rb

@@ -6,6 +6,8 @@ module Skymap
       DEFAULT_MAGNITUDE_LIMIT = 5
 
       def initialize(stars:, magnitude_limit: DEFAULT_MAGNITUDE_LIMIT)
+        MagnitudeLimit.check(magnitude_limit)
+
         @stars = stars
         @magnitude_limit = magnitude_limit
       end
@@ -16,16 +18,37 @@ module Skymap
           magnitude_limit: @magnitude_limit
         )
 
-        @stars.filter_map do |star|
-          next if star.magnitude > @magnitude_limit
-
-          next if context.horizontal(star).altitude.negative?
+        candidates = StarList.wrap(@stars).search(
+          magnitude_limit: @magnitude_limit,
+          cone: context.cone
+        )
 
-          Renderer::Dot.new(
-            center: context.position(star),
-            radius: star_size.radius(star.magnitude)
-          )
+        dots = candidates.filter_map do |star|
+          dot = dot_for(star, context, star_size)
+          [star.magnitude, dot] if dot
         end
+
+        faintest_first(dots)
+      end
+
+      private
+
+      def dot_for(star, context, star_size)
+        radius = star_size.radius(star.magnitude)
+        return unless context.possibly_visible?(star, radius)
+
+        return if context.horizontal(star).altitude.negative?
+
+        center = context.position(star)
+        return unless context.in_view?(center, radius)
+
+        Renderer::Dot.new(center: center, radius: radius)
+      end
+
+      def faintest_first(dots)
+        dots.each_with_index
+          .sort_by { |(magnitude, _), index| [-magnitude, index] }
+          .map { |(_, dot), _| dot }
       end
     end
   end

data/lib/skymap/layers/sun.rb

@@ -14,15 +14,19 @@ module Skymap
         horizontal = sun.observed_by(context.observer).horizontal
         return [] if horizontal.altitude.negative?
 
-        [
-          Renderer::Sun.new(
-            center: context.project(
-              altitude: horizontal.altitude,
-              azimuth: horizontal.azimuth
-            ),
-            radius: SUN_RADIUS_RATIO * context.canvas.radius
-          )
-        ]
+        center = context.project(
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+        radius = context.disk_radius(
+          SUN_RADIUS_RATIO * context.canvas.radius,
+          angular_diameter: sun.angular_diameter,
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+        return [] unless context.in_view?(center, radius)
+
+        [Renderer::Sun.new(center: center, radius: radius)]
       end
     end
   end

data/lib/skymap/magnitude_limit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Skymap
+  module MagnitudeLimit
+    module_function
+
+    def check(value, name: :magnitude_limit, allow_nil: false)
+      return if allow_nil && value.nil?
+      return if value.is_a?(Numeric) && value.real? && value.finite?
+
+      raise ArgumentError,
+        "#{name} must be a finite Numeric#{" or nil" if allow_nil}"
+    end
+  end
+end

data/lib/skymap/print_size.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Skymap
+  PrintSize = Data.define(:length, :unit) do
+    def self.paper(name, margin: PrintSize::DEFAULT_MARGIN)
+      short_side = PrintSize::PAPERS.fetch(name) do
+        papers = PrintSize::PAPERS.keys.join(", ")
+        raise ArgumentError, "paper must be one of #{papers}"
+      end
+      unless margin.is_a?(Numeric) && margin.real? && margin >= 0 &&
+          margin < short_side / 2.0
+        raise ArgumentError,
+          "margin must not be negative and must be less than half the paper"
+      end
+
+      new(length: (short_side - 2 * margin).round(2), unit: :mm)
+    end
+
+    def initialize(length:, unit:)
+      unless length.is_a?(Numeric) && length.real? && length.finite? &&
+          length > 0
+        raise ArgumentError, "length must be a number above 0"
+      end
+
+      unless PrintSize::UNITS.include?(unit)
+        units = PrintSize::UNITS.join(", ")
+        raise ArgumentError, "unit must be one of #{units}"
+      end
+
+      super
+    end
+
+    def to_s
+      number = length.to_f
+      number = number.to_i if number == number.to_i
+
+      "#{number}#{unit}"
+    end
+  end
+
+  PrintSize::UNITS = %i[mm cm in].freeze
+  PrintSize::PAPERS = {
+    a5: 148,
+    a4: 210,
+    a3: 297,
+    letter: 215.9,
+    tabloid: 279.4
+  }.freeze
+  PrintSize::DEFAULT_MARGIN = 10
+end

data/lib/skymap/projection/oblique_stereographic.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Projection
+    class ObliqueStereographic
+      MIN_DENOMINATOR = 1e-9
+      NORTH = [1.0, 0.0, 0.0].freeze
+      ZENITH = [0.0, 0.0, 1.0].freeze
+
+      def initialize(
+        center:,
+        radius:,
+        altitude:,
+        azimuth:,
+        field_of_view:,
+        orientation: :zenith_up,
+        pole: NORTH,
+        rotation: Astronoby::Angle.zero,
+        mirrored: false
+      )
+        @center = center
+        @forward = vector(altitude, azimuth)
+        up = up_from(@forward, field_of_view, orientation, pole)
+        right = Geometry.cross(up, @forward)
+        right = right.map(&:-@) if mirrored
+        @right, @up = turned(right, up, rotation)
+        quarter = Astronoby::Angle.from_radians(field_of_view.radians / 4.0)
+        @scale = radius / (2 * quarter.tan)
+      end
+
+      def project(altitude:, azimuth:)
+        point = vector(altitude, azimuth)
+        factor = 2 / [1 + Geometry.dot(point, @forward), MIN_DENOMINATOR].max
+
+        Point.new(
+          x: @center.x + @scale * factor * Geometry.dot(point, @right),
+          y: @center.y - @scale * factor * Geometry.dot(point, @up)
+        )
+      end
+
+      def scale_at(altitude:, azimuth:)
+        point = vector(altitude, azimuth)
+
+        @scale * 2 / [1 + Geometry.dot(point, @forward), MIN_DENOMINATOR].max
+      end
+
+      def scale_at_point(point)
+        distance = Math.hypot(point.x - @center.x, point.y - @center.y)
+
+        @scale * (1 + (distance / (2 * @scale))**2)
+      end
+
+      private
+
+      def vector(altitude, azimuth)
+        [
+          altitude.cos * azimuth.cos,
+          altitude.cos * azimuth.sin,
+          altitude.sin
+        ]
+      end
+
+      def up_from(forward, field_of_view, orientation, pole)
+        half_angle = Astronoby::Angle.from_radians(field_of_view.radians / 2.0)
+        references = if orientation == :equatorial
+          [pole, ZENITH, NORTH]
+        elsif forward[2] >= half_angle.cos
+          [NORTH, ZENITH]
+        else
+          [ZENITH, NORTH]
+        end
+
+        references.each do |reference|
+          up = Geometry.away_from(reference, forward)
+          return Geometry.normalize(up) if Geometry.dot(up, up) > 1e-18
+        end
+      end
+
+      def turned(right, up, rotation)
+        [
+          right.zip(up).map { |r, u| rotation.cos * r + rotation.sin * u },
+          up.zip(right).map { |u, r| rotation.cos * u - rotation.sin * r }
+        ]
+      end
+    end
+  end
+end

data/lib/skymap/projection/stereographic.rb

@@ -16,6 +16,17 @@ module Skymap
           y: @center.y - distance * azimuth.cos
         )
       end
+
+      def scale_at(altitude:, azimuth:)
+        @radius / (1 + altitude.sin)
+      end
+
+      def scale_at_point(point)
+        scale = @radius / 2.0
+        distance = Math.hypot(point.x - @center.x, point.y - @center.y)
+
+        scale * (1 + (distance / (2 * scale))**2)
+      end
     end
   end
 end

data/lib/skymap/renderer/caption.rb

@@ -5,7 +5,37 @@ module Skymap
     CAPTION_SIZE_RATIO = 0.028
     CAPTION_CHARACTER_WIDTH_RATIO = 0.55
 
-    Caption = Data.define(:position, :text, :size, :kind) do
+    module TextWidth
+      def self.of(text, size)
+        text.length * size * CAPTION_CHARACTER_WIDTH_RATIO
+      end
+
+      def width
+        TextWidth.of(text, size)
+      end
+    end
+
+    Caption = Data.define(
+      :position,
+      :text,
+      :size,
+      :kind,
+      :anchor,
+      :clearance
+    ) do
+      include TextWidth
+
+      def initialize(
+        position:,
+        text:,
+        size:,
+        kind:,
+        anchor: nil,
+        clearance: 0.0
+      )
+        super
+      end
+
       def self.size_for(canvas)
         CAPTION_SIZE_RATIO * canvas.radius
       end
@@ -22,14 +52,16 @@ module Skymap
           ),
           text: text,
           size: size,
-          kind: kind
+          kind: kind,
+          anchor: center,
+          clearance: radius
         )
       end
 
       def self.within_sky(x, y, text, size, canvas)
         dy = (y - canvas.center.y).abs + size / 2
         room = Math.sqrt([canvas.radius**2 - dy**2, 0].max)
-        half_width = text.length * size * CAPTION_CHARACTER_WIDTH_RATIO / 2
+        half_width = TextWidth.of(text, size) / 2
         reach = [room - half_width, 0].max
 
         canvas.center.x + (x - canvas.center.x).clamp(-reach, reach)