pixelart 1.2.2 → 1.3.1

data/lib/pixelart/sample.rb

@@ -0,0 +1,120 @@
+module Pixelart
+
+  class Image
+
+def self.calc_sample_steps( width, new_width,
+                            center: true,
+                            debug: false )
+  ## todo/fix: assert new_width is smaller than width
+  if debug
+    puts
+    puts "==> from: #{width}px  to: #{new_width}px"
+  end
+
+  indexes = []
+
+  base_step = width / new_width    ## pixels per pixel
+
+  err_step = (width % new_width) * 2   ## multiply by 2
+  denominator = new_width * 2   # denominator (in de - nenner  e.g. 1/nenner 4/nenner)
+
+  overflow = err_step*new_width/denominator  ## todo/check - assert that div is always WITHOUT remainder!!!!!
+
+  if debug
+    puts
+    puts "base_step (pixels per pixel):"
+    puts "  #{base_step}     -  #{base_step} * #{new_width}px = #{base_step*new_width}px"
+    puts "err_step  (in 1/#{width}*2):"
+    puts "  #{err_step} / #{denominator}      - #{err_step*new_width} / #{denominator} = +#{err_step*new_width/denominator}px overflow"
+    puts
+  end
+
+  # initial pixel offset
+  index = 0
+  err   = err_step/2   ##  note: start off with +err_step/2 to add overflow pixel in the "middle"
+
+
+  index +=  if center.is_a?( Integer )
+              center
+            elsif center
+              base_step/2
+            else
+               0   #  use 0px offset
+            end
+
+
+  new_width.times do |i|
+    if err >= denominator ## overflow
+      puts "    -- overflow #{err}/#{denominator} - add +1 pixel offset to #{i}"  if debug
+      index += 1
+      err   -= denominator
+    end
+
+    puts "  #{i} => #{index}  -- #{err} / #{denominator}"  if debug
+
+
+    indexes[i] = index
+
+    index += base_step
+    err   += err_step
+  end
+
+  indexes
+end
+
+
+
+    ## todo/check: rename to sample to resample or downsample - why? why not?
+    def sample( steps_x, steps_y=steps_x,
+                top_x: 0, top_y: 0 )
+      width   = steps_x.size
+      height  = steps_y.size
+      puts "    downsampling from #{self.width}x#{self.height} to #{width}x#{height}..."
+
+      dest = Image.new( width, height )
+
+      steps_x.each_with_index do |step_x, x|
+        steps_y.each_with_index do |step_y, y|
+           pixel = self[top_x+step_x, top_y+step_y]
+
+           dest[x,y] =  pixel
+        end
+      end
+
+      dest
+    end
+    alias_method :pixelate, :sample
+
+
+def sample_debug( steps_x, steps_y=steps_x,
+              color:  Color.parse( '#ffff00' ),
+              top_x: 0,
+              top_y: 0)  ## add a yellow pixel
+
+   ## todo/fix:  get a clone of the image (DO NOT modify in place)
+
+    img = self
+
+  steps_x.each_with_index do |step_x, x|
+    steps_y.each_with_index do |step_y, y|
+        base_x = top_x+step_x
+        base_y = top_y+step_y
+
+        img[base_x,base_y] = color
+
+       ## add more colors
+       img[base_x+1,base_y] = color
+       img[base_x+2,base_y] = color
+
+       img[base_x,base_y+1] = color
+       img[base_x,base_y+2] = color
+      end
+  end
+
+  self
+end
+alias_method :pixelate_debug, :sample_debug
+
+  end  # class Image
+end   # module Pixelart
+

data/lib/pixelart/silhouette.rb

@@ -1,35 +1,35 @@
-module Pixelart
-
-
-## todo/check:
-##   use a different name for silhouette
-##    - why not  - outline ???
-##           or  - shadow  ???
-##           or  - profile ???
-##           or  - figure  ???
-##           or  - shape   ???
-##           or  - form    ???
-
-class Image
-  def silhouette( color='#000000' )
-    color = Color.parse( color )
-
-    img = Image.new( @img.width, @img.height )
-
-    @img.width.times do |x|
-      @img.height.times do |y|
-        pixel = @img[x,y]
-
-        img[x,y] = if pixel == Color::TRANSPARENT  # transparent (0)
-                       Color::TRANSPARENT
-                   else
-                       color
-                   end
-    end
-  end
-  img
-end
-
-end  # class Image
-
-end # module Pixelart
+module Pixelart
+
+
+## todo/check:
+##   use a different name for silhouette
+##    - why not  - outline ???
+##           or  - shadow  ???
+##           or  - profile ???
+##           or  - figure  ???
+##           or  - shape   ???
+##           or  - form    ???
+
+class Image
+  def silhouette( color='#000000' )
+    color = Color.parse( color )
+
+    img = Image.new( @img.width, @img.height )
+
+    @img.width.times do |x|
+      @img.height.times do |y|
+        pixel = @img[x,y]
+
+        img[x,y] = if pixel == Color::TRANSPARENT  # transparent (0)
+                       Color::TRANSPARENT
+                   else
+                       color
+                   end
+    end
+  end
+  img
+end
+
+end  # class Image
+
+end # module Pixelart

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
+