pixelart 1.3.0 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f203be5e0f2e2a06f88711fd51da837fb71212e58c0bc9aef80358f661f10f58
-  data.tar.gz: f1377fcab0ec03d91ca692ed8d6e2222bacf5aedc5e477121c4cf1950968ad22
+  metadata.gz: 0724e3e1f83da6ef84325d79706a2f59d773eb31478f1e4d797ff582dad64a4a
+  data.tar.gz: 7d75ebe3aef0abb3e3d142bf787995bbcdf797416912a387601110a3547d08fe
 SHA512:
-  metadata.gz: b3c11e63d1764934b71a62410c23e14af07b42da9ce046a5853b92d493809abd3bede1ef3b40c025e61fd28d9efcb77f87bc31a9997def982dd65e67b62da0a0
-  data.tar.gz: 78f8de9b81fa1ed6c6a77a5ea3bc6414aef36837314f5a2a073c1ab4683b31899c5bcdfe3be85ad7e3c5159f3ee708d9f231e97799f2262378f5b7b49998119a
+  metadata.gz: 6afe87fa92ec1de03bad71cd5f2ba298f78287b77f514a6c74cae6747c1e1d62790d722c07fb0a5d049dcf9966d4fa0a473688e71c717de534420f4746b711f2
+  data.tar.gz: 0b1a7cf13cdffa7410a6c0246f894d3ca5f1e3b1347fd90b9f7cbe9ed3cff4b4fc87c6704d80854b5337aa5f17e24631c28bc8188e4c6f86422e862d22949d43

data/Manifest.txt

@@ -6,14 +6,13 @@ lib/pixelart.rb
 lib/pixelart/base.rb
 lib/pixelart/blur.rb
 lib/pixelart/circle.rb
-lib/pixelart/color.rb
 lib/pixelart/composite.rb
-lib/pixelart/gradient.rb
+lib/pixelart/generator.rb
 lib/pixelart/image.rb
 lib/pixelart/led.rb
 lib/pixelart/misc.rb
-lib/pixelart/palette.rb
 lib/pixelart/pixelator.rb
+lib/pixelart/sample.rb
 lib/pixelart/silhouette.rb
 lib/pixelart/sketch.rb
 lib/pixelart/spots.rb

data/README.md

@@ -288,3 +288,9 @@ Just install the gem:
 
 The scripts are dedicated to the public domain.
 Use it as you please with no restrictions whatsoever.
+
+
+
+## Questions? Comments?
+
+Post them on the [D.I.Y. Punk (Pixel) Art reddit](https://old.reddit.com/r/DIYPunkArt). Thanks.

data/Rakefile

@@ -18,6 +18,7 @@ Hoe.spec 'pixelart' do
   self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
+    ['pixelart-colors'],
     ['chunky_png'],
     ['mini_magick'],
     ['csvreader'],

data/lib/pixelart/base.rb

@@ -1,3 +1,9 @@
+###
+#   base module
+require 'pixelart/colors'
+
+
+
 ###############
 #  3rd party
 require 'chunky_png'
@@ -11,32 +17,24 @@ require 'mini_magick'
 require 'csvreader'
 
 
-## stdlib
-require 'pp'
-require 'time'
-require 'date'
-require 'fileutils'
-
-require 'json'
-require 'yaml'
-
-
-
 
 ## 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/composite'
 
+require 'pixelart/sample'   ## (down)sample / pixelate
+
 
 require 'pixelart/pixelator'
 
 require 'pixelart/misc'   ## misc helpers
 require 'pixelart/stripes'
 
+
+require 'pixelart/generator'   ## generate images from text via spritesheets
+
+
 #########################
 # (special) effects / filters / etc
 require 'pixelart/circle'
@@ -67,21 +65,4 @@ require 'pixelart/blur'
 
 
 
-
-
-##########
-#  add some spelling convenience variants
-PixelArt = Pixelart
-
-module Pixelart
-  Palette256 = Palette8Bit = Palette8bit
-
-  Palette256Image = Palette8BitImage = Palette8bitImage =
-  ImagePalette256 = ImagePalette8Bit = ImagePalette8bit
-
-  CompositeImage = ImageComposite
-end
-
-
-
 puts Pixelart.banner    # say hello

data/lib/pixelart/generator.rb

@@ -0,0 +1,202 @@
+####
+#  "simple" generator (no different sizes, genders, etc.)
+#     uses built-in spritesheet for (archetypes &) attributes
+
+
+module Pixelart
+
+  class Metadata
+    class Sprite
+      attr_reader :id, :name, :type, :more_names
+
+      def initialize( id:,
+                      name:,
+                      type:,
+                      more_names: [] )
+         @id         = id      # zero-based index eg. 0,1,2,3, etc.
+         @name       = name
+         @type       = type
+         @more_names = more_names
+      end
+   end  # class Metadata::Sprite
+  end # class Metadata
+
+
+
+
+  class Generator
+
+ ######
+ # static helpers  - (turn into "true" static self.class methods - why? why not?)
+ #
+ def self.normalize_key( str )
+   ## add & e.g. B&W
+   ## add ' e.g. McDonald's Red
+    str.downcase.gsub(/[ ()&°'_-]/, '').strip
+ end
+
+ def self.normalize_name( str )
+   ## normalize spaces in more names
+   str.strip.gsub( /[ ]{2,}/, ' ' )
+ end
+
+ def normalize_key( str )     self.class.normalize_key( str ); end
+ def normalize_name( str )    self.class.normalize_name( str ); end
+
+
+
+ def build_attributes_by_name( recs )
+    h = {}
+    recs.each_with_index do |rec|
+      names = [rec.name] + rec.more_names
+
+      names.each do |name|
+        key = normalize_key( name )
+
+        if h[ key ]
+          puts "!!! ERROR - attribute name is not unique:"
+          pp rec
+          puts "duplicate:"
+          pp h[key]
+          exit 1
+        end
+        h[ key ] = rec
+      end
+   end
+    ## pp h
+    h
+ end
+
+
+ def build_recs( recs )   ## build and normalize (meta data) records
+    ## sort by id
+    recs = recs.sort do |l,r|
+                       l['id'].to_i( 10 ) <=> r['id'].to_i( 10 )   # use base10 (decimal)
+                     end
+
+    ## assert all recs are in order by id (0 to size)
+    recs.each_with_index do |rec, exp_id|
+       id = rec['id'].to_i(10)
+       if id != exp_id
+          puts "!! ERROR -  meta data record ids out-of-order - expected id #{exp_id}; got #{id}"
+          exit 1
+       end
+    end
+
+    ## convert to "wrapped / immutable" kind-of struct
+    recs = recs.map do |rec|
+             id         = rec['id'].to_i( 10 )
+             name       = normalize_name( rec['name'] )
+             type       = rec['type']
+
+             more_names = (rec['more_names'] || '').split( '|' )
+             more_names = more_names.map {|str| normalize_name( str ) }
+
+             Metadata::Sprite.new(
+               id:         id,
+               name:       name,
+               type:       type,
+               more_names: more_names )
+           end
+    recs
+ end  # method build_recs
+
+
+
+ def initialize( image_path="./spritesheet.png",
+                 meta_path="./spritesheet.csv",
+                 width: 24,
+                 height: 24 )
+    @width  = width
+    @height = height
+
+    @sheet = ImageComposite.read( image_path, width: @width, height: @height )
+    recs  = CsvHash.read( meta_path )
+
+    @recs = build_recs( recs )
+
+    ## lookup by "case/space-insensitive" name / key
+    @attributes_by_name = build_attributes_by_name( @recs )
+ end
+
+
+ def spritesheet() @sheet; end
+ alias_method  :sheet, :spritesheet
+
+
+ def records() @recs; end
+ alias_method :meta, :records
+
+
+
+
+ def find_meta( q )
+    key = normalize_key( q )  ## normalize q(uery) string/symbol
+
+    rec = @attributes_by_name[ key ]
+    if rec
+       puts " lookup >#{key}< => #{rec.id}: #{rec.name} / #{rec.type}"
+    else
+       puts "!! WARN - no lookup found for key >#{key}<"
+    end
+
+    rec
+ end
+
+ def find( q )
+    rec = find_meta( q )
+
+    ## return image if record found
+    rec ? @sheet[ rec.id ] : nil
+ end
+
+
+ def to_recs( *values )
+      recs       = []
+
+      attribute_names  = values
+
+      attribute_names.each do |attribute_name|
+        attribute = find_meta( attribute_name )
+        if attribute.nil?
+           puts "!! ERROR - attribute >#{attribute_name}< not found; sorry"
+           exit 1
+        end
+        recs << attribute
+      end
+
+      recs
+ end
+
+
+
+ def generate_image( *values, background: nil, before: nil )
+   ## note: generate_image NO longer supports
+   ##             - generate by integer number (indexes), sorry
+
+    recs = to_recs( *values )
+
+    ## note: first construct/generate image on transparent background
+    ##          add background if present as LAST step
+    img = Image.new( @width, @height )
+
+    recs.each do |rec|
+      ## note: before call(back) MUST change image INPLACE!!!!
+      before.call( img, rec )   if before
+      img.compose!( @sheet[ rec.id ] )
+    end
+
+    if background    ## for now assume background is (simply) color
+      img2 = Image.new( @width, @height )
+      img2.compose!( Image.new( @width, @height, background ) )
+      img2.compose!( img )
+      img = img2
+    end
+
+    img
+ end
+ alias_method :generate, :generate_image
+
+ end # class Generator
+
+end # module Pixelart

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/version.rb

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

data/lib/pixelart.rb

@@ -9,4 +9,14 @@ require 'pixelart/base'   # aka "strict(er)" version
 include Pixelart
 
 
+##########
+#  add some spelling convenience variants
+
+
+module Pixelart
+  Palette256Image = Palette8BitImage = Palette8bitImage =
+  ImagePalette256 = ImagePalette8Bit = ImagePalette8bit
+
+  CompositeImage = ImageComposite
+end
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pixelart
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.3
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-03 00:00:00.000000000 Z
+date: 2022-07-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pixelart-colors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: chunky_png
   requirement: !ruby/object:Gem::Requirement
@@ -104,14 +118,13 @@ files:
 - lib/pixelart/base.rb
 - lib/pixelart/blur.rb
 - lib/pixelart/circle.rb
-- lib/pixelart/color.rb
 - lib/pixelart/composite.rb
-- lib/pixelart/gradient.rb
+- lib/pixelart/generator.rb
 - lib/pixelart/image.rb
 - lib/pixelart/led.rb
 - lib/pixelart/misc.rb
-- lib/pixelart/palette.rb
 - lib/pixelart/pixelator.rb
+- lib/pixelart/sample.rb
 - lib/pixelart/silhouette.rb
 - lib/pixelart/sketch.rb
 - lib/pixelart/spots.rb

data/lib/pixelart/color.rb

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

@@ -1,106 +0,0 @@
-
-## 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/palette.rb

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