pixelart 1.2.2 → 1.3.1

data/lib/pixelart/misc.rb

@@ -1,66 +1,66 @@
-module Pixelart
-
-
-class ImagePalette8bit < Image  # or use Palette256 alias?
-  def initialize( colors, size: 1, spacing: nil )
-    ## todo/check: change size arg to pixel or such? better name/less confusing - why? why not?
-
-    ## todo/check: assert colors MUST have 256 colors!!!!
-
-    ## use a "smart" default if no spacing set
-    ##   0 for for (pixel) size == 1
-    ##   1 for the rest
-    spacing = size == 1 ? 0 : 1  if spacing.nil?
-
-    img = ChunkyPNG::Image.new( 32*size+(32-1)*spacing,
-                                 8*size+(8-1)*spacing )
-
-
-    colors =colors.map {|color| Color.parse( color ) }
-
-    colors.each_with_index do |color,i|
-      y,x = i.divmod( 32 )
-      if size > 1
-        size.times do |n|
-          size.times do |m|
-            img[ x*size+n+spacing*x,
-                 y*size+m+spacing*y] = color
-          end
-        end
-      else
-        img[x,y] = color
-      end
-    end
-
-    super( img.width, img.height, img )
-  end
-end # class ImagePalette8bit
-
-
-
-class ImageColorBar < Image
-  ## make a color bar
-  ##  keep auto-zoom 24x or such - why? why not?
-  def initialize( colors, size: 24 )
-    img = ChunkyPNG::Image.new( colors.size*size,
-                                size,
-                                ChunkyPNG::Color::WHITE ) # why? why not?
-
-    colors = colors.map {|color| Color.parse( color ) }
-
-    colors.each_with_index do |color,i|
-      size.times do |x|
-        size.times do |y|
-          img[x+size*i,y] = color
-        end
-      end
-    end
-
-    super( img.width, img.height, img )
-  end
-end  # class ImageColorBar
-
-
-end # module Pixelart
-
-
+module Pixelart
+
+
+class ImagePalette8bit < Image  # or use Palette256 alias?
+  def initialize( colors, size: 1, spacing: nil )
+    ## todo/check: change size arg to pixel or such? better name/less confusing - why? why not?
+
+    ## todo/check: assert colors MUST have 256 colors!!!!
+
+    ## use a "smart" default if no spacing set
+    ##   0 for for (pixel) size == 1
+    ##   1 for the rest
+    spacing = size == 1 ? 0 : 1  if spacing.nil?
+
+    img = ChunkyPNG::Image.new( 32*size+(32-1)*spacing,
+                                 8*size+(8-1)*spacing )
+
+
+    colors =colors.map {|color| Color.parse( color ) }
+
+    colors.each_with_index do |color,i|
+      y,x = i.divmod( 32 )
+      if size > 1
+        size.times do |n|
+          size.times do |m|
+            img[ x*size+n+spacing*x,
+                 y*size+m+spacing*y] = color
+          end
+        end
+      else
+        img[x,y] = color
+      end
+    end
+
+    super( img.width, img.height, img )
+  end
+end # class ImagePalette8bit
+
+
+
+class ImageColorBar < Image
+  ## make a color bar
+  ##  keep auto-zoom 24x or such - why? why not?
+  def initialize( colors, size: 24 )
+    img = ChunkyPNG::Image.new( colors.size*size,
+                                size,
+                                ChunkyPNG::Color::WHITE ) # why? why not?
+
+    colors = colors.map {|color| Color.parse( color ) }
+
+    colors.each_with_index do |color,i|
+      size.times do |x|
+        size.times do |y|
+          img[x+size*i,y] = color
+        end
+      end
+    end
+
+    super( img.width, img.height, img )
+  end
+end  # class ImageColorBar
+
+
+end # module Pixelart
+
+

data/lib/pixelart/palette.rb

@@ -1,72 +1,72 @@
-module Pixelart
-
-
-class Palette8bit     # or use Palette256 alias?
-
-
-  ## auto-add grayscale 0 to 255
-  ##  e.g. rgb(0,0,0)
-  ##       rgb(1,1,1)
-  ##       rgb(2,2,2)
-  ##       ...
-  ##       rgb(255,255,255)
-  GRAYSCALE = (0..255).map { |n| Color.rgb( n, n, n ) }
-
-
-   ## 8x32 gradient color stops
-   ##   see https://en.wikipedia.org/wiki/List_of_software_palettes#Color_gradient_palettes
-
-  SEPIA_STOPS = [
-    ['080400', '262117'],
-    ['272218', '453E2F'],
-    ['463F30', '645C48'],
-    ['655D48', '837A60'],
-
-    ['847A60', 'A29778'],
-    ['A39878', 'C1B590'],
-    ['C2B691', 'E0D2A8'],
-    ['E1D3A9', 'FEEFBF'],
-  ]
-
-  BLUE_STOPS = [
-    ['000000', '001F3E'],
-    ['002040', '003F7E'],
-    ['004080', '005FBD'],
-    ['0060BF', '007FFD'],
-
-    ['0080FF', '009FFF'],
-    ['00A0FF', '00BFFF'],
-    ['00C0FF', '00DFFF'],
-    ['00E0FF', '00FEFF'],
-  ]
-
-  FALSE_STOPS = [
-    ['FF00FF', '6400FF'],
-    ['5F00FF', '003CFF'],
-    ['0041FF', '00DCFF'],
-    ['00E1FF', '00FF82'],
-
-    ['00FF7D', '1EFF00'],
-    ['23FF00', 'BEFF00'],
-    ['C3FF00', 'FFA000'],
-    ['FF9B00', 'FF0000'],
-  ]
-
-
-  def self.build_palette( gradients )
-    colors_per_gradient, mod = 256.divmod( gradients.size )
-    raise ArgumentError, "8bit palette - 256 must be divisible by # of gradients (#{gradients.size}; expected mod of 0 but got #{mod}"   if mod != 0
-
-    colors = []
-    gradients.each do |stops|
-      colors += Gradient.new( *stops ).colors( colors_per_gradient )
-    end
-    colors
-  end
-
-  SEPIA     = build_palette( SEPIA_STOPS )
-  BLUE      = build_palette( BLUE_STOPS )
-  FALSE     = build_palette( FALSE_STOPS )
-end  # class Palette8bit
-end # module Pixelart
-
+module Pixelart
+
+
+class Palette8bit     # or use Palette256 alias?
+
+
+  ## auto-add grayscale 0 to 255
+  ##  e.g. rgb(0,0,0)
+  ##       rgb(1,1,1)
+  ##       rgb(2,2,2)
+  ##       ...
+  ##       rgb(255,255,255)
+  GRAYSCALE = (0..255).map { |n| Color.rgb( n, n, n ) }
+
+
+   ## 8x32 gradient color stops
+   ##   see https://en.wikipedia.org/wiki/List_of_software_palettes#Color_gradient_palettes
+
+  SEPIA_STOPS = [
+    ['080400', '262117'],
+    ['272218', '453E2F'],
+    ['463F30', '645C48'],
+    ['655D48', '837A60'],
+
+    ['847A60', 'A29778'],
+    ['A39878', 'C1B590'],
+    ['C2B691', 'E0D2A8'],
+    ['E1D3A9', 'FEEFBF'],
+  ]
+
+  BLUE_STOPS = [
+    ['000000', '001F3E'],
+    ['002040', '003F7E'],
+    ['004080', '005FBD'],
+    ['0060BF', '007FFD'],
+
+    ['0080FF', '009FFF'],
+    ['00A0FF', '00BFFF'],
+    ['00C0FF', '00DFFF'],
+    ['00E0FF', '00FEFF'],
+  ]
+
+  FALSE_STOPS = [
+    ['FF00FF', '6400FF'],
+    ['5F00FF', '003CFF'],
+    ['0041FF', '00DCFF'],
+    ['00E1FF', '00FF82'],
+
+    ['00FF7D', '1EFF00'],
+    ['23FF00', 'BEFF00'],
+    ['C3FF00', 'FFA000'],
+    ['FF9B00', 'FF0000'],
+  ]
+
+
+  def self.build_palette( gradients )
+    colors_per_gradient, mod = 256.divmod( gradients.size )
+    raise ArgumentError, "8bit palette - 256 must be divisible by # of gradients (#{gradients.size}; expected mod of 0 but got #{mod}"   if mod != 0
+
+    colors = []
+    gradients.each do |stops|
+      colors += Gradient.new( *stops ).colors( colors_per_gradient )
+    end
+    colors
+  end
+
+  SEPIA     = build_palette( SEPIA_STOPS )
+  BLUE      = build_palette( BLUE_STOPS )
+  FALSE     = build_palette( FALSE_STOPS )
+end  # class Palette8bit
+end # module Pixelart
+

data/lib/pixelart/pixelator.rb

@@ -1,165 +1,165 @@
-module Pixelart
-
-
-class Pixelator    # or use Minifier or such - rename - why? why not?
-
-  def initialize( img, width=24, height=24 )
-    @img    = img.is_a?( Image ) ? img.image : img  ## "unwrap" if Pixelart::Image
-    @width  = width
-    @height = height
-
-    ## calculate pixel size / density / resolution
-    ##   how many pixels per pixel?
-    @xsize, @xoverflow = img.width.divmod( width )
-    @ysize, @yoverflow = img.height.divmod( height )
-
-    puts "minify image size from (#{@img.width}x#{@img.height}) to (#{width}x#{height})"
-    puts "  pixel size (#{@xsize}x#{@ysize}) - #{@xsize*@ysize} pixel(s) per pixel"
-    puts "    overflow x: #{@xoverflow}, y: #{@yoverflow} pixel(s)"    if @xoverflow > 0 || @yoverflow > 0
-  end
-
-
-  def grid( spacing: 10 )
-    width  = @img.width  + (@width-1)*spacing
-    height = @img.height + (@height-1)*spacing
-
-    img = ChunkyPNG::Image.new( width, height, ChunkyPNG::Color::WHITE )
-
-    @img.width.times do |x|
-      xpixel = x/@xsize
-      @img.height.times do |y|
-        ypixel = y/@ysize
-
-        ## clip overflow pixels
-        xpixel = @width-1   if xpixel >= @width
-        ypixel = @height-1  if ypixel >= @height
-
-        color = @img[x,y]
-        img[x + spacing*xpixel,
-            y + spacing*ypixel] = color
-      end
-    end
-
-    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
-  end
-
-
-  # pixels by coordinates (x/y) with color statistics / usage
-  def pixels
-    @pixels ||= begin
-                  pixels = []
-                  @img.width.times do |x|
-                    xpixel = x/@xsize
-                    @img.height.times do |y|
-                      ypixel = y/@ysize
-
-                      ## skip/cut off overflow pixels
-                      next if xpixel >= @width || ypixel >= @height
-
-                      color = @img[x,y]
-                      colors = pixels[xpixel+ypixel*@width] ||= Hash.new(0)
-                      colors[ color ] += 1
-                    end
-                  end
-
-                  ## sort pixel colors by usage / count (highest first)
-                  pixels = pixels.map do |pixel|
-                                         pixel.sort do |l,r|
-                                                      r[1] <=> l[1]
-                                                    end.to_h
-                                      end
-                  pixels
-                end
-  end
-
-  def pixel(x,y)  pixels[x+y*@width]; end
-  alias_method :[], :pixel
-
-
-  def can_pixelate?( threshold: 50 )
-    # check if any pixel has NOT a color with a 50% majority?
-    count = 0
-    @width.times do |x|
-      @height.times do |y|
-        pixel = pixel( x, y )
-        sum         = pixel.values.sum
-        color_count = pixel.values[0]
-
-        threshold_count = sum / (100/threshold)
-        if color_count < threshold_count
-          count += 1
-          puts "!! #{color_count} < #{threshold_count} (#{threshold}%)"
-          ## todo/check: stor warn in a public errors or warns array - why? why not?
-          puts "!! WARN #{count} - pixel (#{x}/#{y}) - no majority (#{threshold}%) color:"
-          pp pixel
-        end
-      end
-    end
-
-    count == 0    ## return true if not warnings found
-  end
-  alias_method :pixelate?, :can_pixelate?
-
-
-  def pixelate
-    img = ChunkyPNG::Image.new( @width, @height )
-
-    @width.times do |x|
-      @height.times do |y|
-        pixel = pixel( x, y )
-        color = pixel.keys[0]
-        img[x,y] = color
-      end
-    end
-
-    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
-  end
-
-  def outline
-    ## create a two color outline (transparent and non-transparent color)
-    img = ChunkyPNG::Image.new( @width, @height )
-
-    @width.times do |x|
-      @height.times do |y|
-        pixel = pixel( x, y )
-        ## calculate pixel count for transparent and non-transparent parts
-        ##   note:
-        ##     also count all colors with alpha channel < 200 to transparent!!
-        transparent_count, color_count = pixel.reduce([0,0]) do |mem, (color,count)|
-                                          hsl = Color.to_hsl( color )
-                                          ## get alpha channel (transparency) for hsla
-                                          ##    0-255 max.
-                                          alpha = hsl[3]
-                                         if color == 0x00 || alpha < 200
-                                            mem[0] += count
-                                         else
-                                            mem[1] += count
-                                         end
-                                         mem
-                                     end
-
-        print "."
-        if transparent_count > 0 && color_count > 0
-          print "(#{x}/#{y}=>#{transparent_count}/#{color_count})"
-        end
-
-        ## todo/check:
-        ##   warn if sum_transparent == sum_color
-        ##    or within "threshold" e.g. below 55% or 58% or such - why? why not?
-        ##    or add treshold as param to outline?
-        color = if transparent_count > color_count
-                   0x0
-                else
-                   0x0000ffff  ## use blue for now
-                end
-
-        img[x,y] = color
-      end
-    end
-    print "\n"
-
-    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
-  end
-end  # class Pixelator
-end  # module Pixelart
-
+module Pixelart
+
+
+class Pixelator    # or use Minifier or such - rename - why? why not?
+
+  def initialize( img, width=24, height=24 )
+    @img    = img.is_a?( Image ) ? img.image : img  ## "unwrap" if Pixelart::Image
+    @width  = width
+    @height = height
+
+    ## calculate pixel size / density / resolution
+    ##   how many pixels per pixel?
+    @xsize, @xoverflow = img.width.divmod( width )
+    @ysize, @yoverflow = img.height.divmod( height )
+
+    puts "minify image size from (#{@img.width}x#{@img.height}) to (#{width}x#{height})"
+    puts "  pixel size (#{@xsize}x#{@ysize}) - #{@xsize*@ysize} pixel(s) per pixel"
+    puts "    overflow x: #{@xoverflow}, y: #{@yoverflow} pixel(s)"    if @xoverflow > 0 || @yoverflow > 0
+  end
+
+
+  def grid( spacing: 10 )
+    width  = @img.width  + (@width-1)*spacing
+    height = @img.height + (@height-1)*spacing
+
+    img = ChunkyPNG::Image.new( width, height, ChunkyPNG::Color::WHITE )
+
+    @img.width.times do |x|
+      xpixel = x/@xsize
+      @img.height.times do |y|
+        ypixel = y/@ysize
+
+        ## clip overflow pixels
+        xpixel = @width-1   if xpixel >= @width
+        ypixel = @height-1  if ypixel >= @height
+
+        color = @img[x,y]
+        img[x + spacing*xpixel,
+            y + spacing*ypixel] = color
+      end
+    end
+
+    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
+  end
+
+
+  # pixels by coordinates (x/y) with color statistics / usage
+  def pixels
+    @pixels ||= begin
+                  pixels = []
+                  @img.width.times do |x|
+                    xpixel = x/@xsize
+                    @img.height.times do |y|
+                      ypixel = y/@ysize
+
+                      ## skip/cut off overflow pixels
+                      next if xpixel >= @width || ypixel >= @height
+
+                      color = @img[x,y]
+                      colors = pixels[xpixel+ypixel*@width] ||= Hash.new(0)
+                      colors[ color ] += 1
+                    end
+                  end
+
+                  ## sort pixel colors by usage / count (highest first)
+                  pixels = pixels.map do |pixel|
+                                         pixel.sort do |l,r|
+                                                      r[1] <=> l[1]
+                                                    end.to_h
+                                      end
+                  pixels
+                end
+  end
+
+  def pixel(x,y)  pixels[x+y*@width]; end
+  alias_method :[], :pixel
+
+
+  def can_pixelate?( threshold: 50 )
+    # check if any pixel has NOT a color with a 50% majority?
+    count = 0
+    @width.times do |x|
+      @height.times do |y|
+        pixel = pixel( x, y )
+        sum         = pixel.values.sum
+        color_count = pixel.values[0]
+
+        threshold_count = sum / (100/threshold)
+        if color_count < threshold_count
+          count += 1
+          puts "!! #{color_count} < #{threshold_count} (#{threshold}%)"
+          ## todo/check: stor warn in a public errors or warns array - why? why not?
+          puts "!! WARN #{count} - pixel (#{x}/#{y}) - no majority (#{threshold}%) color:"
+          pp pixel
+        end
+      end
+    end
+
+    count == 0    ## return true if not warnings found
+  end
+  alias_method :pixelate?, :can_pixelate?
+
+
+  def pixelate
+    img = ChunkyPNG::Image.new( @width, @height )
+
+    @width.times do |x|
+      @height.times do |y|
+        pixel = pixel( x, y )
+        color = pixel.keys[0]
+        img[x,y] = color
+      end
+    end
+
+    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
+  end
+
+  def outline
+    ## create a two color outline (transparent and non-transparent color)
+    img = ChunkyPNG::Image.new( @width, @height )
+
+    @width.times do |x|
+      @height.times do |y|
+        pixel = pixel( x, y )
+        ## calculate pixel count for transparent and non-transparent parts
+        ##   note:
+        ##     also count all colors with alpha channel < 200 to transparent!!
+        transparent_count, color_count = pixel.reduce([0,0]) do |mem, (color,count)|
+                                          hsl = Color.to_hsl( color )
+                                          ## get alpha channel (transparency) for hsla
+                                          ##    0-255 max.
+                                          alpha = hsl[3]
+                                         if color == 0x00 || alpha < 200
+                                            mem[0] += count
+                                         else
+                                            mem[1] += count
+                                         end
+                                         mem
+                                     end
+
+        print "."
+        if transparent_count > 0 && color_count > 0
+          print "(#{x}/#{y}=>#{transparent_count}/#{color_count})"
+        end
+
+        ## todo/check:
+        ##   warn if sum_transparent == sum_color
+        ##    or within "threshold" e.g. below 55% or 58% or such - why? why not?
+        ##    or add treshold as param to outline?
+        color = if transparent_count > color_count
+                   0x0
+                else
+                   0x0000ffff  ## use blue for now
+                end
+
+        img[x,y] = color
+      end
+    end
+    print "\n"
+
+    Image.new( img.width, img.height, img )  ## wrap in Pixelart::Image - why? why not?
+  end
+end  # class Pixelator
+end  # module Pixelart
+