grid_generator 0.2.22 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1327abac79b922cc0a29266a8aa8cbf58e16c37650af0562a160afbfa699059
-  data.tar.gz: fee34dc3995f296391beeca679aaa76c3a369cea551f455b265e392074778996
+  metadata.gz: 812b6c5f247baa77cba970a91dd52c6b6663d1985563db1d21f173f44e391da1
+  data.tar.gz: 1f0ac5ba29dc0983fe13acd9fb778047b4145cac67e19b39c1fe8a77135faefe
 SHA512:
-  metadata.gz: 9bd94d3336e91193a5fe43ea79f219b5fec06e61d7ab26b0508dcae04b96d023113c446adca8088f4ff0d2727c9d32ffa653d284f98f61b7a3110da1cccb12b2
-  data.tar.gz: 055ad28e29b8dd6bdd6294cc953e8e1e3cdda3db30ea87118bb344839ff3df366a21707a0bcfae30680c64c2451457eb1dbab821675301446e701dcb4cd9692c
+  metadata.gz: dd16fdc6510169001c957ac24342ed79cfc9d79fe96c98011f6270d6223a9a1dc08737dda987617068b4d30581abb519c8dba09cea83fffb438f4310a2e4847c
+  data.tar.gz: e634b12f6070af21ea72cf5e7b6dc5fea167e0c511bdb03d1dfc3829145b80f1d87894ed09503c03270b4ad20fab6381e638b97fd81027990d89561ea2b1fa5c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grid_generator (0.2.22)
+    grid_generator (0.2.24)
       matrix (~> 0.4.2)
 
 GEM

data/lib/grid_generator/megaminx/face_element_factory.rb

@@ -3,7 +3,7 @@ require_relative '../face_parser'
 module GridGenerator
   module Megaminx
     class FaceElementFactory
-      def initialize(x:, y:, index:, face_points: , face_lines:, face:)
+      def initialize(x:, y:, index:, face_points: , face_lines:, face:, rotator: )
         @x, @y = x, y
         @index = index
         @face_points = face_points
@@ -11,9 +11,10 @@ module GridGenerator
         face_attr = FaceParser.new(face).parse
         @colour = face_attr && face_attr[:colour]
         @opacity = face_attr && face_attr[:opacity]
+        @rotator = rotator 
       end
 
-      attr_reader :x, :y, :index, :face_points, :face_lines, :colour, :opacity 
+      attr_reader :x, :y, :index, :face_points, :face_lines, :colour, :opacity, :rotator 
 
       def offset
         Matrix.column_vector([x, y])
@@ -81,7 +82,7 @@ module GridGenerator
           end
         end
 
-        all_points.map { |p| p + offset }
+        all_points.map { |p| rotator.rotate(p) + offset }
       end
 
       def build

data/lib/grid_generator/megaminx/face_projection.rb

@@ -9,7 +9,7 @@ module GridGenerator
     class FaceProjection
       # units 30 - pentagon 90 - megaminx - 150
       # units * 5 
-      def initialize(x:, y:, units:, front_face_elements: "", top_right_face_elements: "", right_face_elements: "", down_face_elements: "", left_face_elements: "", top_left_face_elements: "")
+      def initialize(x:, y:, units:, front_face_elements: "", top_right_face_elements: "", right_face_elements: "", down_face_elements: "", left_face_elements: "", top_left_face_elements: "", rotation_offset: 0)
         @x, @y = x, y
         @units = units
         @front_face_elements = front_face_elements.split(',')
@@ -18,14 +18,29 @@ module GridGenerator
         @down_face_elements = down_face_elements.split(',')
         @left_face_elements = left_face_elements.split(',')
         @top_left_face_elements = top_left_face_elements.split(',')
+        @rotation_offset = rotation_offset
       end
 
-      attr_reader :x, :y, :units, :front_face_elements, :top_right_face_elements, :right_face_elements, :down_face_elements, :left_face_elements, :top_left_face_elements
+      attr_reader :x, :y, :units, :front_face_elements, :top_right_face_elements, :right_face_elements, :down_face_elements, :left_face_elements, :top_left_face_elements, :rotation_offset
+
+      def outside_face_elements
+        [
+          top_right_face_elements,
+          right_face_elements,
+          down_face_elements,
+          left_face_elements,
+          top_left_face_elements
+        ]
+      end
 
       def offset
         @offset ||= Matrix.column_vector([x, y])
       end
 
+      def offset_rotator
+        @offset_rotator ||= GridGenerator::Rotator.new(angle: rotation_offset, rotation_point: rotation_point)    
+      end
+
       def decagon_radius
         5 * units
       end
@@ -82,24 +97,11 @@ module GridGenerator
         ]
       end
 
-      def right_pentagon_points
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 0.4, rotation_point: rotation_point)
-        @right_pentagon_points ||= top_right_pentagon_points.map { |p| rotator.rotate(p) } 
-      end
-
-      def down_pentagon_points
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 0.8, rotation_point: rotation_point)
-        @down_pentagon_points ||= top_right_pentagon_points.map { |p| rotator.rotate(p) } 
-      end
-
-      def left_pentagon_points
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 1.2, rotation_point: rotation_point)
-        @left_pentagon_points ||= top_right_pentagon_points.map { |p| rotator.rotate(p) } 
-      end
-
-      def top_left_pentagon_points
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 1.6, rotation_point: rotation_point)
-        @top_left_pentagon_points ||= top_right_pentagon_points.map { |p| rotator.rotate(p) } 
+      def outside_pentagon_points
+        @outside_pentagon_points ||= (0..4).map do |i|
+          rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
+          top_right_pentagon_points.map { |p| rotator.rotate(p) } 
+        end
       end
 
       def front_face_lines_raw
@@ -118,10 +120,10 @@ module GridGenerator
 
       def top_right_face_lines_raw
         @top_right_face_lines_raw ||= (0..4).map do |i| 
-          a = top_right_pentagon_points[i-1] # offset by one so first line is top right
-          b = top_right_pentagon_points[(i)%5]
-          c = top_right_pentagon_points[(i+1)%5]
-          d = top_right_pentagon_points[(i+2)%5]
+          a = outside_pentagon_points[0][i-1] # offset by one so first line is top right
+          b = outside_pentagon_points[0][(i)%5]
+          c = outside_pentagon_points[0][(i+1)%5]
+          d = outside_pentagon_points[0][(i+2)%5]
 
           ab_intervals = GridGenerator::Helper.intervals(a,b,2)
           cd_intervals = GridGenerator::Helper.intervals(c,d,2)
@@ -130,72 +132,46 @@ module GridGenerator
         end
       end
 
-      def right_face_lines_raw
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 0.4, rotation_point: rotation_point)
-        @right_face_lines_raw ||= top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
-      end
-
-      def down_face_lines_raw
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 0.8, rotation_point: rotation_point)
-        @down_face_lines_raw ||= top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
-      end
-
-      def left_face_lines_raw
-        rotator = GridGenerator::Rotator.new(angle: Math::PI * 1.2, rotation_point: rotation_point)
-        @left_face_lines_raw ||= top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
+      def outside_face_lines_raw
+        @outside_face_lines_raw ||= (0..4).map do |i|
+          rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
+          top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
+        end
       end
 
       def top_left_face_lines_raw
         rotator = GridGenerator::Rotator.new(angle: Math::PI * 1.6, rotation_point: rotation_point)
-        @top_left_face_lines_raw ||= top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
+        @top_left_face_lines_raw ||= outside_face_lines_raw[0].map { |l| rotator.rotate(l) } 
       end
 
       # for svg
-      def connecting_lines
-        pentagon_points.each_with_index.map do |p, i|
-          d = decagon_points[i*2]
-          GridGenerator::Line.new(a: p, b: d) + offset
-        end
-      end
-
-      # for svg
-      def top_right_face_lines
-        top_right_face_lines_raw.map { |l| l + offset }
-      end
-
-      # for svg
-      def right_face_lines
-        right_face_lines_raw.map { |l| l + offset }
-      end
-
-      # for svg
-      def down_face_lines
-        down_face_lines_raw.map { |l| l + offset }
+      def decagon_points_string
+        decagon_points.map { |p| offset_rotator.rotate(p) + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
       end
 
       # for svg
-      def left_face_lines
-        left_face_lines_raw.map { |l| l + offset }
+      def pentagon_points_string
+        pentagon_points.map { |p| offset_rotator.rotate(p) + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
       end
 
       # for svg
-      def top_left_face_lines
-        top_left_face_lines_raw.map { |l| l + offset }
+      def connecting_lines
+        pentagon_points.each_with_index.map do |p, i|
+          d = decagon_points[i*2]
+          offset_rotator.rotate(GridGenerator::Line.new(a: p, b: d)) + offset
+        end
       end
 
       # for svg
       def front_face_lines
-        front_face_lines_raw.map { |l| l + offset }
-      end
-
-      # for svg
-      def decagon_points_string
-        decagon_points.map { |p| p + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+        front_face_lines_raw.map { |l| offset_rotator.rotate(l) + offset }
       end
 
       # for svg
-      def pentagon_points_string
-        pentagon_points.map { |p| p + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+      def outside_face_lines
+        outside_face_lines_raw.map do |face_lines|
+          face_lines.map { |l| offset_rotator.rotate(l) + offset }
+        end
       end
 
       # for svg
@@ -207,75 +183,27 @@ module GridGenerator
             index: i,
             face_points: pentagon_points,
             face_lines: front_face_lines_raw,
-            face: element
+            face: element,
+            rotator: offset_rotator
           ).build unless element == '-'
         end.compact
       end
 
       # for svg
-      def top_right_face_element_shapes
-        top_right_face_elements.each_with_index.map do |element, i|
-          GridGenerator::Megaminx::FaceElementFactory.new(
-            x: x,
-            y: y,
-            index: i,
-            face_points: top_right_pentagon_points,
-            face_lines: top_right_face_lines_raw,
-            face: element
-          ).build unless element == '-'
-        end.compact
-      end
-
-      def right_face_element_shapes
-        right_face_elements.each_with_index.map do |element, i|
-          GridGenerator::Megaminx::FaceElementFactory.new(
-            x: x,
-            y: y,
-            index: i,
-            face_points: right_pentagon_points,
-            face_lines: right_face_lines_raw,
-            face: element
-          ).build unless element == '-'
-        end.compact
-      end
-
-      def down_face_element_shapes
-        down_face_elements.each_with_index.map do |element, i|
-          GridGenerator::Megaminx::FaceElementFactory.new(
-            x: x,
-            y: y,
-            index: i,
-            face_points: down_pentagon_points,
-            face_lines: down_face_lines_raw,
-            face: element
-          ).build unless element == '-'
-        end.compact
-      end
-
-      def left_face_element_shapes
-        left_face_elements.each_with_index.map do |element, i|
-          GridGenerator::Megaminx::FaceElementFactory.new(
-            x: x,
-            y: y,
-            index: i,
-            face_points: left_pentagon_points,
-            face_lines: left_face_lines_raw,
-            face: element
-          ).build unless element == '-'
-        end.compact
-      end
-
-      def top_left_face_element_shapes
-        top_left_face_elements.each_with_index.map do |element, i|
-          GridGenerator::Megaminx::FaceElementFactory.new(
-            x: x,
-            y: y,
-            index: i,
-            face_points: top_left_pentagon_points,
-            face_lines: top_left_face_lines_raw,
-            face: element
-          ).build unless element == '-'
-        end.compact
+      def outside_face_element_shapes
+        outside_face_elements.each_with_index.map do |face_elements, face_index|
+          face_elements.each_with_index.map do |element, element_index|
+            GridGenerator::Megaminx::FaceElementFactory.new(
+              x: x,
+              y: y,
+              index: element_index,
+              face_points: outside_pentagon_points[face_index],
+              face_lines: outside_face_lines_raw[face_index],
+              face: element,
+              rotator: offset_rotator
+            ).build unless element == '-'
+          end.compact
+        end
       end
     end
   end

data/lib/grid_generator/rotator.rb

@@ -13,6 +13,7 @@ module GridGenerator
 
     # subtract rotation point to move point towards 0,0, rotate, then add to move back
     def rotate(obj)
+      return obj if angle == 0 
       case obj
       when Matrix
         (matrix * (obj - rotation_point)) + rotation_point

data/lib/grid_generator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GridGenerator
-  VERSION = "0.2.22"
+  VERSION = "0.2.24"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grid_generator
 version: !ruby/object:Gem::Version
-  version: 0.2.22
+  version: 0.2.24
 platform: ruby
 authors:
 - Mark Humphreys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: matrix