dieses 0.0.1

data/lib/dieses/geometry/element.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Geometry
+    class Element
+      BoundingBox = Struct.new :minimum, :maximum
+
+      attr_reader :attributes, :hash
+
+      def initialize
+        @attributes = {}
+        @hash       = self.class.hash ^ to_h.hash
+        freeze
+      end
+
+      def attr(**kwargs)
+        tap do
+          kwargs.each { |key, value| attributes[key.to_sym] = value }
+        end
+      end
+
+      def classify(*tags, **kwargs)
+        existing_class = attributes[:class] || Set.new
+        attr(**kwargs, tags: existing_class.add(tags))
+      end
+
+      def to_svg
+        format to_svgf, attributes: Support.kwargs_to_s(**attributes)
+      end
+
+      def eql?(other)
+        return false unless other.is_a? self.class
+
+        to_h == other.to_h
+      end
+
+      alias == eql?
+    end
+
+    class << self
+      def centered(elements, rect)
+        bbox = bounding_box_of(*elements)
+
+        x = (rect.width  - bbox.maximum.x + bbox.minimum.x) / 2
+        y = (rect.height - bbox.maximum.y + bbox.minimum.y) / 2
+
+        elements.map { |element| element.translate(x: x, y: y).attr(**element.attributes.dup) }
+      end
+
+      def to_svg(elements, rect = Undefined, prefix: EMPTY_STRING)
+        (Undefined.equal?(rect) ? elements : centered(elements, rect)).map do |element|
+          "#{prefix}#{element.to_svg}"
+        end.join.chomp
+      end
+
+      def bounding_box_of(*elements)
+        bboxes = elements.map(&:bbox)
+
+        minimum = bboxes.map(&:minimum).min
+        maximum = bboxes.map(&:maximum).max
+
+        Element::BoundingBox.new minimum, maximum
+      end
+    end
+  end
+end

data/lib/dieses/geometry/equation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'equation/slant'
+require_relative 'equation/steep'
+
+module Dieses
+  module Geometry
+    module Equation
+      module_function
+
+      def from_line(line)
+        starting, ending = line.starting, line.ending
+
+        if (c = starting.x) == ending.x
+          vertical(c)
+        elsif (c = starting.y) == ending.y
+          horizontal(c)
+        else
+          slope     = (ending.y - starting.y) / (ending.x - starting.x)
+          intercept = starting.y - slope * starting.x
+
+          slant(slope: slope, intercept: intercept)
+        end
+      end
+
+      def slant(slope:, intercept:)
+        Slant.new slope: slope, intercept: intercept
+      end
+
+      def slant_from_direction(point:, angle:)
+        return horizontal(point.y) if (angle % 180).zero?
+        return vertical(point.x)   if (angle % 90).zero?
+
+        slope     = Math.tan(Support.to_radian(angle.to_f))
+        intercept = point.y - slope * point.x
+
+        slant(slope: slope, intercept: intercept)
+      end
+
+      def steep(c)
+        Steep.new c
+      end
+
+      class << self
+        alias vertical steep
+      end
+
+      def horizontal(c)
+        slant(slope: 0.0, intercept: c)
+      end
+
+      def intersect(u, v)
+        u.intersect(v)
+      end
+    end
+  end
+end

data/lib/dieses/geometry/equation/slant.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Geometry
+    module Equation
+      class Slant
+        attr_reader :slope, :intercept
+
+        def initialize(slope:, intercept:)
+          @slope, @intercept = slope.to_f, intercept.to_f
+          freeze
+        end
+
+        def x(y)
+          (y - intercept) / slope
+        end
+
+        def y(x)
+          slope * x + intercept
+        end
+
+        # When distance given, y = m * x + n (m, n positive) equation moves to the right (x increases, y decreases)
+        def translate(distance = nil, x: nil, y: nil)
+          dx, dy = 0, 0
+
+          intercept = self.intercept
+
+          dx, dy = distance * Math.cos(angle_in_radian), -distance * Math.sin(angle_in_radian) if distance
+
+          dx += x if x
+          dy += y if y
+
+          intercept -= slope * dx
+          intercept += dy
+
+          self.class.new slope: slope, intercept: intercept
+        end
+
+        def angle_in_radian
+          Math.atan(slope)
+        end
+
+        def intersect(other)
+          case other
+          when Slant
+            x = (other.intercept - intercept) / (slope - other.slope)
+            y = slope * x + intercept
+          when Steep
+            x = other.x
+            y = y(x)
+          end
+
+          Point.new(x, y)
+        end
+
+        def left?(point, precision: Support::Float.precision)
+          Support.almost_greater_than(point.y, y(point.x), precision: precision)
+        end
+
+        def right?(point, precision: Support::Float.precision)
+          Support.almost_less_than(point.y, y(point.x), precision: precision)
+        end
+
+        def onto?(point, precision: Support::Float.precision)
+          Support.almost_equal(point.y, y(point.x), precision: precision)
+        end
+
+        def eql?(other)
+          self.class == other.class && to_h == other.to_h
+        end
+
+        alias == eql?
+
+        def hash
+          self.class.hash ^ to_h.hash
+        end
+
+        def to_h
+          { slope: scope, intercept: intercept }
+        end
+
+        def to_s
+          "E(y = #{slope} * x + #{intercept})"
+        end
+      end
+    end
+  end
+end

data/lib/dieses/geometry/equation/steep.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Geometry
+    module Equation
+      class Steep
+        def initialize(c)
+          @x = c
+        end
+
+        def y(_ = nil)
+          Float::INFINITY
+        end
+
+        def x(_ = nil)
+          @x
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def translate(distance = nil, x: nil, y: nil)
+          self.class.new self.x + (distance || 0.0) + (x || 0.0)
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+
+        def intersect(other)
+          case other
+          when Slant
+            x = self.x
+            y = other.y(x)
+          when Steep
+            x = Float::INFINITY
+            y = Float::INFINITY
+          end
+
+          Point.new(x, y)
+        end
+
+        def left?(point, precision: Support::Float.precision)
+          Support.almost_less_than(point.x, x(point.y), precision: precision)
+        end
+
+        def right?(point, precision: Support::Float.precision)
+          Support.almost_greater_than(point.x, x(point.y), precision: precision)
+        end
+
+        def onto?(point, precision: Support::Float.precision)
+          Support.almost_equal(point.x, x(point.y), precision: precision)
+        end
+
+        def eql?(other)
+          self.class == other.class && x == other.x
+        end
+
+        alias == eql?
+
+        def hash
+          self.class.hash ^ to_h.hash
+        end
+
+        def to_h
+          { x: x }
+        end
+
+        def to_s
+          "E(x = #{c})"
+        end
+      end
+    end
+  end
+end

data/lib/dieses/geometry/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Geometry
+    Error = Class.new Error
+  end
+end

data/lib/dieses/geometry/line.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Dieses
+  module Geometry
+    class Line < Element
+      extend Forwardable
+
+      def_delegators :@equation, :left?, :right?, :intersect
+
+      attr_reader :starting, :ending, :equation
+
+      def initialize(starting, ending)
+        @starting, @ending = Point.cast(starting), Point.cast(ending)
+        @equation = Equation.from_line(self)
+
+        super()
+      end
+
+      def translate(x: nil, y: nil)
+        starting, ending = [self.starting, self.ending].map { |point| point.translate(x: x, y: y) }
+        self.class.new starting, ending
+      end
+
+      def duplicate(x: nil, y: nil, count: 1)
+        lines, line = [], self
+
+        count.times do
+          lines << line
+          line = line.translate(x: x, y: y)
+        end
+
+        [lines, line]
+      end
+
+      def duplicates(x: nil, y: nil, count: 1)
+        lines, = duplicate(x: x, y: y, count: count)
+        lines
+      end
+
+      def onto?(point)
+        equation.onto?(point) && point >= starting && point <= ending
+      end
+
+      def to_svgf
+        x1, y1, x2, y2 = [*starting.to_a, *ending.to_a].map { |value| Support.approx(value) }
+
+        <<~SVG
+          <line x1="#{x1}" y1="#{y1}" x2="#{x2}" y2="#{y2}" %{attributes}/>
+        SVG
+      end
+
+      def to_s
+        "L(#{starting}, #{ending})"
+      end
+
+      def to_h
+        { starting: starting, ending: ending }
+      end
+
+      def bbox
+        BoundingBox.new([starting, ending].min, [starting, ending].max)
+      end
+    end
+  end
+end

data/lib/dieses/geometry/point.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Geometry
+    class Point
+      include Comparable
+
+      attr_reader :x, :y, :hash
+
+      def initialize(x, y)
+        @x, @y = x.to_f, y.to_f
+        @hash  = Point.hash ^ to_a.hash
+
+        freeze
+      end
+
+      def translate(x: nil, y: nil)
+        self.class.new(self.x + (x || 0), self.y + (y || 0))
+      end
+
+      def distance(other = nil)
+        self.class.distance(self, other)
+      end
+
+      def approx(precision = nil)
+        self.class.new Support.approx(x, precision), Support.approx(y, precision)
+      end
+
+      def <=>(other)
+        return unless other.is_a? Point
+
+        to_a <=> other.to_a
+      end
+
+      def eql?(other)
+        return false unless other.is_a? Point
+
+        to_a == other.to_a
+      end
+
+      alias == eql?
+
+      def to_s
+        "P(#{x}, #{y})"
+      end
+
+      def to_a
+        [x, y]
+      end
+
+      def to_h
+        { x: x, y: y }
+      end
+
+      class << self
+        def call(*args)
+          new(*args)
+        end
+
+        def origin
+          new 0.0, 0.0
+        end
+
+        def distance(starting, ending)
+          ending ||= origin
+          Math.sqrt((ending.x - starting.x)**2 + (starting.y - ending.y)**2)
+        end
+
+        def cast(point)
+          Point.new(point.x, point.y)
+        end
+      end
+
+      class Mutable < Point
+        attr_writer :x, :y
+
+        def initialize(x, y) # rubocop:disable Lint/MissingSuper
+          @x, @y = x.to_f, y.to_f
+        end
+
+        def hash
+          (@hash ||= self.class.hash) ^ to_a.hash
+        end
+
+        def translate!(x: nil, y: nil)
+          tap do
+            self.x += (x || 0)
+            self.y += (y || 0)
+          end
+        end
+
+        def self.cast(immutable_point)
+          Mutable.new(immutable_point.x, immutable_point.y)
+        end
+      end
+    end
+  end
+end