geo_pattern 1.2.1 → 1.3.0

data/lib/geo_pattern/pattern/mosaic_squares_pattern.rb

@@ -0,0 +1,76 @@
+module GeoPattern
+  class MosaicSquaresPattern < BasePattern
+    def render_to_svg
+      triangle_size = map(hex_val(0, 1), 0, 15, 15, 50)
+
+      svg.set_width(triangle_size * 8)
+      svg.set_height(triangle_size * 8)
+
+      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
+    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

data/lib/geo_pattern/pattern/nested_squares_pattern.rb

@@ -0,0 +1,51 @@
+module GeoPattern
+  class NestedSquaresPattern < BasePattern
+    def render_to_svg
+      block_size = map(hex_val(0, 1), 0, 15, 4, 12)
+      square_size = block_size * 7
+
+      svg.set_width((square_size + block_size)*6 + block_size*6)
+      svg.set_height((square_size + block_size)*6 + block_size*6)
+
+      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"   => "none",
+            "stroke" => fill,
+            "style"  => {
+              "opacity" => opacity,
+              "stroke-width" => "#{block_size}px"
+            }
+          }
+
+          svg.rect(x*square_size + x*block_size*2 + block_size/2,
+                    y*square_size + y*block_size*2 + block_size/2,
+                    square_size, square_size, styles)
+
+          val     = hex_val(39-i, 1)
+          opacity = opacity(val)
+          fill    = fill_color(val)
+
+          styles = {
+            "fill"   => "none",
+            "stroke" => fill,
+            "style"  => {
+              "opacity" => opacity,
+              "stroke-width" => "#{block_size}px"
+            }
+          }
+
+          svg.rect(x*square_size + x*block_size*2 + block_size/2 + block_size*2,
+                    y*square_size + y*block_size*2 + block_size/2 + block_size*2,
+                    block_size * 3, block_size * 3, styles)
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/pattern/octagon_pattern.rb

@@ -0,0 +1,35 @@
+module GeoPattern
+  class OctagonPattern < BasePattern
+    def render_to_svg
+      square_size = map(hex_val(0, 1), 0, 15, 10, 60)
+      tile        = build_octogon_shape(square_size)
+
+      svg.set_width(square_size * 6)
+      svg.set_height(square_size * 6)
+
+      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.polyline(tile, {
+            "fill"           => fill,
+            "fill-opacity"   => opacity,
+            "stroke"         => STROKE_COLOR,
+            "stroke-opacity" => STROKE_OPACITY,
+            "transform"      => "translate(#{x*square_size}, #{y*square_size})"
+          })
+          i += 1
+        end
+      end
+    end
+
+    def build_octogon_shape(square_size)
+      s = square_size
+      c = s * 0.33
+      "#{c},0,#{s-c},0,#{s},#{c},#{s},#{s-c},#{s-c},#{s},#{c},#{s},0,#{s-c},0,#{c},#{c},0"
+    end
+  end
+end

data/lib/geo_pattern/pattern/overlapping_circles_pattern.rb

@@ -0,0 +1,46 @@
+module GeoPattern
+  class OverlappingCirclesPattern < BasePattern
+    def render_to_svg
+      scale    = hex_val(0, 1)
+      diameter = map(scale, 0, 15, 25, 200)
+      radius   = diameter/2;
+
+      svg.set_width(radius * 6)
+      svg.set_height(radius * 6)
+
+      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,
+            "style" => {
+              "opacity" => opacity
+            }
+          }
+
+          svg.circle(x*radius, y*radius, radius, styles)
+
+          # Add an extra one at top-right, for tiling.
+          if (x == 0)
+            svg.circle(6*radius, y*radius, radius, styles)
+          end
+
+          # Add an extra row at the end that matches the first row, for tiling.
+          if (y == 0)
+            svg.circle(x*radius, 6*radius, radius, styles)
+          end
+
+          # Add an extra one at bottom-right, for tiling.
+          if (x == 0 and y == 0)
+            svg.circle(6*radius, 6*radius, radius, styles)
+          end
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/pattern/overlapping_rings_pattern.rb

@@ -0,0 +1,46 @@
+module GeoPattern
+  class OverlappingRingsPattern < BasePattern
+    def render_to_svg
+      scale        = hex_val(0, 1)
+      ring_size    = map(scale, 0, 15, 10, 60)
+      stroke_width = ring_size / 4
+
+      svg.set_width(ring_size * 6)
+      svg.set_height(ring_size * 6)
+
+      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"   => "none",
+            "stroke" => fill,
+            "style"  => {
+              "opacity" => opacity,
+              "stroke-width" => "#{stroke_width}px"
+            }
+          }
+
+          svg.circle(x*ring_size, y*ring_size, ring_size - stroke_width/2, styles)
+
+          # Add an extra one at top-right, for tiling.
+          if (x == 0)
+            svg.circle(6*ring_size, y*ring_size, ring_size - stroke_width/2, styles)
+          end
+
+          if (y == 0)
+            svg.circle(x*ring_size, 6*ring_size, ring_size - stroke_width/2, styles)
+          end
+
+          if (x == 0 and y == 0)
+            svg.circle(6*ring_size, 6*ring_size, ring_size - stroke_width/2, styles)
+          end
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/pattern/pattern_helpers.rb

@@ -0,0 +1,19 @@
+Dir[File.join(File.dirname(__FILE__), '**', '*.rb')].each { |file| require file }
+
+module GeoPattern
+  module PatternHelpers
+    def self.hex_val(hash, index, length)
+      hash[index, length || 1].to_i(16)
+    end
+
+    # Ruby implementation of Processing's map function
+    # http://processing.org/reference/map_.html
+    def self.map(value, v_min, v_max, d_min, d_max) # v for value, d for desired
+      v_value = value.to_f # so it returns float
+
+      v_range = v_max - v_min
+      d_range = d_max - d_min
+      (v_value - v_min) * d_range / v_range + d_min
+    end
+  end
+end

data/lib/geo_pattern/pattern/plaid_pattern.rb

@@ -0,0 +1,49 @@
+module GeoPattern
+  class PlaidPattern < BasePattern
+    def render_to_svg
+      height = 0
+      width  = 0
+
+      # horizontal stripes
+      i = 0
+      18.times do
+        space   = hex_val(i, 1)
+        height += space + 5
+
+        val           = hex_val(i+1, 1)
+        opacity       = opacity(val)
+        fill          = fill_color(val)
+        stripe_height = val + 5
+
+        svg.rect(0, height, "100%", stripe_height, {
+              "opacity"   => opacity,
+              "fill"      => fill
+        })
+        height += stripe_height
+        i += 2
+      end
+
+      # vertical stripes
+      i = 0
+      18.times do
+        space  = hex_val(i, 1)
+        width += space + 5
+
+        val          = hex_val(i+1, 1)
+        opacity      = opacity(val)
+        fill         = fill_color(val)
+        stripe_width = val + 5
+
+        svg.rect(width, 0, stripe_width, "100%", {
+              "opacity"   => opacity,
+              "fill"      => fill
+        })
+        width += stripe_width
+        i += 2
+      end
+
+      svg.set_width(width)
+      svg.set_height(height)
+    end
+  end
+end

data/lib/geo_pattern/pattern/plus_sign_pattern.rb

@@ -0,0 +1,53 @@
+module GeoPattern
+  class PlusSignPattern < BasePattern
+    def render_to_svg
+      square_size = map(hex_val(0, 1), 0, 15, 10, 25)
+      plus_size   = square_size * 3
+      plus_shape  = build_plus_shape(square_size)
+
+      svg.set_width(square_size * 12)
+      svg.set_height(square_size * 12)
+
+      i = 0
+      for y in 0..5
+        for x in 0..5
+          val     = hex_val(i, 1)
+          opacity = opacity(val)
+          fill    = fill_color(val)
+          dx      = (y % 2 == 0) ? 0 : 1
+
+          styles = {
+            "fill"           => fill,
+            "stroke"         => STROKE_COLOR,
+            "stroke-opacity" => STROKE_OPACITY,
+            "style"          => {
+              "fill-opacity" => opacity
+            }
+          }
+
+          svg.group(plus_shape, styles.merge({
+            "transform" => "translate(#{x*plus_size - x*square_size + dx*square_size - square_size},#{y*plus_size - y*square_size - plus_size/2})"}))
+
+          # Add an extra column on the right for tiling.
+          if (x == 0)
+            svg.group(plus_shape, styles.merge({
+              "transform" => "translate(#{4*plus_size - x*square_size + dx*square_size - square_size},#{y*plus_size - y*square_size - plus_size/2})"}))
+          end
+
+          # Add an extra row on the bottom that matches the first row, for tiling.
+          if (y == 0)
+            svg.group(plus_shape, styles.merge({
+              "transform" => "translate(#{x*plus_size - x*square_size + dx*square_size - square_size},#{4*plus_size - y*square_size - plus_size/2})"}))
+          end
+
+          # Add an extra one at top-right and bottom-right, for tiling.
+          if (x == 0 && y == 0)
+            svg.group(plus_shape, styles.merge({
+              "transform" => "translate(#{4*plus_size - x*square_size + dx*square_size - square_size},#{4*plus_size - y*square_size - plus_size/2})"}))
+          end
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/pattern/sine_wave_pattern.rb

@@ -0,0 +1,36 @@
+module GeoPattern
+  class SineWavePattern < BasePattern
+    def render_to_svg
+      period     = map(hex_val(0, 1), 0, 15, 100, 400).floor
+      amplitude  = map(hex_val(1, 1), 0, 15, 30, 100).floor
+      wave_width = map(hex_val(2, 1), 0, 15, 3, 30).floor
+
+      svg.set_width(period)
+      svg.set_height(wave_width * 36)
+
+      for i in 0..35
+        val      = hex_val(i, 1)
+        opacity  = opacity(val)
+        fill     = fill_color(val)
+        x_offset = period / 4 * 0.7
+
+        styles = {
+            "fill"      => "none",
+            "stroke"    => fill,
+            "style"     => {
+              "opacity"      => opacity,
+              "stroke-width" => "#{wave_width}px"
+            }
+        }
+
+        str = "M0 "+amplitude.to_s+
+              " C "+x_offset.to_s+" 0, "+(period/2 - x_offset).to_s+" 0, "+(period/2).to_s+" "+amplitude.to_s+
+              " S "+(period-x_offset).to_s+" "+(amplitude*2).to_s+", "+period.to_s+" "+amplitude.to_s+
+              " S "+(period*1.5-x_offset).to_s+" 0, "+(period*1.5).to_s+", "+amplitude.to_s;
+
+        svg.path(str, styles.merge({"transform" => "translate(-#{period/4}, #{wave_width*i-amplitude*1.5})"}))
+        svg.path(str, styles.merge({"transform" => "translate(-#{period/4}, #{wave_width*i-amplitude*1.5 + wave_width*36})"}))
+      end
+    end
+  end
+end

data/lib/geo_pattern/pattern/square_pattern.rb

@@ -0,0 +1,27 @@
+module GeoPattern
+  class SquarePattern < BasePattern
+    def render_to_svg
+      square_size = map(hex_val(0, 1), 0, 15, 10, 60)
+
+      svg.set_width(square_size * 6)
+      svg.set_height(square_size * 6)
+
+      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.rect(x*square_size, y*square_size, square_size, square_size, {
+            "fill"           => fill,
+            "fill-opacity"   => opacity,
+            "stroke"         => STROKE_COLOR,
+            "stroke-opacity" => STROKE_OPACITY
+          })
+          i += 1
+        end
+      end
+    end
+  end
+end