pixelart 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68fa84133edc2cb7f9742514af4ef188e1e358b3ae408f6ffd282c4c815e1ae5
-  data.tar.gz: 2048f7c4e4a29cf6aff876b273c25a58bb3c2ef1c9836756847c13e59f381d18
+  metadata.gz: df39f58ffbca991ae1fbbdc2f4a3b83545074f7872dd96bf9b23ac5be7259a0d
+  data.tar.gz: 865908e9a481ef8bd74c98572dbe6c17fd2c7dde2bd5f0f8613247716be4065a
 SHA512:
-  metadata.gz: 188f2845bf2f64102829f1840eaf56ded7ba7f2f2f931e07aa951d3b29e2e82b7570cd1564a40e8afb54ecd8f040874a9e1e589a5284025836dd81adf73549d3
-  data.tar.gz: c12fa48855d076acd7516fa02d97a5da56467ce8ce78e7dc41e305681be1e1251fdb82ce638d6921726d5d6455e2849a75806730f314b93efe2146a70eb89d7c
+  metadata.gz: 65305e097f184eb6e62e6d0b392f2a9e42c2a705abbb198752fdb905681bc35ac9fb263efd663bb77d5ab3cef440127e55eeee2eb33ba841fde35338dff50d63
+  data.tar.gz: 94df6b1fced1c835ae8132922350b9d50d2fe21c29c020cc2b4595246af2d42fc0e0346bcfd6aacbc1ae45e153d58cfb5592ee90ab9c9da01b4ce07313d2b23e

data/Manifest.txt

@@ -3,4 +3,10 @@ Manifest.txt
 README.md
 Rakefile
 lib/pixelart.rb
+lib/pixelart/base.rb
+lib/pixelart/color.rb
+lib/pixelart/gradient.rb
+lib/pixelart/image.rb
+lib/pixelart/misc.rb
+lib/pixelart/palette.rb
 lib/pixelart/version.rb

data/README.md

@@ -3,8 +3,8 @@
 pixelart  - mint your own pixel art images off chain using any design (in ascii text) in any colors; incl. 2x/4x/8x zoom for bigger sizes
 
 
-* home  :: [github.com/cryptocopycats/mooncats](https://github.com/cryptocopycats/mooncats)
-* bugs  :: [github.com/cryptocopycats/mooncats/issues](https://github.com/cryptocopycats/mooncats/issues)
+* home  :: [github.com/rubycoco/pixel](https://github.com/rubycoco/pixel)
+* bugs  :: [github.com/rubycoco/pixel/issues](https://github.com/rubycoco/pixel/issues)
 * gem   :: [rubygems.org/gems/pixelart](https://rubygems.org/gems/pixelart)
 * rdoc  :: [rubydoc.info/gems/pixelart](http://rubydoc.info/gems/pixelart)
 
@@ -58,7 +58,7 @@ Note: The color 0 (transparent) is auto-magically added / defined.
 And let's mint a mooncat image:
 
 ``` ruby
-img = Pixelart::Image.parse( pixels, colors: colors )
+img = Image.parse( pixels, colors: colors )
 img.save( './i/mooncat_white.png' )
 ```
 
@@ -71,8 +71,8 @@ img3x.save( './i/mooncat_white-3x.png' )
 
 Voila!
 
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/mooncat_white.png)
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/mooncat_white-3x.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/mooncat_white.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/mooncat_white-3x.png)
 
 
 
@@ -91,7 +91,7 @@ colors = [
 And let's start minting:
 
 ``` ruby
-img = Pixelart::Image.parse( pixels, colors: colors )
+img = Image.parse( pixels, colors: colors )
 img.save( './i/mooncat_black.png' )
 
 img3x = img.zoom( 3 )
@@ -100,8 +100,8 @@ img3x.save( './i/mooncat_black-3x.png' )
 
 Voila! Black is the new White!
 
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/mooncat_black.png)
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/mooncat_black-3x.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/mooncat_black.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/mooncat_black-3x.png)
 
 
 
@@ -214,7 +214,7 @@ colors = {
 And let's mint an imperial master image:
 
 ``` ruby
-img = Pixelart::Image.parse( pixels, colors: colors )
+img = Image.parse( pixels, colors: colors )
 img.save( './i/vader.png' )
 ```
 
@@ -227,8 +227,52 @@ img5x.save( './i/vader5x.png' )
 
 Voila!
 
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/vader.png)
-![](https://github.com/cryptocopycats/mooncats/raw/master/pixelarti/vader5x.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/vader.png)
+![](https://github.com/rubycoco/pixel/raw/master/pixelart/i/vader5x.png)
+
+
+
+
+## Modular "Base" Version
+
+
+Note: By default if you require pixelart
+all classes inside the `Pixelart` module such as `Image`, `Color`, `Gradient`, `Palette8bit`, etc. get "top-leveled", that is,
+included in the top level e.g.:
+
+``` ruby
+require 'pixelart/base'
+include Pixelart
+```
+
+And now you can use all classes without
+the `Pixelart::` module scope e.g.:
+
+``` ruby
+gradient = Gradient.new( '000000', 'ffffff' )
+
+pp colors = gradient.colors( 256 )
+puts '---'
+pp colors.map { |color| Color.to_hex( color ) }
+```
+
+vs
+
+``` ruby
+gradient = Pixelart::Gradient.new( '000000', 'ffffff' )
+
+pp colors = gradient.colors( 256 )
+puts '---'
+pp colors.map { |color| Pixelart::Color.to_hex( color ) }
+```
+
+
+For a "stricter" modular version require the "base" version
+that always requires the `Pixelart::` module scope e.g.:
+
+``` ruby
+require 'pixelart/base'
+```
 
 
 

data/Rakefile

@@ -8,7 +8,7 @@ Hoe.spec 'pixelart' do
   self.summary = "pixelart - mint your own pixel art images off chain using any design (in ascii text) in any colors; incl. 2x/4x/8x zoom for bigger sizes"
   self.description = summary
 
-  self.urls    = { home: 'https://github.com/cryptocopycats/mooncats' }
+  self.urls    = { home: 'https://github.com/rubycoco/pixel' }
 
   self.author  = 'Gerald Bauer'
   self.email   = 'wwwmake@googlegroups.com'

data/lib/pixelart.rb

@@ -1,180 +1,10 @@
-## 3rd party
-require 'chunky_png'
 
-## stdlib
-require 'pp'
-require 'time'
-require 'date'
-require 'fileutils'
+## our own code (without "top-level" shortcuts e.g. "modular version")
+require 'pixelart/base'   # aka "strict(er)" version
 
 
-## our own code
-require 'pixelart/version'    # note: let version always go first
+###
+#  add convenience top-level shortcuts / aliases
+#    make Image, Color, Palette8bit, etc top-level
+include Pixelart
 
-
-
-module Pixelart
-class Image
-
-
-
-def self.read( path )   ## convenience helper
-  img_inner = ChunkyPNG::Image.from_file( path )
-  img = new( img_inner.width, img_inner.height, img_inner )
-  img
-end
-
-
-def self.parse( pixels, colors: )
-  colors = parse_colors( colors )
-  pixels = parse_pixels( pixels )
-
-  width  = pixels.reduce(1) {|width,row| row.size > width ? row.size : width }
-  height = pixels.size
-
-  img = new( width, height )
-
-  pixels.each_with_index do |row,y|
-    row.each_with_index do |color,x|
-      pixel = colors[color]
-      img[x,y] = pixel
-    end # each row
-  end # each data
-
-  img
-end
-
-
-
-def initialize( width, height, initial=ChunkyPNG::Color::TRANSPARENT )
-
-  if initial.is_a?( ChunkyPNG::Image )
-    @img = initial
-  else
-    ## todo/check - initial - use parse_color here too e.g. allow "#fff" too etc.
-    @img = ChunkyPNG::Image.new( width, height, initial )
-  end
-end
-
-
-
-def zoom( zoom=2 )
-  ## create a new zoom factor x image (2x, 3x, etc.)
-
-  img = Image.new( @img.width*zoom,
-                   @img.height*zoom )
-
-  @img.height.times do |y|
-    @img.width.times do |x|
-      pixel = @img[x,y]
-      zoom.times do |n|
-        zoom.times do |m|
-          img[n+zoom*x,m+zoom*y] = pixel
-        end
-      end
-    end # each x
-  end # each y
-
-  img
-end
-alias_method :scale, :zoom
-
-
-
-
-#####
-# (image) delegates
-##   todo/check: add some more??
-def save( path, constraints = {} )
-  # step 1: make sure outdir exits
-  outdir = File.dirname( path )
-  FileUtils.mkdir_p( outdir )  unless Dir.exist?( outdir )
-
-  # step 2: save
-  @img.save( path, constraints )
-end
-alias_method :write, :save
-
-
-def compose!( other, x=0, y=0 )
-  @img.compose!( other.image, x, y )    ## note: "unwrap" inner image ref
-end
-alias_method :paste!, :compose!
-
-
-def width()        @img.width; end
-def height()       @img.height; end
-
-def []( x, y )          @img[x,y]; end
-def []=( x, y, value )  @img[x,y]=value; end
-
-## return image ref - use a different name - why? why not?
-def image()        @img; end
-
-
-
-
-######
-# helpers
-def self.parse_pixels( pixels )
-  data = []
-  pixels.each_line do |line|
-    line = line.strip
-    if line.empty?
-      puts "!! WARN: skipping empty line in pixel art source"
-      next
-    end
-
-    ## note: allow multiple spaces or tabs to separate pixel codes
-    ##  e.g.   o o o o o o o o o o o o dg lg w w lg w lg lg dg dg w w  lg dg o o o o o o o o o o o
-    ##    or
-    data << line.split( /[ \t]+/)
- end
- data
-end
-
-
-def self.parse_colors( colors )
-  if colors.is_a?( Array )   ## convenience shortcut
-    ## note: always auto-add color 0 as pre-defined transparent - why? why not?
-    h = { '0' => ChunkyPNG::Color::TRANSPARENT }
-    colors.each_with_index do |color, i|
-       h[ (i+1).to_s ] = parse_color( color )
-    end
-    h
-  else  ## assume hash table with color map
-    ## convert into ChunkyPNG::Color
-    colors.map do |key,color|
-      ## always convert key to string why? why not?  use symbol?
-      [ key.to_s, parse_color( color ) ]
-    end.to_h
-  end
-end
-
-def self.parse_color( color )
-  if color.is_a?( Integer )  ## e.g. Assumess ChunkyPNG::Color.rgb() or such
-    color ## pass through as is 1:1
-  elsif color.is_a?(String)
-    if color.downcase == 'transparent'   ## special case for builtin colors
-      ChunkyPNG::Color::TRANSPARENT
-    else
-      ## note: return an Integer !!! (not a Color class or such!!! )
-      ChunkyPNG::Color.from_hex( color )
-    end
-  else
-    raise ArgumentError, "unknown color format; cannot parse - expected rgb hex string e.g. d3d3d3"
-  end
-end
-
-
-end # class Image
-end  # module Pixelart
-
-
-
-### add some convenience shortcuts
-PixelArt = Pixelart
-
-
-
-puts Pixelart.banner    # say hello

data/lib/pixelart/base.rb

@@ -0,0 +1,34 @@
+## 3rd party
+require 'chunky_png'
+
+## stdlib
+require 'pp'
+require 'time'
+require 'date'
+require 'fileutils'
+
+
+## our own code
+require 'pixelart/version'    # note: let version always go first
+require 'pixelart/color'
+require 'pixelart/gradient'
+require 'pixelart/palette'
+require 'pixelart/image'
+
+require 'pixelart/misc'   ## misc helpers
+
+
+##########
+#  add some spelling convenience variants
+PixelArt = Pixelart
+
+module Pixelart
+  Palette256 = Palette8Bit = Palette8bit
+
+  Palette256Image = Palette8BitImage = Palette8bitImage =
+  ImagePalette256 = ImagePalette8Bit = ImagePalette8bit
+end
+
+
+
+puts Pixelart.banner    # say hello

data/lib/pixelart/color.rb

@@ -0,0 +1,132 @@
+module Pixelart
+
+
+class Color
+  TRANSPARENT = 0            # rgba(  0,  0,  0,  0)
+  BLACK       = 0xff         # rgba(  0,  0,  0,255)
+  WHITE       = 0xffffffff   # rgba(255,255,255,255)
+
+
+
+  def self.parse( color )
+    if color.is_a?( Integer )  ## e.g. assumes ChunkyPNG::Color.rgb() or such
+      color ## pass through as is 1:1
+    elsif color.is_a?( Array )  ## assume array of hsl(a) e. g. [180, 0.86, 0.88]
+      from_hsl( *color )
+    elsif color.is_a?( String )
+      if color.downcase == 'transparent'   ## special case for builtin colors
+        TRANSPARENT
+      else
+        ## note: return an Integer !!! (not a Color class or such!!! )
+        from_hex( color )
+      end
+    else
+      raise ArgumentError, "unknown color format; cannot parse - expected rgb hex string e.g. d3d3d3"
+    end
+  end
+
+  def self.from_hex( hex )
+    ## Creates a color by converting it from a string in hex notation.
+    ##
+    ## It supports colors with (#rrggbbaa) or without (#rrggbb)
+    ##  alpha channel as well as the 3-digit short format (#rgb)
+    ## for those without. Color strings may include
+    ## the prefix "0x" or "#"".
+    ChunkyPNG::Color.from_hex( hex )
+  end
+
+  def self.from_hsl( hue, saturation, lightness, alpha=255)
+    ChunkyPNG::Color.from_hsl( hue,
+                               saturation,
+                               lightness,
+                               alpha )
+  end
+
+
+  def self.to_hex( color, include_alpha: true )
+    ChunkyPNG::Color.to_hex( color, include_alpha )
+  end
+
+  def self.to_hsl( color, include_alpha: true )
+    # Returns an array with the separate HSL components of a color.
+    ChunkyPNG::Color.to_hsl( color, include_alpha )
+  end
+
+  def self.r( color ) ChunkyPNG::Color.r( color ); end
+  def self.g( color ) ChunkyPNG::Color.g( color ); end
+  def self.b( color ) ChunkyPNG::Color.b( color ); end
+
+  def self.rgb( r, g, b ) ChunkyPNG::Color.rgb( r, g, b); end
+
+
+
+  ## known built-in color names
+  def self.build_names
+    names = {
+      '#00000000' => 'TRANSPARENT',
+      '#000000ff' => 'BLACK',
+      '#ffffffff' => 'WHITE',
+    }
+
+    ## auto-add grayscale 1 to 254
+    (1..254).each do |n|
+      hex = "#" + ('%02x' % n)*3
+      hex << "ff"  ## add alpha channel (255)
+      names[ hex ] = "8-BIT GRAYSCALE ##{n}"
+    end
+
+    names
+  end
+
+  NAMES = build_names
+
+
+
+  def self.format( color )
+    rgb = [r(color),
+           g(color),
+           b(color)]
+
+    # rgb in hex (string format)
+    #   note: do NOT include alpha channel for now - why? why not?
+    hex = "#" + rgb.map{|num| '%02x' % num }.join
+
+    hsl = to_hsl( color )
+    ## get alpha channel (transparency) for hsla
+    alpha = hsl[3]
+
+
+    buf = ''
+    buf << hex
+    buf << " / "
+    buf << "rgb("
+    buf << "%3d " % rgb[0]
+    buf << "%3d " % rgb[1]
+    buf << "%3d)"  % rgb[2]
+    buf << " - "
+    buf << "hsl("
+    buf << "%3d° " % (hsl[0] % 360)
+    buf << "%3d%% " % (hsl[1]*100+0.5).to_i
+    buf << "%3d%%)" % (hsl[2]*100+0.5).to_i
+
+    if alpha != 255
+      buf << " - α(%3d%%)" % (alpha*100/255+0.5).to_i
+    else
+      buf << "          "  ## add empty for 255 (full opacity)
+    end
+
+    ## note: add alpha channel to hex
+    alpha_hex = '%02x' % alpha
+    name = NAMES[ hex+alpha_hex ]
+    buf << " - #{name}"  if name
+
+    buf
+  end
+  class << self
+    alias_method :fmt, :format
+  end
+
+end  # class Color
+end  # module Pixelart
+
+

data/lib/pixelart/gradient.rb

@@ -0,0 +1,106 @@
+
+## inspired / helped by
+##  https://en.wikipedia.org/wiki/List_of_software_palettes#Color_gradient_palettes
+##  https://github.com/mistic100/tinygradient
+##   https://mistic100.github.io/tinygradient/
+##   https://bsouthga.dev/posts/color-gradients-with-python
+
+
+module Pixelart
+
+class Gradient
+
+  def initialize( *stops )
+    ## note:  convert stop colors to rgb triplets e.g.
+    ##         from #ffffff to [255,255,255]
+    ##              #000000 to [0,0,0]  etc.
+    @stops = stops.map do |stop|
+               stop = Color.parse( stop )
+               [Color.r(stop), Color.g(stop), Color.b(stop)]
+             end
+  end
+
+
+  def colors( steps )
+    segments = @stops.size - 1
+
+    ## note: gradient will include start (first)
+    ##   AND stop color (last) - stop color is NOT excluded for now!!
+    if segments == 1
+       start = @stops[0]
+       stop  = @stops[1]
+
+       gradient = linear_gradient( start, stop, steps,
+                                   include_stop: true )
+    else
+      steps_per_segment, mod = steps.divmod( segments )
+      raise ArgumentError, "steps (#{steps}) must be divisible by # of segments (#{segments}); expected mod of 0 but got #{mod}"   if mod != 0
+
+      gradient = []
+      segments.times do |segment|
+        start = @stops[segment]
+        stop  = @stops[segment+1]
+        include_stop =  (segment == segments-1)  ## note: only include stop if last segment!!
+
+        # print "  segment #{segment+1}/#{segments} #{steps_per_segment} color(s) - "
+        # print "  start: #{start.inspect}  "
+        # print  include_stop ? 'include' : 'exclude'
+        # print " stop:  #{stop.inspect}"
+        # print "\n"
+
+        gradient += linear_gradient( start, stop, steps_per_segment,
+                                     include_stop: include_stop )
+      end
+    end
+
+    ## convert to color (Integer)
+    gradient.map do |color|
+      Color.rgb( *color )
+    end
+ end
+
+
+
+ def interpolate( start, stop, steps, n )
+   ## note: n - expected to start with 1,2,3,etc.
+   color = []
+   3.times do |i|
+     stepize = Float(stop[i] - start[i]) / Float(steps-1)
+     value = stepize * n
+     ## convert back to Integer from Float
+     ##   add 0.5 for rounding up (starting with 0.5) - why? why not?
+     value = (value+0.5).to_i
+     value = start[i] + value
+
+     color << value
+   end
+   color
+ end
+
+
+ def linear_gradient( start, stop, steps,
+                      include_stop: true )
+
+  gradient = [start]  ## auto-add start color (first color in gradient)
+
+  if include_stop
+    1.upto( steps-2 ).each do |n|  ## sub two (-2), that is, start and stop color
+      gradient << interpolate( start, stop, steps, n )
+    end
+    # note: use original passed in stop color (should match calculated)
+    gradient << stop
+  else
+    1.upto( steps-1 ).each do |n|  ## sub one (-1), that is, start color only
+      ## note: add one (+1) to steps because stop color gets excluded (not included)!!
+      gradient << interpolate( start, stop, steps+1, n )
+    end
+  end
+
+  gradient
+end
+
+
+
+end  # class Gradient
+end  # module Pixelart
+

data/lib/pixelart/image.rb

@@ -0,0 +1,221 @@
+module Pixelart
+
+class Image
+
+def self.read( path )   ## convenience helper
+  img_inner = ChunkyPNG::Image.from_file( path )
+  img = new( img_inner.width, img_inner.height, img_inner )
+  img
+end
+
+
+def self.parse( pixels, colors: )
+  colors = parse_colors( colors )
+  pixels = parse_pixels( pixels )
+
+  width  = pixels.reduce(1) {|width,row| row.size > width ? row.size : width }
+  height = pixels.size
+
+  img = new( width, height )
+
+  pixels.each_with_index do |row,y|
+    row.each_with_index do |color,x|
+      pixel = colors[color]
+      img[x,y] = pixel
+    end # each row
+  end # each data
+
+  img
+end
+
+
+
+def initialize( width, height, initial=Color::TRANSPARENT )
+
+  if initial.is_a?( ChunkyPNG::Image )
+    @img = initial
+  else
+    ## todo/check - initial - use parse_color here too e.g. allow "#fff" too etc.
+    @img = ChunkyPNG::Image.new( width, height, initial )
+  end
+end
+
+
+
+def zoom( zoom=2 )
+  ## create a new zoom factor x image (2x, 3x, etc.)
+
+  img = Image.new( @img.width*zoom,
+                   @img.height*zoom )
+
+  @img.height.times do |y|
+    @img.width.times do |x|
+      pixel = @img[x,y]
+      zoom.times do |n|
+        zoom.times do |m|
+          img[n+zoom*x,m+zoom*y] = pixel
+        end
+      end
+    end # each x
+  end # each y
+
+  img
+end
+alias_method :scale, :zoom
+
+
+
+#######################
+## filter / effects
+
+def grayscale
+  img = @img.grayscale
+  Image.new( img.width, img.height, img )
+end
+
+## add replace_colors alias too? - why? why not?
+def change_colors( color_map )
+  color_map = _parse_color_map( color_map )
+
+  img = @img.dup  ## note: make a deep copy!!!
+  _change_colors!( img, color_map )
+
+  ## wrap into Pixelart::Image - lets you use zoom() and such
+  Image.new( img.width, img.height, img )
+end
+alias_method :recolor, :change_colors
+
+
+
+## predefined palette8bit color maps
+##     (grayscale to sepia/blue/false/etc.)
+##  - todo/check - keep "shortcut" convenience predefined map - why? why not?
+PALETTE8BIT = {
+  sepia: Palette8bit::GRAYSCALE.zip( Palette8bit::SEPIA ).to_h,
+  blue:  Palette8bit::GRAYSCALE.zip( Palette8bit::BLUE ).to_h,
+  false: Palette8bit::GRAYSCALE.zip( Palette8bit::FALSE ).to_h,
+}
+
+def change_palette8bit( palette )
+  ## step 0: mapping from grayscale to new 8bit palette (256 colors)
+  color_map = if palette.is_a?( String ) || palette.is_a?( Symbol )
+                 PALETTE8BIT[ palette.to_sym ]
+                 ## todo/fix: check for missing/undefined palette not found - why? why not?
+              else
+                 ##  make sure we have colors all in Integer not names, hex, etc.
+                 palette = _parse_colors( palette )
+                 Palette8bit::GRAYSCALE.zip( palette ).to_h
+              end
+
+  ## step 1: convert to grayscale (256 colors)
+  img = @img.grayscale
+  _change_colors!( img, color_map )
+
+  ## wrap into Pixelart::Image - lets you use zoom() and such
+  Image.new( img.width, img.height, img )
+end
+alias_method :change_palette256, :change_palette8bit
+
+
+####
+##  private helpers
+def _parse_colors( colors )
+  colors.map {|color| Color.parse( color ) }
+end
+
+def _parse_color_map( color_map )
+  color_map.map do |k,v|
+    [Color.parse(k),  Color.parse(v)]
+  end.to_h
+end
+
+def _change_colors!( img, color_map )
+  img.width.times do |x|
+    img.height.times do |y|
+      color = img[x,y]
+      new_color = color_map[color]
+      img[x,y] = new_color  if new_color
+    end
+  end
+end
+
+
+
+
+#####
+# (image) delegates
+##   todo/check: add some more??
+def save( path, constraints = {} )
+  # step 1: make sure outdir exits
+  outdir = File.dirname( path )
+  FileUtils.mkdir_p( outdir )  unless Dir.exist?( outdir )
+
+  # step 2: save
+  @img.save( path, constraints )
+end
+alias_method :write, :save
+
+
+def compose!( other, x=0, y=0 )
+  @img.compose!( other.image, x, y )    ## note: "unwrap" inner image ref
+end
+alias_method :paste!, :compose!
+
+
+def width()        @img.width; end
+def height()       @img.height; end
+
+def []( x, y )          @img[x,y]; end
+def []=( x, y, value )  @img[x,y]=value; end
+
+def pixels()       @img.pixels; end
+
+## return image ref - use a different name - why? why not?
+##   change to to_image  - why? why not?
+def image()        @img; end
+
+
+
+
+######
+# helpers
+def self.parse_pixels( pixels )
+  data = []
+  pixels.each_line do |line|
+    line = line.strip
+    if line.empty?
+      puts "!! WARN: skipping empty line in pixel art source"
+      next
+    end
+
+    ## note: allow multiple spaces or tabs to separate pixel codes
+    ##  e.g.   o o o o o o o o o o o o dg lg w w lg w lg lg dg dg w w  lg dg o o o o o o o o o o o
+    ##    or
+    data << line.split( /[ \t]+/)
+ end
+ data
+end
+
+
+def self.parse_colors( colors )
+  if colors.is_a?( Array )   ## convenience shortcut
+    ## note: always auto-add color 0 as pre-defined transparent - why? why not?
+    h = { '0' => Color::TRANSPARENT }
+    colors.each_with_index do |color, i|
+       h[ (i+1).to_s ] = Color.parse( color )
+    end
+    h
+  else  ## assume hash table with color map
+    ## convert into ChunkyPNG::Color
+    colors.map do |key,color|
+      ## always convert key to string why? why not?  use symbol?
+      [ key.to_s, Color.parse( color ) ]
+    end.to_h
+  end
+end
+
+
+
+end # class Image
+end  # module Pixelart
+

data/lib/pixelart/misc.rb

@@ -0,0 +1,37 @@
+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.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
+end # module Pixelart
+
+

data/lib/pixelart/palette.rb

@@ -0,0 +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
+

data/lib/pixelart/version.rb

@@ -3,7 +3,7 @@ module Pixelart
 
   MAJOR = 0
   MINOR = 1
-  PATCH = 1
+  PATCH = 6
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pixelart
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2021-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png
@@ -73,8 +73,14 @@ files:
 - README.md
 - Rakefile
 - lib/pixelart.rb
+- lib/pixelart/base.rb
+- lib/pixelart/color.rb
+- lib/pixelart/gradient.rb
+- lib/pixelart/image.rb
+- lib/pixelart/misc.rb
+- lib/pixelart/palette.rb
 - lib/pixelart/version.rb
-homepage: https://github.com/cryptocopycats/mooncats
+homepage: https://github.com/rubycoco/pixel
 licenses:
 - Public Domain
 metadata: {}