falu 0.0.1

data/lib/falu.rb

@@ -0,0 +1,20 @@
+require 'canfig'
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/object/json'
+require 'mini_magick'
+require 'falu/image'
+require 'falu/color'
+require 'falu/swatch'
+require 'falu/palette'
+require 'falu/image_palette'
+require 'falu/dithered_palette'
+
+module Falu
+
+  def self.colors
+    @colors ||= File.read(File.expand_path('../../colors.txt', __FILE__)).split("\n").map do |c|
+      carr = c.split("|")
+      {name: carr[0], hex: carr[1], rgb: carr[2], hsl: carr[3]}
+    end
+  end
+end

data/lib/falu/color.rb

@@ -0,0 +1,87 @@
+require 'falu/colors/hex'
+require 'falu/colors/rgb'
+require 'falu/colors/hsl'
+
+module Falu
+  class Color
+    attr_reader :color
+
+    class << self
+      def dump(color)
+        color.as_json
+      end
+
+      def load(json)
+        new(json.values.first)
+      end
+
+      def color(color)
+        if hex?(color)
+          Falu::Colors::HEX.new(color)
+        elsif rgb?(color) && !hsl?(color)
+          Falu::Colors::RGB.new(color)
+        elsif hsl?(color) && !rgb?(color)
+          Falu::Colors::HSL.new(color)
+        else
+          raise "Unable to determine color type (RGB vs HSL): #{color.to_s}"
+        end
+      end
+
+      def hex?(color)
+        color = color.join('') if color.is_a?(Array)
+        !!color.to_s.match(/#?([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})/)
+      end
+
+      def rgb?(color)
+        color = color.to_s.split(',') unless color.is_a?(Array)
+        color = color.map { |c| c.to_i }
+        return false if color.length != 3
+        return false if color.any? { |c| c > 255 || c < 0 }
+        true
+      end
+
+      def hsl?(color)
+        color = color.to_s.split(',') unless color.is_a?(Array)
+        color = color.map { |c| c.to_f }
+        return false if color.length != 3
+        return false if color[0] > 360 || color[0] < 0
+        return false if color[1..2].any? { |c| c > 100 || c < 0 }
+        true
+      end
+    end
+
+    def initialize(color)
+      @color = color.is_a?(Falu::Colors::Base) ? color : self.class.color(color)
+    end
+
+    def name
+      cname = Falu.colors.find { |c| c[:hex].downcase == hex.to_s.downcase }
+      cname.nil? ? cname : cname[:name]
+    end
+
+    def hex
+      @hex ||= color.to_hex
+    end
+
+    def rgb
+      @rgb ||= color.to_rgb
+    end
+
+    def hsl
+      @hsl ||= color.to_hsl
+    end
+
+    def <=>(other)
+      rgb.absolute <=> other.rgb.absolute
+    end
+
+    def to_s(stype=:hex)
+      send(stype).to_s
+    end
+
+    def as_json(options={})
+      # TODO options to control what type to return
+      hex.as_json
+    end
+  end
+end

data/lib/falu/colors/base.rb

@@ -0,0 +1,11 @@
+module Falu
+  module Colors
+    class Base
+      attr_reader :color
+
+      def as_json(options={})
+        to_s
+      end
+    end
+  end
+end

data/lib/falu/colors/hex.rb

@@ -0,0 +1,56 @@
+require 'falu/colors/base'
+
+module Falu
+  module Colors
+    class HEX < Base
+      def initialize(*color, rgb: nil, hsl: nil)
+        color = color[0] if color.length == 1
+        raise "Invalid HEX Color: #{color.to_s}" unless Falu::Color.hex?(color)
+        @color = color.is_a?(Array) ? color.join : color
+      end
+
+      def colors
+        @colors ||= begin
+          match = color.to_s.match(/#?([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})/)
+          match[1..3] unless match.nil?
+        end
+      end
+
+      def red
+        colors[0]
+      end
+
+      def green
+        colors[1]
+      end
+
+      def blue
+        colors[2]
+      end
+
+      def to_s
+        "##{colors.join}"
+      end
+
+      def to_a
+        colors
+      end
+
+      def to_h
+        {red: red, green: green, blue: blue}
+      end
+
+      def to_hex
+        self
+      end
+
+      def to_rgb
+        Falu::Colors::RGB.new(colors.map { |c| c.to_i(16) })
+      end
+
+      def to_hsl
+        to_rgb.to_hsl
+      end
+    end
+  end
+end

data/lib/falu/colors/hsl.rb

@@ -0,0 +1,73 @@
+require 'falu/colors/base'
+
+module Falu
+  module Colors
+    class HSL < Base
+      def initialize(*color, hex: nil, rgb: nil)
+        color = color[0] if color.length == 1
+        raise "Invalid HSL Color: #{color.to_s}" unless Falu::Color.hsl?(color)
+        @color = color.is_a?(Array) ? color.join(',') : color
+      end
+
+      def colors
+        @colors ||= color.to_s.split(',').map { |c| c.strip.to_f }
+      end
+
+      def hue
+        colors[0]
+      end
+
+      def saturation
+        colors[1]
+      end
+
+      def lightness
+        colors[2]
+      end
+
+      def to_s
+        colors.map { |c| c.round.to_s.rjust(3, '0') }.join(',')
+      end
+
+      def to_a
+        colors
+      end
+
+      def to_h
+        {hue: hue, saturation: saturation, lightness: lightness}
+      end
+
+      def hue_to_rgb(p, q, t)
+        t += 1.0 if t < 0
+        t -= 1.0 if t > 1
+        return p + (q - p) * 6.0 * t if t < (1.0/6.0)
+        return q if t < (1.0/2.0)
+        return p + (q - p) * (2.0/3.0 - t) * 6.0 if t < (2.0/3.0)
+        return p
+      end
+
+      def to_hsl
+        self
+      end
+
+      def to_rgb
+        red = grn = blu = lit = (lightness.to_f / 100.0)
+        hue, sat = (self.hue.to_f / 360.0), (saturation.to_f / 100.0)
+
+        if sat > 0
+          lum = lit < 0.5 ? lit * (1.0 + sat) : (lit + sat) - (lit * sat)
+          crm = (2.0 * lit) - lum
+          red = hue_to_rgb(crm, lum, hue + 1.0/3.0)
+          grn = hue_to_rgb(crm, lum, hue)
+          blu = hue_to_rgb(crm, lum, hue - 1.0/3.0)
+        end
+
+        Falu::Colors::RGB.new([(red * 255).round, (grn * 255).round, (blu * 255).round])
+      end
+
+      def to_hex
+        to_rgb.to_hex
+      end
+    end
+  end
+end

data/lib/falu/colors/rgb.rb

@@ -0,0 +1,101 @@
+require 'falu/colors/base'
+
+module Falu
+  module Colors
+    class RGB < Base
+      def initialize(*color)
+        color = color[0] if color.length == 1
+        raise "Invalid RGB Color: #{color.to_s}" unless Falu::Color.rgb?(color)
+        @color = color.is_a?(Array) ? color.join(',') : color
+      end
+
+      def colors
+        @colors ||= color.to_s.split(',').map { |c| c.strip.to_i }
+      end
+
+      def red
+        colors[0]
+      end
+
+      def green
+        colors[1]
+      end
+
+      def blue
+        colors[2]
+      end
+
+      def absolute
+        colors.sum
+      end
+
+      def inverse
+        @inverse ||= colors.map { |c| c / 255.0 }
+      end
+
+      def chroma
+        @chroma ||= (inverse.max - inverse.min)
+      end
+
+      def lightness
+        @lightness ||= ((inverse.max + inverse.min) / 2)
+      end
+
+      def saturation
+        @saturation ||= begin
+          if inverse.max == inverse.min
+            0
+          else
+            if lightness < 0.5
+              (chroma / (inverse.max + inverse.min))
+            else
+              (chroma / (2 - inverse.max - inverse.min))
+            end
+          end
+        end
+      end
+
+      def hue
+        @hue ||= begin
+          if inverse.max == inverse.min
+            0
+          else
+            rd,gr,bl = *inverse
+
+            if rd == inverse.max
+              hue = ((gr - bl) / chroma % 6) * 60
+            elsif gr == inverse.max
+              hue = ((bl - rd) / chroma + 2) * 60
+            elsif bl == inverse.max
+              hue = ((rd - gr) / chroma + 4) * 60
+            end
+          end
+        end
+      end
+
+      def to_s
+        colors.map { |c| c.round.to_s.rjust(3, '0') }.join(',')
+      end
+
+      def to_a
+        colors
+      end
+
+      def to_h
+        {red: red, green: green, blue: blue}
+      end
+
+      def to_rgb
+        self
+      end
+
+      def to_hex
+        Falu::Colors::HEX.new("##{colors.map { |c| c.to_s(16).rjust(2, '0') }.join}")
+      end
+
+      def to_hsl
+        Falu::Colors::HSL.new([hue, (saturation * 100), (lightness * 100)])
+      end
+    end
+  end
+end

data/lib/falu/dithered_palette.rb

@@ -0,0 +1,15 @@
+module Falu
+  class DitheredPalette < ImagePalette
+    delegate :colors, to: :configuration
+
+    def initialize(image, swatches=nil, **opts)
+      configuration.configure({colors: 20})
+      super(image, swatches, **opts)
+    end
+
+    def swatches
+      @swatches = image.scale(scale).dither(colors).sample(0, 0, size: size, sample: sample).map { |swatch| Falu::Swatch.new(*swatch) } if @swatches.empty?
+      @swatches
+    end
+  end
+end

data/lib/falu/image.rb

@@ -0,0 +1,121 @@
+require 'tempfile'
+
+# TODO currently this relies on shelling out to imagemagick via minimagick, but could be improved
+#
+# Image
+# Images::
+#   Image
+#   Original
+#   Dithered
+#   Scaled
+
+module Falu
+  class Image
+
+    delegate :width, :height, :path, :run_command, to: :image
+
+    def initialize(image)
+      @image = image
+    end
+
+    def image
+      @image = MiniMagick::Image.open(@image) unless @image.is_a?(MiniMagick::Image)
+      @image
+    end
+
+    def histogram
+      #hist = run_command("convert", "#{path}", "-format", "%c", "histogram:info:").split("\n")
+      #return hist.first
+      run_command("convert", "#{path}", "-format", "%c", "histogram:info:").split("\n").map do |clr|
+        next unless match = clr.match(/\s*(\d+):\s+\((\d+,\d+,\d+)\)\s+(#[\da-fA-F]{6})\s+(.*)/)
+        color = {
+          count: match[1].to_i,
+          rgb: match[2],
+          hex: match[3].downcase
+        }
+
+        if block_given?
+          yield(*(color.values + [color]))
+        else
+          color
+        end
+      end.compact.to_enum
+    end
+
+    def pixels(x=0, y=0, w=nil, h=nil, size: 10, sample: nil, &block)
+      w ||= width
+      h ||= height
+
+      (w / size).times.map do |ww|
+        pw = (ww * size)
+        px = x + pw
+
+        (h / size).times.map do |hh|
+          ph = (hh * size)
+          py = y + ph
+
+          pixels = run_command("convert", "#{path}[#{size}x#{size}+#{px}+#{py}]", "-depth", '8', "txt:").split("\n")
+          sample = 1 if sample == true
+          pixels = pixels.sample(sample) if sample
+
+          pixels.map do |pxl|
+            next unless match = pxl.match(/(\d+),(\d+):\s+\((\d+,\d+,\d+)\)\s+(#[\da-fA-F]{6})\s+(.*)/)
+
+            pixel = {
+              x: match[1].to_i + pw,
+              y: match[2].to_i + ph,
+              rgb: match[3],
+              hex: match[4].downcase,
+            }
+
+            if block_given?
+              yield(*(pixel.values + [pixel]))
+            else
+              pixel
+            end
+          end
+        end
+      end.flatten.to_enum
+    end
+
+    def sample(x=0, y=0, w=nil, h=nil, size: 10, sample: false, &block)
+      palette = {}
+      pixels(x, y, w, h, size: size, sample: sample) do |x,y,color|
+        palette[color] ||= 0
+        palette[color] += 1
+        yield(color) if block_given?
+      end
+      palette.to_a.to_enum
+    end
+
+    def scale(scale, filename: nil)
+      filename ||= Tempfile.new(['scaled', '.png']).path
+
+      args = [
+        'convert', path,
+        '-scale', scale,
+        filename
+      ]
+
+      run_command(*args)
+      self.class.new(filename)
+    end
+
+    def dither(colors=3, filename: nil, scale: nil, unique: false)
+      filename ||= Tempfile.new(['dithered', '.png']).path
+      scale ||= unique ? (colors * 10) : [width, height].max 
+
+      args = [
+        'convert', path,
+        '+dither',
+        '-colors', colors,
+        (unique ? '-unique-colors' : nil),
+        '-scale', scale,
+        filename
+      ].compact
+
+      run_command(*args)
+      self.class.new(filename)
+    end
+  end
+end