pixelart 1.2.3 → 1.3.0

data/lib/pixelart/sketch.rb

@@ -1,69 +1,69 @@
-module Pixelart
-
-
-
-class Image
-  def sketch( sketch=4, line: 1 )
-       # todo: line - find a better name eg. line_strenght/width or such?
-      width  = @img.width*sketch  + (@img.width+1)*line
-      height = @img.height*sketch + (@img.height+1)*line
-
-      puts "  #{width}x#{height}"
-
-      img = Image.new( width, height, Color::WHITE )
-
-      @img.width.times do |x|
-        @img.height.times do |y|
-          pixel = @img[x,y]
-
-          ## get surrounding pixels - if "out-of-bound" use transparent (0)
-          left   =  x == 0  ? Color::TRANSPARENT : @img[x-1,y]
-          top    =  y == 0  ? Color::TRANSPARENT : @img[x  ,y-1]
-
-          if pixel != left   ## draw vertical line
-              (sketch+line*2).times do |n|
-                line.times do |m|
-                  img[    x*sketch + line*x + m,
-                      n + y*sketch + line*y] = Color::BLACK
-                end
-              end
-          end
-
-          if pixel != top   ## draw horizontal line
-             (sketch+line*2).times do |n|
-               line.times do |m|
-                 img[n + x*sketch + line*x,
-                         y*sketch + line*y + m] = Color::BLACK
-                end
-             end
-          end
-
-
-          ## check special edge case for x and y to add "finish-up" right and bottom line
-          if x == @img.width-1 && pixel != Color::TRANSPARENT
-             ## draw vertical line
-             (sketch+line*2).times do |n|
-              line.times do |m|
-                img[    (x+1)*sketch + line*(x+1) + m,
-                    n + y*sketch + line*y] = Color::BLACK
-              end
-             end
-          end
-
-          if y== @img.height-1 && pixel != Color::TRANSPARENT
-            ## draw horizontal line
-            (sketch+line*2).times do |n|
-              line.times do |m|
-                img[n + x*sketch + line*x,
-                        (y+1)*sketch + line*(y+1) + m] = Color::BLACK
-              end
-            end
-          end
-        end
-      end
-
-      img
-  end
-end # class Image
-end # module Pixelart
-
+module Pixelart
+
+
+
+class Image
+  def sketch( sketch=4, line: 1 )
+       # todo: line - find a better name eg. line_strenght/width or such?
+      width  = @img.width*sketch  + (@img.width+1)*line
+      height = @img.height*sketch + (@img.height+1)*line
+
+      puts "  #{width}x#{height}"
+
+      img = Image.new( width, height, Color::WHITE )
+
+      @img.width.times do |x|
+        @img.height.times do |y|
+          pixel = @img[x,y]
+
+          ## get surrounding pixels - if "out-of-bound" use transparent (0)
+          left   =  x == 0  ? Color::TRANSPARENT : @img[x-1,y]
+          top    =  y == 0  ? Color::TRANSPARENT : @img[x  ,y-1]
+
+          if pixel != left   ## draw vertical line
+              (sketch+line*2).times do |n|
+                line.times do |m|
+                  img[    x*sketch + line*x + m,
+                      n + y*sketch + line*y] = Color::BLACK
+                end
+              end
+          end
+
+          if pixel != top   ## draw horizontal line
+             (sketch+line*2).times do |n|
+               line.times do |m|
+                 img[n + x*sketch + line*x,
+                         y*sketch + line*y + m] = Color::BLACK
+                end
+             end
+          end
+
+
+          ## check special edge case for x and y to add "finish-up" right and bottom line
+          if x == @img.width-1 && pixel != Color::TRANSPARENT
+             ## draw vertical line
+             (sketch+line*2).times do |n|
+              line.times do |m|
+                img[    (x+1)*sketch + line*(x+1) + m,
+                    n + y*sketch + line*y] = Color::BLACK
+              end
+             end
+          end
+
+          if y== @img.height-1 && pixel != Color::TRANSPARENT
+            ## draw horizontal line
+            (sketch+line*2).times do |n|
+              line.times do |m|
+                img[n + x*sketch + line*x,
+                        (y+1)*sketch + line*(y+1) + m] = Color::BLACK
+              end
+            end
+          end
+        end
+      end
+
+      img
+  end
+end # class Image
+end # module Pixelart
+

data/lib/pixelart/spots.rb

@@ -1,146 +1,146 @@
-module Pixelart
-
-class Image
-
-
-def spots_hidef( spot=10,
-                   spacing: 0,
-                   center: nil,
-                   radius: nil,
-                   background: nil,
-                   lightness: nil,
-                   odd: false )
-
-  width  = @img.width*spot+(@img.width-1)*spacing
-  height = @img.height*spot+(@img.height-1)*spacing
-
-  ## puts "  #{width}x#{height}"
-
-  ## settings in a hash for "pretty printing" in comments
-  settings = { spot: spot
-             }
-
-  settings[ :spacing ] = spacing  if spacing
-  settings[ :center ]  = center  if center
-  settings[ :radius ] = radius  if radius
-  settings[ :background ] = background  if background
-  settings[ :lightness ] = lightness  if lightness
-  settings[ :odd ] = odd   if odd
-
-
-  v = Vector.new( width, height, header: <<TXT )
-generated by pixelart/v#{VERSION} on #{Time.now.utc}
-
-spots_hidef with settings:
-    #{settings.to_json}
-TXT
-
-
-  min_center, max_center = center ? center : [0,0]
-  min_radius, max_radius = radius ? radius : [0,0]
-
-  ## note: allow passing in array of colors (will get randomally picked)
-  background_colors = if background
-                        ## check for array; otherwise assume single color passed in
-                        background_ary = background.is_a?( Array) ? background : [background]
-                        background_ary.map { |background| Color.parse( background ) }
-                      else
-                        [0]   # transparent (default - no background)
-                      end
-
-
-  min_lightness, max_lightness = lightness ? lightness : [0.0,0.0]
-
-
-   @img.width.times do |x|
-      @img.height.times do |y|
-         color = @img[ x, y ]
-
-         if color == 0   ## transparent
-           next if background.nil?
-
-           color = if background_colors.size == 1
-                     background_colors[0]
-                   else  ## pick random background color
-                     background_colors[ rand( background_colors.size ) ]
-                   end
-         end
-
-
-         if lightness
-          ## todo/check: make it work with alpha too
-          h,s,l = Color.to_hsl( color, include_alpha: false )
-
-           h = h % 360    ## make sure h(ue) is always positive!!!
-
-           ## note: rand() return between 0.0 and 1.0
-           l_diff = min_lightness +
-                     (max_lightness-min_lightness)*rand()
-
-           lnew = [1.0, l+l_diff].min
-           lnew = [0.0, lnew].max
-
-           ## print " #{l}+#{l_diff}=#{lnew} "
-
-           color = Color.from_hsl( h,
-                                   [1.0, s].min,
-                                   lnew )
-         end
-
-         ## note: return hexstring with leading #
-         # e.g.    0 becomes #00000000
-         #        and so on
-         color_hex = Color.to_hex( color, include_alpha: true )
-
-         cx_offset,
-         cy_offset = if center  ## randomize (offset off center +/-)
-                       [(spot/2 + min_center) + rand( max_center-min_center ),
-                        (spot/2 + min_center) + rand( max_center-min_center )]
-                     else
-                       [spot/2,   ## center
-                        spot/2]
-                     end
-
-         cx = x*spot + x*spacing + cx_offset
-         cy = y*spot + y*spacing + cx_offset
-
-         r = if radius ## randomize (radius +/-)
-                       min_radius + rand( max_radius-min_radius )
-                     else
-                       spot/2
-                     end
-
-         cx += spot/2   if odd && (y % 2 == 1)  ## add odd offset
-
-
-         v.circle( cx: cx, cy: cy, r: r, fill: color_hex)
-      end
-    end
-  v
-end  ## method spots_hidef
-alias_method :spots_hd, :spots_hidef
-
-
-def spots( spot=10,
-              spacing: 0,
-              center: nil,
-              radius: nil,
-              background: nil,
-              lightness: nil,
-              odd: false )
-
-  v = spots_hidef( spot,
-        spacing: spacing,
-        center: center,
-        radius: radius,
-        background: background,
-        lightness: lightness,
-        odd: odd )
-
-  v.to_image
-end
-
-
-end # class Image
-end # class Pixelart
-
+module Pixelart
+
+class Image
+
+
+def spots_hidef( spot=10,
+                   spacing: 0,
+                   center: nil,
+                   radius: nil,
+                   background: nil,
+                   lightness: nil,
+                   odd: false )
+
+  width  = @img.width*spot+(@img.width-1)*spacing
+  height = @img.height*spot+(@img.height-1)*spacing
+
+  ## puts "  #{width}x#{height}"
+
+  ## settings in a hash for "pretty printing" in comments
+  settings = { spot: spot
+             }
+
+  settings[ :spacing ] = spacing  if spacing
+  settings[ :center ]  = center  if center
+  settings[ :radius ] = radius  if radius
+  settings[ :background ] = background  if background
+  settings[ :lightness ] = lightness  if lightness
+  settings[ :odd ] = odd   if odd
+
+
+  v = Vector.new( width, height, header: <<TXT )
+generated by pixelart/v#{VERSION} on #{Time.now.utc}
+
+spots_hidef with settings:
+    #{settings.to_json}
+TXT
+
+
+  min_center, max_center = center ? center : [0,0]
+  min_radius, max_radius = radius ? radius : [0,0]
+
+  ## note: allow passing in array of colors (will get randomally picked)
+  background_colors = if background
+                        ## check for array; otherwise assume single color passed in
+                        background_ary = background.is_a?( Array) ? background : [background]
+                        background_ary.map { |background| Color.parse( background ) }
+                      else
+                        [0]   # transparent (default - no background)
+                      end
+
+
+  min_lightness, max_lightness = lightness ? lightness : [0.0,0.0]
+
+
+   @img.width.times do |x|
+      @img.height.times do |y|
+         color = @img[ x, y ]
+
+         if color == 0   ## transparent
+           next if background.nil?
+
+           color = if background_colors.size == 1
+                     background_colors[0]
+                   else  ## pick random background color
+                     background_colors[ rand( background_colors.size ) ]
+                   end
+         end
+
+
+         if lightness
+          ## todo/check: make it work with alpha too
+          h,s,l = Color.to_hsl( color, include_alpha: false )
+
+           h = h % 360    ## make sure h(ue) is always positive!!!
+
+           ## note: rand() return between 0.0 and 1.0
+           l_diff = min_lightness +
+                     (max_lightness-min_lightness)*rand()
+
+           lnew = [1.0, l+l_diff].min
+           lnew = [0.0, lnew].max
+
+           ## print " #{l}+#{l_diff}=#{lnew} "
+
+           color = Color.from_hsl( h,
+                                   [1.0, s].min,
+                                   lnew )
+         end
+
+         ## note: return hexstring with leading #
+         # e.g.    0 becomes #00000000
+         #        and so on
+         color_hex = Color.to_hex( color, include_alpha: true )
+
+         cx_offset,
+         cy_offset = if center  ## randomize (offset off center +/-)
+                       [(spot/2 + min_center) + rand( max_center-min_center ),
+                        (spot/2 + min_center) + rand( max_center-min_center )]
+                     else
+                       [spot/2,   ## center
+                        spot/2]
+                     end
+
+         cx = x*spot + x*spacing + cx_offset
+         cy = y*spot + y*spacing + cx_offset
+
+         r = if radius ## randomize (radius +/-)
+                       min_radius + rand( max_radius-min_radius )
+                     else
+                       spot/2
+                     end
+
+         cx += spot/2   if odd && (y % 2 == 1)  ## add odd offset
+
+
+         v.circle( cx: cx, cy: cy, r: r, fill: color_hex)
+      end
+    end
+  v
+end  ## method spots_hidef
+alias_method :spots_hd, :spots_hidef
+
+
+def spots( spot=10,
+              spacing: 0,
+              center: nil,
+              radius: nil,
+              background: nil,
+              lightness: nil,
+              odd: false )
+
+  v = spots_hidef( spot,
+        spacing: spacing,
+        center: center,
+        radius: radius,
+        background: background,
+        lightness: lightness,
+        odd: odd )
+
+  v.to_image
+end
+
+
+end # class Image
+end # class Pixelart
+

data/lib/pixelart/stripes.rb

@@ -0,0 +1,116 @@
+module Pixelart
+  class Image
+
+
+def self.calc_stripes( length, n: 2, debug: false )
+  stripes = []
+
+  base_step = length / n    ## pixels per pixel
+
+  err_step = (length % n) * 2   ## multiply by 2
+  denominator =  n * 2   # denominator (in de - nenner  e.g. 1/nenner 4/nenner)
+
+  overflow = err_step*n/denominator  ## todo/check - assert that div is always WITHOUT remainder!!!!!
+
+  if debug
+    puts
+    puts "base_step (pixels per stripe):"
+    puts "  #{base_step}     -  #{base_step}px * #{n} = #{base_step*n}px"
+    puts "err_step  (in 1/#{length}*2):"
+    puts "  #{err_step} / #{denominator}      - #{err_step*n} / #{denominator} = +#{err_step*n/denominator}px overflow"
+    puts
+  end
+
+  err    = 0
+  stripe = 0
+
+  n.times do |i|
+    stripe  = base_step
+    err    += err_step
+
+    if err >= denominator ## overflow
+      puts "    -- overflow #{err}/#{denominator} - add +1 pixel to stripe #{i}"  if debug
+
+      stripe += 1
+      err   -= denominator
+    end
+
+
+    puts "  #{i} => #{stripe}  -- #{err} / #{denominator}"  if debug
+
+    stripes[i] = stripe
+  end
+
+  ## note: assert calculation - sum of stripes MUST be equal length
+  sum = stripes.sum
+  puts "  sum: #{sum}"  if debug
+
+  if sum != length
+    puts "!! ERROR - stripes sum #{sum} calculation failed; expected #{length}:"
+    pp stripes
+    exit 1
+  end
+
+  stripes
+end
+
+
+def stripes_horizontal( *colors )
+  colors = colors.map { |color| Color.parse( color ) }
+
+  img = Image.new( @img.width, @img.height )
+
+  n = colors.size
+  lengths = self.class.calc_stripes( @img.height, n: n )
+
+  i      = 0
+  length = lengths[0]
+  color  = colors[0]
+
+  @img.height.times do |y|
+    if y >= length
+      i      += 1
+      length += lengths[i]
+      color   = colors[i]
+    end
+    @img.width.times do |x|
+      img[x,y] = color
+    end
+  end
+
+  img.compose!( self )  ## paste/compose image onto backgorund
+  img
+end
+alias_method :stripes, :stripes_horizontal
+
+
+
+### todo/check: move colors to (reusable) constants int Color !!!! why? why not?
+RAINBOW_RED    = Color.parse( '#E40303' )
+RAINBOW_ORANGE = Color.parse( '#FF8C00' )
+RAINBOW_YELLOW = Color.parse( '#FFED00' )
+RAINBOW_GREEN  = Color.parse( '#008026' )
+RAINBOW_BLUE   = Color.parse( '#004DFF' )
+RAINBOW_VIOLET = Color.parse( '#750787' )
+
+
+def rainbow
+  ##
+  # the most common variant consists of six stripes:
+  #   red, orange, yellow, green, blue, and violet.
+  # The flag is typically flown horizontally,
+  #  with the red stripe on top, as it would be in a natural rainbow
+  #
+  #  see https://en.wikipedia.org/wiki/Rainbow_flag_(LGBT)
+  stripes( RAINBOW_RED,
+           RAINBOW_ORANGE,
+           RAINBOW_YELLOW,
+           RAINBOW_GREEN,
+           RAINBOW_BLUE,
+           RAINBOW_VIOLET )
+end
+alias_method :pride, :rainbow
+
+
+  end  # class Image
+end   # module Pixelart

data/lib/pixelart/transparent.rb

@@ -1,60 +1,60 @@
-
-module Pixelart
-class Image
-
-  def transparent( style = :solid, fuzzy: false )
-    img = Image.new( width, height )
-
-
-    background = self[0,0]
-
-    bh,bs,bl =  Color.to_hsl( background )
-    bh = (bh % 360)  ## might might negative degree (always make positive)
-
-    height.times do |y|
-        if style == :linear
-          background = self[0,y]
-
-          bh,bs,bl =  Color.to_hsl( background )
-          bh = (bh % 360)  ## might might negative degree (always make positive)
-        end
-      width.times do |x|
-        pixel = self[x,y]
-
-        if background == 0  ## special case if background is already transparent keep going
-          img[x,y] =  pixel
-        elsif fuzzy
-          ## check for more transparents
-            ##   not s  is 0.0 to 0.99  (100%)
-            ##   and l  is 0.0 to 0.99  (100%)
-          h,s,l =  Color.to_hsl( pixel )
-          h = (h % 360)  ## might might negative degree (always make positive)
-
-          ## try some kind-of fuzzy "heuristic" match on background color
-          if ((h >= bh-5) && (h <= bh+5)) &&
-             ((s >= bs-0.07) && (s <= bs+0.07)) &&
-             ((l >= bl-0.07) && (l <= bl+0.07))
-           img[x,y] = 0  ## Color::TRANSPARENT
-
-           if h != bh || s != bs || l != bl
-              # report fuzzy background color
-              puts "  #{x}/#{y} fuzzy background #{[h,s,l]} ~= #{[bh,bs,bl]}"
-           end
-          else
-            img[x,y] =  pixel
-          end
-        else
-           if pixel == background
-            img[x,y] = 0   ## Color::TRANSPARENT
-           else
-             img[x,y] =  pixel
-           end
-        end
-      end
-    end
-    img
-  end # method transparent
-
-
-end   # class Image
-end  # module Pixelart
+
+module Pixelart
+class Image
+
+  def transparent( style = :solid, fuzzy: false )
+    img = Image.new( width, height )
+
+
+    background = self[0,0]
+
+    bh,bs,bl =  Color.to_hsl( background )
+    bh = (bh % 360)  ## might might negative degree (always make positive)
+
+    height.times do |y|
+        if style == :linear
+          background = self[0,y]
+
+          bh,bs,bl =  Color.to_hsl( background )
+          bh = (bh % 360)  ## might might negative degree (always make positive)
+        end
+      width.times do |x|
+        pixel = self[x,y]
+
+        if background == 0  ## special case if background is already transparent keep going
+          img[x,y] =  pixel
+        elsif fuzzy
+          ## check for more transparents
+            ##   not s  is 0.0 to 0.99  (100%)
+            ##   and l  is 0.0 to 0.99  (100%)
+          h,s,l =  Color.to_hsl( pixel )
+          h = (h % 360)  ## might might negative degree (always make positive)
+
+          ## try some kind-of fuzzy "heuristic" match on background color
+          if ((h >= bh-5) && (h <= bh+5)) &&
+             ((s >= bs-0.07) && (s <= bs+0.07)) &&
+             ((l >= bl-0.07) && (l <= bl+0.07))
+           img[x,y] = 0  ## Color::TRANSPARENT
+
+           if h != bh || s != bs || l != bl
+              # report fuzzy background color
+              puts "  #{x}/#{y} fuzzy background #{[h,s,l]} ~= #{[bh,bs,bl]}"
+           end
+          else
+            img[x,y] =  pixel
+          end
+        else
+           if pixel == background
+            img[x,y] = 0   ## Color::TRANSPARENT
+           else
+             img[x,y] =  pixel
+           end
+        end
+      end
+    end
+    img
+  end # method transparent
+
+
+end   # class Image
+end  # module Pixelart