geo_pattern 1.3.2 → 1.4.0

data/lib/geo_pattern/roles/comparable_metadata.rb

@@ -0,0 +1,35 @@
+module GeoPattern
+  # Roles
+  module Roles
+    # A comparable metadata
+    module ComparableMetadata
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def generator?(value)
+        return false unless value.is_a?(Class) || value.nil?
+        return true if value.nil? && @generator
+
+        return true if value == generator
+
+        false
+      end
+
+      # Class Methods
+      module ClassMethods
+        # Define comparators
+        def def_comparators(*methods)
+          methods.flatten.each do |m|
+            define_method "#{m}?".to_sym do |value|
+              return true if value.nil? && public_send(m)
+              return true if value == public_send(m)
+
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/roles/named_generator.rb

@@ -0,0 +1,13 @@
+module GeoPattern
+  module Roles
+    module NamedGenerator
+      def name?(other_name)
+        name == other_name.to_sym
+      end
+
+      def name
+        Helpers.underscore(Helpers.demodulize(self.class).gsub(/Generator/, '')).to_sym
+      end
+    end
+  end
+end

data/lib/geo_pattern/seed.rb

@@ -0,0 +1,21 @@
+module GeoPattern
+  class Seed
+    private
+
+    attr_reader :seed
+
+    public
+
+    def initialize(string)
+      @seed = Digest::SHA1.hexdigest string.to_s
+    end
+
+    def [](*args)
+      seed[*args]
+    end
+
+    def to_i(index, length)
+      seed[index, length || 1].to_i(16)
+    end
+  end
+end

data/lib/geo_pattern/structure.rb

@@ -0,0 +1,25 @@
+module GeoPattern
+  class Structure
+    include Roles::ComparableMetadata
+
+    extend Forwardable
+
+    attr_reader :image, :preset, :name, :generator
+
+    def_delegators :@preset, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max
+
+    def initialize(options)
+      @image     = options[:image]
+      @preset    = options[:preset]
+      @name      = options[:name]
+      @generator = options[:generator]
+
+      fail ArgumentError, 'Argument name is missing' if @name.nil?
+      fail ArgumentError, 'Argument image is missing' if @image.nil?
+      fail ArgumentError, 'Argument preset is missing' if @preset.nil?
+      fail ArgumentError, 'Argument generator is missing' if @generator.nil?
+    end
+
+    def_comparators :name, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max
+  end
+end

data/lib/geo_pattern/structure_generators/base_generator.rb

@@ -0,0 +1,85 @@
+module GeoPattern
+  module StructureGenerators
+    class BaseGenerator
+      include Roles::NamedGenerator
+
+      private
+
+      attr_reader :svg, :seed, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max, :preset
+      attr_accessor :height, :width
+
+      public
+
+      def initialize(seed, preset, svg = SvgImage.new)
+        @svg    = svg
+        @seed   = seed
+        @preset = preset
+
+        @fill_color_dark  = @preset.fill_color_dark
+        @fill_color_light = @preset.fill_color_light
+        @stroke_color     = @preset.stroke_color
+        @stroke_opacity   = @preset.stroke_opacity
+        @opacity_min      = @preset.opacity_min
+        @opacity_max      = @preset.opacity_max
+
+        @height = 100
+        @width  = 100
+
+        after_initialize
+      end
+
+      def generate(pattern)
+        pattern.structure = Structure.new(image: svg_image, preset: preset, generator: self.class, name: name)
+
+        pattern.height    = height
+        pattern.width     = width
+
+        self
+      end
+
+      private
+
+      # Set Svg Image
+      def svg_image
+        image = generate_structure
+        image.height = height
+        image.width  = width
+
+        image
+      end
+
+      # Hook for generators
+      def after_initialize; end
+
+      # Generate the structure
+      def generate_structure
+        fail NotImplementedError
+      end
+
+      def hex_val(index, len)
+        seed.to_i(index, len)
+      end
+
+      def fill_color(val)
+        (val.even?) ? fill_color_light : fill_color_dark
+      end
+
+      def opacity(val)
+        map(val, 0, 15, opacity_min, opacity_max)
+      end
+
+      def map(value, v_min, v_max, d_min, d_max)
+        PatternHelpers.map(value, v_min, v_max, d_min, d_max)
+      end
+
+      protected
+
+      def build_plus_shape(square_size)
+        [
+          "rect(#{square_size},0,#{square_size},#{square_size * 3})",
+          "rect(0, #{square_size},#{square_size * 3},#{square_size})"
+        ]
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/chevrons_generator.rb

@@ -0,0 +1,55 @@
+module GeoPattern
+  module StructureGenerators
+    class ChevronsGenerator < BaseGenerator
+      private
+
+      attr_reader :chevron_height, :chevron_width, :chevron
+
+      def after_initialize
+        @chevron_width  = map(hex_val(0, 1), 0, 15, 30, 80)
+        @chevron_height = map(hex_val(0, 1), 0, 15, 30, 80)
+        @chevron        = build_chevron_shape(chevron_width, chevron_height)
+
+        self.height = chevron_height * 6 * 0.66
+        self.width  = chevron_width * 6
+      end
+
+      def generate_structure
+        i = 0
+        for y in 0..5
+          for x in 0..5
+            val     = hex_val(i, 1)
+            opacity = opacity(val)
+            fill    = fill_color(val)
+
+            styles  = {
+              'stroke'         => stroke_color,
+              'stroke-opacity' => stroke_opacity,
+              'fill'           => fill,
+              'fill-opacity'   => opacity,
+              'stroke-width'   => 1
+            }
+
+            svg.group(chevron, styles.merge('transform' => "translate(#{x * chevron_width},#{y * chevron_height * 0.66 - chevron_height / 2})"))
+
+            # Add an extra row at the end that matches the first row, for tiling.
+            if (y == 0)
+              svg.group(chevron, styles.merge('transform' => "translate(#{x * chevron_width},#{6 * chevron_height * 0.66 - chevron_height / 2})"))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_chevron_shape(width, height)
+        e = height * 0.66
+        [
+          %{polyline("0,0,#{width / 2},#{height - e},#{width / 2},#{height},0,#{e},0,0")},
+          %{polyline("#{width / 2},#{height - e},#{width},0,#{width},#{e},#{width / 2},#{height},#{width / 2},#{height - e}")}
+        ]
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/concentric_circles_generator.rb

@@ -0,0 +1,56 @@
+module GeoPattern
+  module StructureGenerators
+    class ConcentricCirclesGenerator < BaseGenerator
+      private
+
+      attr_reader :scale, :ring_size, :stroke_width
+
+      def after_initialize
+        @scale        = hex_val(0, 1)
+        @ring_size    = map(scale, 0, 15, 10, 60)
+        @stroke_width = ring_size / 5
+
+        self.width = self.height = (ring_size + stroke_width) * 6
+      end
+
+      def generate_structure
+        i = 0
+        for y in 0..5
+          for x in 0..5
+            val     = hex_val(i, 1)
+            opacity = opacity(val)
+            fill    = fill_color(val)
+
+            svg.circle(
+              x * ring_size + x * stroke_width + (ring_size + stroke_width) / 2,
+              y * ring_size + y * stroke_width + (ring_size + stroke_width) / 2,
+              ring_size / 2,
+              'fill'   => 'none',
+              'stroke' => fill,
+              'style'  => {
+                'opacity' => opacity,
+                'stroke-width' => "#{stroke_width}px"
+              }
+              )
+
+            val     = hex_val(39 - i, 1)
+            opacity = opacity(val)
+            fill    = fill_color(val)
+
+            svg.circle(
+              x * ring_size + x * stroke_width + (ring_size + stroke_width) / 2,
+              y * ring_size + y * stroke_width + (ring_size + stroke_width) / 2,
+              ring_size / 4,
+              'fill'         => fill,
+              'fill-opacity' => opacity
+              )
+
+            i += 1
+          end
+        end
+
+        svg
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/diamonds_generator.rb

@@ -0,0 +1,66 @@
+module GeoPattern
+  module StructureGenerators
+    class DiamondsGenerator < BaseGenerator
+      private
+
+      attr_reader :diamond_height, :diamond_width, :diamond
+
+      def after_initialize
+        @diamond_width  = map(hex_val(0, 1), 0, 15, 10, 50)
+        @diamond_height = map(hex_val(1, 1), 0, 15, 10, 50)
+        @diamond        = build_diamond_shape(diamond_width, diamond_height)
+
+        self.height = diamond_height * 3
+        self.width  = diamond_width * 6
+      end
+
+      def generate_structure
+        i = 0
+        for y in 0..5
+          for x in 0..5
+            val     = hex_val(i, 1)
+            opacity = opacity(val)
+            fill    = fill_color(val)
+
+            styles = {
+              'fill'           => fill,
+              'fill-opacity'   => opacity,
+              'stroke'         => stroke_color,
+              'stroke-opacity' => stroke_opacity
+            }
+
+            dx = (y % 2 == 0) ? 0 : diamond_width / 2
+
+            svg.polyline(diamond, styles.merge(
+                                    'transform' => "translate(#{x * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * y - diamond_height / 2})"))
+
+            # Add an extra one at top-right, for tiling.
+            if (x == 0)
+              svg.polyline(diamond, styles.merge(
+                                      'transform' => "translate(#{6 * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * y - diamond_height / 2})"))
+            end
+
+            # Add an extra row at the end that matches the first row, for tiling.
+            if (y == 0)
+              svg.polyline(diamond, styles.merge(
+                                      'transform' => "translate(#{x * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * 6 - diamond_height / 2})"))
+            end
+
+            # Add an extra one at bottom-right, for tiling.
+            if x == 0 && y == 0
+              svg.polyline(diamond, styles.merge(
+                                      'transform' => "translate(#{6 * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * 6 - diamond_height / 2})"))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_diamond_shape(width, height)
+        "#{width / 2}, 0, #{width}, #{height / 2}, #{width / 2}, #{height}, 0, #{height / 2}"
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/hexagons_generator.rb

@@ -0,0 +1,67 @@
+module GeoPattern
+  module StructureGenerators
+    class HexagonsGenerator < BaseGenerator
+      private
+
+      attr_reader :scale, :side_length, :hex_height, :hex_width, :hex
+
+      def after_initialize
+        @scale       = hex_val(0, 1)
+        @side_length = map(scale, 0, 15, 8, 60)
+        @hex_height  = side_length * Math.sqrt(3)
+        @hex_width   = side_length * 2
+        @hex         = build_hexagon_shape(side_length)
+
+        self.width  = hex_width * 3 + side_length * 3
+        self.height = hex_height * 6
+      end
+
+      def generate_structure
+        i = 0
+        for y in 0..5
+          for x in 0..5
+            val     = hex_val(i, 1)
+            dy      = x % 2 == 0 ? y * hex_height : y * hex_height + hex_height / 2
+            opacity = opacity(val)
+            fill    = fill_color(val)
+
+            styles = {
+              'fill'           => fill,
+              'fill-opacity'   => opacity,
+              'stroke'         => stroke_color,
+              'stroke-opacity' => stroke_opacity
+            }
+
+            svg.polyline(hex, styles.merge('transform' => "translate(#{x * side_length * 1.5 - hex_width / 2}, #{dy - hex_height / 2})"))
+
+            # Add an extra one at top-right, for tiling.
+            if (x == 0)
+              svg.polyline(hex, styles.merge('transform' => "translate(#{6 * side_length * 1.5 - hex_width / 2}, #{dy - hex_height / 2})"))
+            end
+
+            # Add an extra row at the end that matches the first row, for tiling.
+            if (y == 0)
+              dy = x % 2 == 0 ? 6 * hex_height : 6 * hex_height + hex_height / 2
+              svg.polyline(hex, styles.merge('transform' => "translate(#{x * side_length * 1.5 - hex_width / 2}, #{dy - hex_height / 2})"))
+            end
+
+            # Add an extra one at bottom-right, for tiling.
+            if x == 0 && y == 0
+              svg.polyline(hex, styles.merge('transform' => "translate(#{6 * side_length * 1.5 - hex_width / 2}, #{5 * hex_height + hex_height / 2})"))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_hexagon_shape(sideLength)
+        c = sideLength
+        a = c / 2
+        b = Math.sin(60 * Math::PI / 180) * c
+        "0,#{b},#{a},0,#{a + c},0,#{2 * c},#{b},#{a + c},#{2 * b},#{a},#{2 * b},0,#{b}"
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/mosaic_squares_generator.rb

@@ -0,0 +1,85 @@
+module GeoPattern
+  module StructureGenerators
+    class MosaicSquaresGenerator < BaseGenerator
+      private
+
+      attr_reader :triangle_size
+
+      def after_initialize
+        @triangle_size = map(hex_val(0, 1), 0, 15, 15, 50)
+
+        self.height = self.width = triangle_size * 8
+      end
+
+      def generate_structure
+        i = 0
+        for y in 0..3
+          for x in 0..3
+            if x.even?
+              if y.even?
+                draw_outer_mosaic_tile(x * triangle_size * 2, y * triangle_size * 2, triangle_size, hex_val(i, 1))
+              else
+                draw_inner_mosaic_tile(x * triangle_size * 2, y * triangle_size * 2, triangle_size, [hex_val(i, 1), hex_val(i + 1, 1)])
+              end
+            else
+              if y.even?
+                draw_inner_mosaic_tile(x * triangle_size * 2, y * triangle_size * 2, triangle_size, [hex_val(i, 1), hex_val(i + 1, 1)])
+              else
+                draw_outer_mosaic_tile(x * triangle_size * 2, y * triangle_size * 2, triangle_size, hex_val(i, 1))
+              end
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def draw_inner_mosaic_tile(x, y, triangle_size, vals)
+        triangle = build_right_triangle_shape(triangle_size)
+        opacity  = opacity(vals[0])
+        fill     = fill_color(vals[0])
+        styles   = {
+          'stroke'         => stroke_color,
+          'stroke-opacity' => stroke_opacity,
+          'fill-opacity'   => opacity,
+          'fill'           => fill
+        }
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size}, #{y}) scale(-1, 1)"))
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size}, #{y + triangle_size * 2}) scale(1, -1)"))
+
+        opacity = opacity(vals[1])
+        fill    = fill_color(vals[1])
+        styles  = {
+          'stroke'         => stroke_color,
+          'stroke-opacity' => stroke_opacity,
+          'fill-opacity'   => opacity,
+          'fill'           => fill
+        }
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size}, #{y + triangle_size * 2}) scale(-1, -1)"))
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size}, #{y}) scale(1, 1)"))
+      end
+
+      def draw_outer_mosaic_tile(x, y, triangle_size, val)
+        opacity  = opacity(val)
+        fill     = fill_color(val)
+        triangle = build_right_triangle_shape(triangle_size)
+        styles   = {
+          'stroke'         => stroke_color,
+          'stroke-opacity' => stroke_opacity,
+          'fill-opacity'   => opacity,
+          'fill'           => fill
+        }
+
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x}, #{y + triangle_size}) scale(1, -1)"))
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size * 2}, #{y + triangle_size}) scale(-1, -1)"))
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x}, #{y + triangle_size}) scale(1, 1)"))
+        svg.polyline(triangle, styles.merge('transform' => "translate(#{x + triangle_size * 2}, #{y + triangle_size}) scale(-1, 1)"))
+      end
+
+      def build_right_triangle_shape(side_length)
+        "0, 0, #{side_length}, #{side_length}, 0, #{side_length}, 0, 0"
+      end
+    end
+  end
+end