Paletti 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b4eb61346249f243156a63eb8a889be54807e27
+  data.tar.gz: fa3dce231ec9e9503f4245849bc65808d5fb0fda
+SHA512:
+  metadata.gz: ff5b42b80f6fbb52ae401ff39a6ebad599725aa470bc6bc56ebedae3578a3cea7b24add8e09909a53a722a0cbd2299f6ce67cbd5cbd69638ef58e5fc49c61eaa
+  data.tar.gz: 51948fca59a4540d08b3a31fb37606de4286fed95bf9d0152a01d4aae04a75011d129893ef0dd84ef186d531ca24bdeeccdace130ade9d723314211abc7d063e

data/bin/pal

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'paletti'
+require 'optparse'
+
+begin
+  option_parser = OptionParser.new do |opts|
+    executable_name = File.basename($PROGRAM_NAME)
+    opts.banner = "
+      Paletti takes an image and finds its background color as well as the best primary, secondary, and detail text colors that are readable on the background color.
+
+      Usage: #{executable_name} image_path
+    "
+  end
+end
+
+if ARGV.empty?
+  puts "Error: you must specifiy a path (local or URL) to an image."
+  puts option_parser.help
+else
+  img = Paletti.new(ARGV[0])
+  bg_pixel = img.background_pixel
+  text_pixels = img.text_pixels
+  puts "Background color:\nR: #{bg_pixel.to_norm_rgba[0].to_i} G: #{bg_pixel.to_norm_rgba[1].to_i} B: #{bg_pixel.to_norm_rgba[2].to_i}\n\n"
+  puts "Text colors:\n"
+  text_pixels.each do |pixel|
+    puts "R: #{pixel.to_norm_rgba[0].to_i} G: #{pixel.to_norm_rgba[1].to_i} B: #{pixel.to_norm_rgba[2].to_i}\n"
+  end
+end

data/lib/paletti.rb

@@ -0,0 +1,71 @@
+require 'rmagick'
+require_relative 'paletti/pixel'
+
+class Paletti
+
+  def initialize(path_to_image)
+    # Load the image at the given path
+    @image = Magick::Image.read(path_to_image)[0]
+  end
+
+  def background_pixel
+    if @background_pixel
+      return @background_pixel
+    end
+
+    # Make an array of all the edge/border pixels
+    border_pixels = []
+    @image.each_pixel do |pixel, col_idx, row_idx|
+      if col_idx == 0 || row_idx == 0 || col_idx == @image.columns - 1 || row_idx == @image.rows - 1
+        border_pixels.push(pixel)
+      end
+    end
+
+    # Make a hash of the edge/border pixel frequencies and sort by frequency
+    border_pixel_counts = Hash.new(0)
+    border_pixels.each { |border_pixel| border_pixel_counts[border_pixel] += 1 }
+    sorted_border_pixels = border_pixel_counts.sort_by { |pixel, count| -count }
+    sorted_border_pixels = sorted_border_pixels.flatten.select! do |pixel|
+      pixel.class == Magick::Pixel
+    end
+
+    # Get a non black or white pixel if possible
+    pixel = sorted_border_pixels.first
+    backup_pixel = pixel.dup
+    while !pixel.nil? && pixel.is_black_or_white? && sorted_border_pixels.length > 1
+      sorted_border_pixels.delete(pixel)
+      pixel = sorted_border_pixels.find { |p| border_pixel_counts[p].to_f / border_pixel_counts[pixel].to_f > 0.05 && !p.is_black_or_white?  }
+    end
+    return @background_pixel = pixel || backup_pixel
+  end
+
+  def text_pixels
+    if @text_pixels
+      return @text_pixels
+    end
+
+    # Make an array of all the pixels and sort by frequency
+    pixels = []
+    @image.each_pixel { |pixel| pixels.push(pixel) }
+    # For speed, just use a random sample of 250,000 pixels max
+    pixels = pixels.sample(250_000) if pixels.length > 250_000
+    pixel_counts = Hash.new(0)
+    pixels.each do |pixel|
+      if pixel.to_hsla[1] < 0.15 * 255.to_f
+        pixel = Magick::Pixel.from_hsla(pixel.to_hsla[0], 0.15 * 255.to_f, pixel.to_hsla[2], pixel.to_hsla[3])
+      end
+      pixel_counts[pixel] += 1
+    end
+    sorted_pixels = pixel_counts.sort_by { |pixel, count| -count }
+    sorted_pixels = sorted_pixels.flatten.select! { |pixel| pixel.class == Magick::Pixel }
+
+    # Get the most common three colors that are distinct from each other and the background color
+    @text_pixels = []
+    while @text_pixels.length < 3
+      found = (sorted_pixels.find { |pixel| pixel.is_contrasting?(self.background_pixel) && @text_pixels.all? { |text_pixel| text_pixel.is_distinct?(pixel) } })
+      @text_pixels.push(found)
+    end
+    return @text_pixels
+  end
+
+end

data/lib/paletti/pixel.rb

@@ -0,0 +1,91 @@
+class Magick::Pixel
+
+  def to_norm_rgba
+    [self.red.to_f * NORM_FACTOR, self.green.to_f * NORM_FACTOR, self.blue.to_f * NORM_FACTOR, self.opacity.to_f * NORM_FACTOR]
+  end
+
+  def norm_red
+    self.red.to_f * NORM_FACTOR
+  end
+
+  def norm_green
+    self.green.to_f * NORM_FACTOR
+  end
+
+  def norm_blue
+    self.blue.to_f * NORM_FACTOR
+  end
+
+  def norm_opacity
+    self.opacity.to_f * NORM_FACTOR
+  end
+
+  def is_black_or_white?
+    r, g, b = self.norm_red, self.norm_green, self.norm_blue
+    black_thresh = 0.09 * 255.to_f
+    white_thresh = 0.91 * 255.to_f
+    (r > white_thresh && g > white_thresh && b > white_thresh) || (r < black_thresh && g < black_thresh && b < black_thresh) ? true : false
+  end
+
+  def is_distinct?(other_pixel)
+    r, g, b, a = self.norm_red, self.norm_green, self.norm_blue, self.norm_opacity
+    other_r, other_g, other_b, other_a = other_pixel.norm_red, other_pixel.norm_green, other_pixel.norm_blue, other_pixel.norm_opacity
+    upper_thresh = 0.25 * 255.to_f
+    lower_thresh = 0.03 * 255.to_f
+
+    if (r - other_r).abs > upper_thresh || (g - other_g).abs > upper_thresh || (b - other_b).abs > upper_thresh || (a - other_a).abs > upper_thresh
+      if (r - g).abs < lower_thresh && (r - b).abs < lower_thresh && (other_r - other_g).abs < lower_thresh && (other_r - other_b).abs < lower_thresh
+        return false
+      end
+      return true
+    end
+    return false
+  end
+
+  def is_contrasting?(other_pixel)
+    # Calculate contrast using the W3C formula
+    #   http://www.w3.org/TR/WCAG20-TECHS/G145.html
+    lum = self.luminance
+    other_pixel_lum = other_pixel.luminance
+    contrast = 0
+    if lum > other_pixel_lum
+      contrast = (lum + 0.05) / (other_pixel_lum + 0.05)
+    else
+      contrast = (other_pixel_lum + 0.05) / (lum + 0.05)
+    end
+
+    return contrast.to_f > 3
+  end
+
+  def is_dark?
+    return self.luminance < 0.5
+  end
+
+  def luminance
+    r, g, b = self.norm_red / 255.to_f, self.norm_green / 255.to_f, self.norm_blue / 255.to_f
+    if r <= 0.03928
+      r = r / 12.92
+    else
+      r = ((r + 0.055) / 1.055) ** 2.4
+    end
+
+    if g <= 0.03928
+      g = g / 12.92
+    else
+      g = ((g + 0.055) / 1.055) ** 2.4
+    end
+
+    if b <= 0.03928
+      b = b / 12.92
+    else
+      b = ((b + 0.055) / 1.055) ** 2.4
+    end
+
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+  end
+
+  private
+
+  NORM_FACTOR = 255.to_f / Magick::QuantumRange.to_f
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: Paletti
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Satyam Ghodasara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-24 00:00:00.000000000 Z
+dependencies: []
+description: Paletti takes an image and finds its background color as well as the
+  best primary, secondary, and detail text colors that are readable on the background
+  color.
+email: sghodas@gmail.com
+executables:
+- pal
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pal
+- lib/paletti.rb
+- lib/paletti/pixel.rb
+homepage: https://github.com/sghodas/paletti
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Paletti generates readable text colors to display over images.
+test_files: []