skymap 0.4.0 → 0.5.0

data/lib/skymap/label_placement.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module Skymap
+  class LabelPlacement
+    RANKS = %i[field planet star deep_sky].freeze
+    MARGIN_RATIO = 0.25
+    GAP_RATIO = 0.5
+    DOT_RATIO = 0.25
+    CELL_RATIO = 4
+    DIAGONAL = Math.sqrt(0.5)
+    DIRECTIONS = [
+      [0, 1], [0, -1], [1, 0], [-1, 0], [1, 1], [-1, 1], [1, -1], [-1, -1]
+    ].freeze
+
+    Box = Data.define(:left, :top, :right, :bottom) do
+      def intersects?(other)
+        left < other.right && other.left < right &&
+          top < other.bottom && other.top < bottom
+      end
+
+      def bounds
+        self
+      end
+
+      def blocks?(other)
+        intersects?(other)
+      end
+
+      def reaches?(x, y, radius)
+        dx = [left - x, 0, x - right].max
+        dy = [top - y, 0, y - bottom].max
+
+        dx * dx + dy * dy < radius * radius
+      end
+
+      def crossed_by?(from, to)
+        dx = to.x - from.x
+        dy = to.y - from.y
+        entering = 0.0
+        leaving = 1.0
+
+        [
+          [-dx, from.x - left], [dx, right - from.x],
+          [-dy, from.y - top], [dy, bottom - from.y]
+        ].each do |direction, distance|
+          if direction.zero?
+            return false if distance.negative?
+          else
+            ratio = distance / direction
+            if direction.negative?
+              entering = ratio if ratio > entering
+            elsif ratio < leaving
+              leaving = ratio
+            end
+          end
+        end
+
+        entering <= leaving
+      end
+    end
+
+    Disc = Data.define(:center, :radius) do
+      def bounds
+        Box.new(
+          left: center.x - radius, top: center.y - radius,
+          right: center.x + radius, bottom: center.y + radius
+        )
+      end
+
+      def blocks?(box)
+        box.reaches?(center.x, center.y, radius)
+      end
+    end
+
+    Segment = Data.define(:from, :to, :bounds) do
+      def self.between(from, to)
+        new(
+          from: from,
+          to: to,
+          bounds: Box.new(
+            left: [from.x, to.x].min, top: [from.y, to.y].min,
+            right: [from.x, to.x].max, bottom: [from.y, to.y].max
+          )
+        )
+      end
+
+      def blocks?(box)
+        bounds.intersects?(box) && box.crossed_by?(from, to)
+      end
+    end
+
+    class Index
+      def initialize(cell, limit)
+        @cell = cell
+        @last = (limit / cell).floor
+        @cells = {}
+      end
+
+      def add(blocker)
+        cells_of(blocker.bounds) { |cell| (@cells[cell] ||= []) << blocker }
+      end
+
+      def blocked?(box)
+        cells_of(box) do |cell|
+          blockers = @cells[cell]
+          return true if blockers&.any? { |blocker| blocker.blocks?(box) }
+        end
+
+        false
+      end
+
+      private
+
+      def cells_of(box)
+        rows = span(box.top, box.bottom)
+
+        span(box.left, box.right).each do |column|
+          rows.each { |row| yield [column, row] }
+        end
+      end
+
+      def span(from, to)
+        [(from / @cell).floor, 0].max..[(to / @cell).floor, @last].min
+      end
+    end
+    private_constant :Box, :Disc, :Segment, :Index
+
+    def initialize(canvas:)
+      @canvas = canvas
+    end
+
+    def arrange(elements)
+      captions = elements.select { |element| anchored?(element) }
+      return elements if captions.empty?
+
+      text_size = captions.map(&:size).min
+      index = Index.new(CELL_RATIO * text_size, @canvas.size)
+      fixed_boxes(elements).each { |box| index.add(box) }
+      obstacles(elements, text_size).each { |obstacle| index.add(obstacle) }
+      placed = {}.compare_by_identity
+
+      by_priority(captions).each do |caption|
+        position = free_position(caption, index)
+        next unless position
+
+        index.add(box(caption, position))
+        placed[caption] = caption.with(position: position)
+      end
+
+      elements.filter_map do |element|
+        anchored?(element) ? placed[element] : element
+      end
+    end
+
+    private
+
+    def anchored?(element)
+      element.is_a?(Renderer::Caption) && !element.anchor.nil?
+    end
+
+    def by_priority(captions)
+      captions.each_with_index
+        .sort_by { |caption, index| [rank(caption.kind), index] }
+        .map(&:first)
+    end
+
+    def rank(kind)
+      RANKS.index(kind) || RANKS.size
+    end
+
+    def fixed_boxes(elements)
+      elements.filter_map do |element|
+        next unless text?(element) && !anchored?(element)
+
+        box(element, element.position)
+      end
+    end
+
+    def text?(element)
+      element.is_a?(Renderer::Caption) || element.is_a?(Renderer::Label)
+    end
+
+    def obstacles(elements, text_size)
+      bright = DOT_RATIO * text_size
+
+      elements.flat_map do |element|
+        case element
+        when Renderer::DeepSkySymbol then symbol(element)
+        when Renderer::Planet, Renderer::Moon, Renderer::Sun
+          [Disc.new(center: element.center, radius: element.radius)]
+        when Renderer::Dot
+          next [] if element.radius < bright
+
+          [Disc.new(center: element.center, radius: element.radius)]
+        else
+          []
+        end
+      end
+    end
+
+    def symbol(symbol)
+      unless symbol.hollow?
+        return [Disc.new(center: symbol.center, radius: symbol.semi_major)]
+      end
+
+      points = symbol.outline
+
+      points.zip(points.rotate).map { |from, to| Segment.between(from, to) }
+    end
+
+    def free_position(caption, index)
+      candidates(caption).find do |position, check_sky|
+        !index.blocked?(box(caption, position)) &&
+          (!check_sky || inside_sky?(caption, position))
+      end&.first
+    end
+
+    def candidates(caption)
+      around = DIRECTIONS.map { |direction| [at(caption, direction), true] }
+
+      [[caption.position, false]] + around
+    end
+
+    def at(caption, direction)
+      anchor = caption.anchor
+      size = caption.size
+      ux, uy = direction
+      reach_x = uy.zero? ? caption.clearance : caption.clearance * DIAGONAL
+      reach_y = ux.zero? ? caption.clearance : caption.clearance * DIAGONAL
+      gap = GAP_RATIO * size
+
+      Point.new(
+        x: anchor.x + ux * (reach_x + gap + caption.width / 2),
+        y: anchor.y + uy * (reach_y + size)
+      )
+    end
+
+    def inside_sky?(caption, position)
+      half_width = caption.width / 2
+      half_height = caption.size / 2
+
+      [-1, 1].product([-1, 1]).all? do |sx, sy|
+        Math.hypot(
+          position.x + sx * half_width - @canvas.center.x,
+          position.y + sy * half_height - @canvas.center.y
+        ) <= @canvas.radius
+      end
+    end
+
+    def box(text, position)
+      margin = MARGIN_RATIO * text.size
+      half_width = text.width / 2 + margin
+      half_height = text.size / 2 + margin
+
+      Box.new(
+        left: position.x - half_width,
+        top: position.y - half_height,
+        right: position.x + half_width,
+        bottom: position.y + half_height
+      )
+    end
+  end
+end

data/lib/skymap/layers/cardinal_directions.rb

@@ -7,6 +7,8 @@ module Skymap
       CARDINAL_SIZE_RATIO = 0.6
 
       def elements(context)
+        return [] unless context.full_sky?
+
         canvas = context.canvas
 
         CARDINAL_DIRECTIONS.map do |text, azimuth|

data/lib/skymap/layers/constellation_lines.rb

@@ -11,11 +11,14 @@ module Skymap
       end
 
       def elements(context)
-        stars_by_hr = Star.by_hr(@stars)
+        stars_by_hr = StarList.wrap(@stars).by_hr
 
         @lines.filter_map do |line|
           ends = [line.from, line.to].map { |hrs| stars_by_hr.values_at(*hrs) }
           next if ends.flatten.include?(nil)
+          next unless ends.flatten.all? { |star|
+            context.reachable?(context.horizontal(star))
+          }
 
           directions = ends.map do |end_stars|
             Horizon.direction(
@@ -34,6 +37,8 @@ module Skymap
               Point.midpoint(end_stars.map { |star| context.position(star) })
             end
           end
+          next unless context.crosses_view?([from, to])
+
           Renderer::Line.new(
             from: from,
             to: to,

data/lib/skymap/layers/constellation_names.rb

@@ -10,7 +10,7 @@ module Skymap
       end
 
       def elements(context)
-        stars_by_hr = Star.by_hr(@stars)
+        stars_by_hr = StarList.wrap(@stars).by_hr
 
         @lines.group_by(&:constellation).filter_map do |abbreviation, lines|
           name = @names[abbreviation]
@@ -23,8 +23,11 @@ module Skymap
           next if risen.sum(&:size) * 2 <= parts.sum(&:size)
 
           biggest = risen.max_by(&:size)
+          position = Point.midpoint(biggest.map { |s| context.position(s) })
+          next unless context.in_view?(position)
+
           Renderer::Caption.new(
-            position: Point.midpoint(biggest.map { |s| context.position(s) }),
+            position: position,
             text: name,
             size: Renderer::Caption.size_for(context.canvas),
             kind: :constellation

data/lib/skymap/layers/deep_sky_objects.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class DeepSkyObjects
+      DEFAULT_MAGNITUDE_LIMIT = 11
+      MIN_RADIUS_RATIO = 0.012
+      LINE_WIDTH_RATIO = 0.003
+
+      def initialize(
+        objects:,
+        magnitude_limit: DEFAULT_MAGNITUDE_LIMIT,
+        labels: false
+      )
+        MagnitudeLimit.check(magnitude_limit)
+
+        @objects = objects
+        @magnitude_limit = magnitude_limit
+        @labels = labels
+      end
+
+      def elements(context)
+        radius = context.canvas.radius
+        minimum = MIN_RADIUS_RATIO * radius
+        width = LINE_WIDTH_RATIO * radius
+
+        brightest_first.flat_map do |object|
+          draw(context, object, minimum, width)
+        end
+      end
+
+      private
+
+      def brightest_first
+        @objects.each_with_index
+          .reject { |object, _| too_faint?(object) }
+          .sort_by { |object, index| [object.magnitude || Float::INFINITY, index] }
+          .map(&:first)
+      end
+
+      def too_faint?(object)
+        object.magnitude && object.magnitude > @magnitude_limit
+      end
+
+      def draw(context, object, minimum, width)
+        coordinates = object.equatorial_coordinates
+        horizontal = context.horizontal_coordinates(coordinates)
+        return [] if horizontal.altitude.negative?
+
+        center = context.project(
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+        semi_major, semi_minor = semi_axes(context, object, horizontal, minimum)
+        return [] unless context.in_view?(center, semi_major)
+
+        drawn = Renderer::DeepSkySymbol.new(
+          center: center,
+          kind: object.type,
+          semi_major: semi_major,
+          semi_minor: semi_minor,
+          rotation: rotation(context, object),
+          width: width
+        )
+
+        [drawn, caption(context, object, center, semi_major)].compact
+      end
+
+      def semi_axes(context, object, horizontal, minimum)
+        major, minor = axes(object)
+        return [minimum, minimum] unless major
+
+        pixels = ->(angle) {
+          context.span(
+            angle,
+            altitude: horizontal.altitude,
+            azimuth: horizontal.azimuth
+          ) / 2
+        }
+        semi_major = pixels.call(major)
+        semi_minor = pixels.call(minor)
+        growth = [minimum / semi_major, 1].max
+
+        [semi_major * growth, semi_minor * growth]
+      end
+
+      def axes(object)
+        major = object.major_axis
+        return unless major
+
+        minor = object.minor_axis
+        return [major, minor] if round?(object) || object.position_angle
+
+        equal_area = Astronoby::Angle.from_radians(
+          Math.sqrt(major.radians * minor.radians)
+        )
+
+        [equal_area, equal_area]
+      end
+
+      def round?(object)
+        object.major_axis == object.minor_axis
+      end
+
+      def rotation(context, object)
+        angle = object.position_angle
+        return 0.0 if angle.nil? || round?(object)
+
+        context.rotation_at(
+          object.equatorial_coordinates,
+          position_angle: angle
+        ).degrees
+      end
+
+      def caption(context, object, center, radius)
+        return unless @labels
+
+        Renderer::Caption.beside(
+          center: center,
+          radius: radius,
+          canvas: context.canvas,
+          text: object.designation,
+          kind: :deep_sky
+        )
+      end
+    end
+  end
+end

data/lib/skymap/layers/ecliptic.rb

@@ -17,7 +17,7 @@ module Skymap
       def elements(context)
         width = LINE_WIDTH_RATIO * context.canvas.radius
 
-        joined(Horizon.visible_runs(context, @points)).map do |points|
+        Horizon.joined(Horizon.visible_runs(context, @points)).map do |points|
           Renderer::Ecliptic.new(points: points, width: width)
         end
       end
@@ -33,12 +33,6 @@ module Skymap
           epoch: Astronoby::JulianDate::J2000
         )
       end
-
-      def joined(runs)
-        return runs unless runs.size > 1 && runs.first.first == runs.last.last
-
-        [runs.last + runs.first.drop(1)] + runs[1...-1]
-      end
     end
   end
 end

data/lib/skymap/layers/field_circles.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Skymap
+  module Layers
+    class FieldCircles
+      LINE_WIDTH_RATIO = 0.004
+      MAX_DEVIATION = 0.1
+      MIN_SAMPLES = 16
+      MAX_SAMPLES = 360
+
+      def initialize(fields:, center: nil, labels: false)
+        check_fields(fields)
+        check_center(center)
+
+        @fields = fields
+        @center = center
+        @labels = labels
+      end
+
+      def elements(context)
+        center = center_in(context)
+        return [] unless center
+
+        frame = frame_around(center)
+        width = LINE_WIDTH_RATIO * context.canvas.radius
+
+        @fields.flat_map do |field|
+          circle(context, center, frame, field, width)
+        end
+      end
+
+      private
+
+      def circle(context, center, frame, field, width)
+        radius = Astronoby::Angle.from_radians(field.true_field.radians / 2.0)
+        samples = sample_count(context, center, radius)
+        path = path_of(context, ring(context, frame, radius, samples))
+        runs = Horizon.joined(Horizon.runs_of(context, path))
+        return [] if runs.empty?
+
+        circles = runs.map do |points|
+          Renderer::FieldCircle.new(points: points, width: width)
+        end
+        circles + caption(context, field, path.compact)
+      end
+
+      def sample_count(context, center, radius)
+        pixels = context.span(
+          radius,
+          altitude: center.altitude,
+          azimuth: center.azimuth
+        )
+        step = Math.acos([1 - MAX_DEVIATION / pixels, -1].max)
+        return MAX_SAMPLES unless step.positive?
+
+        samples = (Math::PI / step).ceil.clamp(MIN_SAMPLES, MAX_SAMPLES)
+
+        samples + -samples % 4
+      end
+
+      def ring(context, frame, radius, samples)
+        forward, side, up = frame
+        points = (0...samples).map do |index|
+          angle = 2 * Math::PI * index / samples
+          direction = (0..2).map do |axis|
+            radius.cos * forward[axis] +
+              radius.sin * (Math.cos(angle) * side[axis] +
+                Math.sin(angle) * up[axis])
+          end
+          Astronoby::Coordinates::Horizontal.new(
+            altitude: Astronoby::Angle.from_radians(
+              Math.asin(direction[2].clamp(-1, 1))
+            ),
+            azimuth: Astronoby::Angle.from_radians(
+              Math.atan2(direction[1], direction[0])
+            ),
+            observer: context.observer
+          )
+        end
+
+        points + points.first(1)
+      end
+
+      def path_of(context, horizontals)
+        [position(context, horizontals.first)] +
+          horizontals.each_cons(2).flat_map do |from, to|
+            crossing(context, from, to) + [position(context, to)]
+          end
+      end
+
+      def crossing(context, from, to)
+        return [] unless context.full_sky?
+
+        Horizon.crossing_point(context, from, to)
+      end
+
+      def position(context, horizontal)
+        return if context.full_sky? && horizontal.altitude.negative?
+        return unless context.reachable?(horizontal)
+
+        context.project(
+          altitude: horizontal.altitude,
+          azimuth: horizontal.azimuth
+        )
+      end
+
+      def caption(context, field, points)
+        return [] unless @labels
+
+        xs, ys = points.map(&:x), points.map(&:y)
+        caption = Renderer::Caption.beside(
+          center: Point.new(
+            x: (xs.min + xs.max) / 2.0,
+            y: (ys.min + ys.max) / 2.0
+          ),
+          radius: (ys.max - ys.min) / 2.0,
+          canvas: context.canvas,
+          text: field.label,
+          kind: :field
+        )
+
+        context.in_view?(caption.position) ? [caption] : []
+      end
+
+      def center_in(context)
+        center = @center || context.view&.center
+        return unless center
+
+        context.to_horizontal(center)
+      end
+
+      def frame_around(center)
+        Geometry.frame(
+          [
+            center.altitude.cos * center.azimuth.cos,
+            center.altitude.cos * center.azimuth.sin,
+            center.altitude.sin
+          ]
+        )
+      end
+
+      def check_fields(fields)
+        valid = fields.is_a?(Array) && !fields.empty? &&
+          fields.all? { |field| field?(field) }
+        return if valid
+
+        raise ArgumentError,
+          "fields must be a list of Skymap::Field or Skymap::Setup, " \
+          "or anything with a true_field angle and a label"
+      end
+
+      def field?(field)
+        field.respond_to?(:true_field) && field.respond_to?(:label) &&
+          field.true_field.is_a?(Astronoby::Angle) &&
+          field.true_field.positive? && field.true_field.radians <= Math::PI &&
+          field.label.is_a?(String)
+      end
+
+      def check_center(center)
+        return if center.nil? ||
+          center.is_a?(Astronoby::Coordinates::Equatorial) ||
+          center.is_a?(Astronoby::Coordinates::Horizontal)
+
+        raise ArgumentError,
+          "center must be equatorial or horizontal coordinates"
+      end
+    end
+  end
+end