colordom 0.2.0 → 0.3.0

data/{Cargo.toml → ext/colordom/Cargo.toml}

@@ -6,6 +6,7 @@ edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
+magnus = "0.3"
 image = "0.24"
 dominant_color = "0.3"
 palette_extract = "0.1"

data/ext/colordom/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('colordom/colordom')

data/ext/colordom/src/lib.rs

@@ -0,0 +1,156 @@
+use std::path::PathBuf;
+
+use magnus::{
+  class, define_module, function, method,
+  prelude::*, gc::register_mark_object, memoize,
+  Error, ExceptionClass, RClass, RModule
+};
+
+use image::{DynamicImage};
+use palette_extract::{Quality, MaxColors, PixelEncoding, PixelFilter};
+use palette::{FromColor, IntoColor, Lab, Pixel, Srgb};
+
+use dominant_color;
+use kmeans_colors;
+
+fn colordom_error() -> ExceptionClass {
+  *memoize!(ExceptionClass: {
+    let ex: RClass = class::object().const_get::<_, RModule>("Colordom").unwrap().const_get("Error").unwrap();
+    register_mark_object(ex);
+
+    ExceptionClass::from_value(*ex).unwrap()
+  })
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "Colordom::Color", free_immediatly, size)]
+struct Color {
+  r: u8,
+  g: u8,
+  b: u8
+}
+
+impl Color {
+  fn new(r: u8, g: u8, b: u8) -> Self {
+    Self { r, g, b }
+  }
+
+  fn r(&self) -> u8 { self.r }
+  fn g(&self) -> u8 { self.g }
+  fn b(&self) -> u8 { self.b }
+
+  fn rgb(&self) -> Vec<u8> {
+    vec![self.r, self.g, self.b]
+  }
+
+  fn hex(&self) -> String {
+    format!("#{:02X}{:02X}{:02X}", self.r, self.g, self.b)
+  }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "Colordom::Image", free_immediatly, size)]
+struct Image {
+  img: DynamicImage
+}
+
+impl Image {
+  fn new(path: PathBuf) -> Result<Self, Error> {
+    match image::open(&path) {
+      Ok(img) => Ok(Self { img }),
+      Err(ex) => Err(Error::new(colordom_error(), ex.to_string()))
+    }
+  }
+
+  fn pixels(&self) -> &[u8] {
+    self.img.as_bytes()
+  }
+
+  fn has_alpha(&self) -> bool {
+    self.img.color().has_alpha()
+  }
+
+  fn histogram(&self, max_colors: usize) -> Vec<Color> {
+    let colors = dominant_color::get_colors(
+      &self.pixels(),
+      self.has_alpha()
+    );
+
+    colors.chunks(3)
+      .take(max_colors)
+      .map(|x| Color::new(x[0], x[1], x[2]))
+      .collect::<Vec<Color>>()
+  }
+
+  fn mediancut(&self, max_colors: usize) -> Vec<Color> {
+    let colors = palette_extract::get_palette_with_options(
+      &self.pixels(),
+      PixelEncoding::Rgb,
+      Quality::new(6),
+      MaxColors::new(max_colors as u8),
+      PixelFilter::None
+    );
+
+    colors.iter()
+      .take(max_colors)
+      .map(|x| Color::new(x.r, x.g, x.b))
+      .collect::<Vec<Color>>()
+  }
+
+  fn kmeans(&self, max_colors: usize) -> Vec<Color> {
+    let max_iterations = 20;
+    let converge = 1.0;
+    let verbose = false;
+    let seed = 0;
+
+    let lab: Vec<Lab> = Srgb::from_raw_slice(&self.pixels()).iter()
+      .map(|x| x.into_format().into_color())
+      .collect();
+
+    let result = kmeans_colors::get_kmeans_hamerly(
+      max_colors, max_iterations, converge, verbose, &lab, seed
+    );
+
+    let colors = &result.centroids.iter()
+      .map(|x| Srgb::from_color(*x).into_format())
+      .collect::<Vec<Srgb<u8>>>();
+
+    colors.iter()
+      .take(max_colors)
+      .map(|x| Color::new(x.red, x.green, x.blue))
+      .collect::<Vec<Color>>()
+  }
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+  let module = define_module("Colordom")?;
+
+  let colorc = module.define_class("Color", Default::default())?;
+
+  colorc.define_singleton_method("new", function!(Color::new, 3))?;
+  colorc.define_method("r", method!(Color::r, 0))?;
+  colorc.define_method("g", method!(Color::g, 0))?;
+  colorc.define_method("b", method!(Color::b, 0))?;
+
+  colorc.define_method("rgb", method!(Color::rgb, 0))?;
+  colorc.define_method("hex", method!(Color::hex, 0))?;
+
+  colorc.define_method("clone", method!(Color::clone, 0))?;
+  colorc.define_method("dup", method!(Color::clone, 0))?;
+
+  colorc.define_alias("to_rgb", "rgb")?;
+  colorc.define_alias("to_hex", "hex")?;
+
+  let imagec = module.define_class("Image", Default::default())?;
+
+  imagec.define_singleton_method("new", function!(Image::new, 1))?;
+  imagec.define_method("histogram", method!(Image::histogram, 1))?;
+  imagec.define_method("mediancut", method!(Image::mediancut, 1))?;
+  imagec.define_method("kmeans", method!(Image::kmeans, 1))?;
+
+  imagec.define_method("clone", method!(Image::clone, 0))?;
+  imagec.define_method("dup", method!(Image::clone, 0))?;
+
+  Ok(())
+}

data/lib/colordom/color.rb

@@ -1,25 +1,49 @@
+# frozen_string_literal: true
+
 module Colordom
+  # Color object with RGB and HEX values implemented in Rust.
   class Color
-    attr_reader :r, :g, :b
+    # @!method initialize(r, g, b)
+    # A new instance of Color.
+    # @return [Color]
 
-    def initialize(red, green, blue)
-      @r, @g, @b = [red, green, blue].map(&:to_i)
-    end
+    # @!attribute [r] r
+    # Red color value.
+    # @return [Integer]
 
-    def ==(other)
-      other.is_a?(self.class) &&
-        rgb == other.rgb
-    end
+    # @!attribute [r] g
+    # Green color value.
+    # @return [Integer]
 
-    def rgb
-      [r, g, b]
-    end
+    # @!attribute [r] b
+    # Blue color value.
+    # @return [Integer]
 
-    def hex
-      '#%02X%02X%02X' % rgb
-    end
+    # @!method rgb
+    # @!parse [ruby] alias to_rgb rgb
+    # Get the RGB representation of the color.
+    # @return [Array<Integer>]
+
+    # @!method hex
+    # @!parse [ruby] alias to_hex hex
+    # Get the hex representation of the color.
+    # @return [String]
+
+    # Compare with other color value.
+    # @param other [Color, Array<Integer>, String]
+    # @return [Boolean]
 
-    alias to_rgb rgb
-    alias to_hex hex
+    def ==(other)
+      case other
+      when Array
+        rgb == other
+      when String
+        hex == other
+      when self.class
+        rgb == other.rgb
+      else
+        false
+      end
+    end
   end
 end

data/lib/colordom/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Colordom
   class Error < StandardError
   end

data/lib/colordom/image.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Colordom
+  # Image object implemented in Rust that extracts dominant colors.
+  class Image
+    # @!method initialize(path)
+    # A new instance of Image.
+    # @param path [String, Pathname, File]
+    # @return [Image]
+    # @raise [Error] if path is not a valid image
+
+    # @!method histogram(max_colors)
+    # Get dominant colors using histogram quantization.
+    # @param max_colors [Integer]
+    # @return [Array<Color>]
+
+    # @!method mediancut(max_colors)
+    # Get dominant colors using media cut quantization.
+    # @param max_colors [Integer]
+    # @return [Array<Color>]
+
+    # @!method kmeans(max_colors)
+    # Get dominant colors using k-means clustering.
+    # @param max_colors [Integer]
+    # @return [Array<Color>]
+  end
+end

data/lib/colordom/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Colordom
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'
 end

data/lib/colordom.rb

@@ -1,56 +1,52 @@
-require 'ffi'
+# frozen_string_literal: true
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "colordom/#{$1}/colordom"
+rescue LoadError
+  require 'colordom/colordom'
+end
 
-require 'colordom/result'
-require 'colordom/native'
 require 'colordom/error'
 require 'colordom/color'
+require 'colordom/image'
 require 'colordom/version'
 
+# Module that extracts dominant colors from images
+# using native extension implemented in Rust.
 module Colordom
   class << self
-    def histogram(path, max_colors = 5)
-      regex = /(\d+), (\d+), (\d+)/
-      value = call(:to_histogram, path)
-
-      parse(value, regex, max_colors)
-    end
-
-    def mediancut(path, max_colors = 5)
-      regex = /r: (\d+), g: (\d+), b: (\d+)/
-      value = call(:to_mediancut, path, max_colors)
-
-      parse(value, regex, max_colors)
-    end
+    # Get dominant colors using histogram quantization.
+    # @param path (see Image#initialize)
+    # @param max_colors (see Image#histogram)
+    # @return (see Image#histogram)
+    # @raise (see Image#initialize)
 
-    def kmeans(path, max_colors = 5)
-      regex = /red: (\d+), green: (\d+), blue: (\d+)/
-      value = call(:to_kmeans, path, max_colors)
-
-      parse(value, regex)
+    def histogram(path, max_colors = 5)
+      image = Image.new(path)
+      image.histogram(max_colors)
     end
 
-    private
-
-    def call(method, path, *args)
-      return if path.nil?
-
-      result = Native.send(method, path, *args)
-      result = result.read_string.force_encoding('UTF-8')
+    # Get dominant colors using media cut quantization.
+    # @param path (see Image#initialize)
+    # @param max_colors (see Image#mediancut)
+    # @return (see Image#mediancut)
+    # @raise (see Image#initialize)
 
-      raise Error, result if result.start_with?(Error.name)
-
-      result
+    def mediancut(path, max_colors = 5)
+      image = Image.new(path)
+      image.mediancut(max_colors)
     end
 
-    def parse(result, regex, limit = nil)
-      return [] if result.nil?
+    # Get dominant colors using k-means clustering.
+    # @param path (see Image#initialize)
+    # @param max_colors (see Image#kmeans)
+    # @return (see Image#kmeans)
+    # @raise (see Image#initialize)
 
-      colors = result.scan(regex)
-      colors = colors.first(limit) if limit && limit.positive?
-
-      colors.map do |values|
-        Color.new(*values)
-      end
+    def kmeans(path, max_colors = 5)
+      image = Image.new(path)
+      image.kmeans(max_colors)
     end
   end
 end

metadata

@@ -1,31 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: colordom
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonian Guveli
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-20 00:00:00.000000000 Z
+date: 2022-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi
-  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: thermite
+  name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,48 +53,39 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '1.2'
 description: Extract dominant colors from images using native extension implemented
   in Rust.
 email:
 - jonian@hardpixel.eu
 executables: []
 extensions:
-- ext/Rakefile
+- ext/colordom/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- Cargo.toml
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/benchmark
-- bin/compare
-- bin/console
-- bin/setup
-- colordom.gemspec
-- ext/Rakefile
+- ext/colordom/Cargo.lock
+- ext/colordom/Cargo.toml
+- ext/colordom/extconf.rb
+- ext/colordom/src/lib.rs
 - lib/colordom.rb
 - lib/colordom/color.rb
 - lib/colordom/error.rb
-- lib/colordom/native.rb
-- lib/colordom/result.rb
+- lib/colordom/image.rb
 - lib/colordom/version.rb
-- src/lib.rs
 homepage: https://github.com/hardpixel/colordom
 licenses:
 - MIT
@@ -121,14 +98,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Extract dominant colors from images

data/.gitignore

@@ -1,17 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-Gemfile.lock
-
-# Added by cargo
-
-/target
-Cargo.lock
-
-/lib/*.so
-/mkmf.log

data/.travis.yml

@@ -1,13 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.7.2
-env:
-  global:
-    - RUST_VERSION=stable
-before_install:
-  - if [ ! -e "$HOME/.cargo/bin" ]; then curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain $RUST_VERSION -y; fi
-  - export PATH="$HOME/.cargo/bin:$PATH"
-  - rustup default $RUST_VERSION
-  - gem install bundler -v 2.1.4

data/Gemfile

@@ -1,11 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in colordom.gemspec
-gemspec
-
-gem 'benchmark-ips'
-gem 'benchmark-memory'
-gem 'camalian'
-gem 'colorscore'
-gem 'miro', github: 'jonbuda/miro'
-gem 'chunky_png', '1.3.15'

data/Rakefile

@@ -1,13 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-require 'thermite/tasks'
-
-Thermite::Tasks.new
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-task default: %w[thermite:build test]

data/bin/benchmark

@@ -1,80 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-
-require 'benchmark/ips'
-require 'benchmark/memory'
-
-require 'colordom'
-require 'camalian'
-require 'colorscore'
-require 'miro'
-
-COUNT = 5
-IMAGE = File.join(__dir__, '..', 'samples/sample.png')
-
-def miro(method)
-  Miro.options[:color_count] = COUNT
-  Miro.options[:method] = method
-
-  colors = Miro::DominantColors.new(IMAGE)
-  colors.to_hex
-end
-
-def colorscore
-  histogram = Colorscore::Histogram.new(IMAGE, COUNT)
-  histogram.colors
-end
-
-def camalian(quant)
-  img = Camalian::load(IMAGE)
-  img.prominent_colors(COUNT, quantization: quant)
-end
-
-reports = lambda do |x|
-  x.report('colordom (HST)') do
-    Colordom.histogram(IMAGE, COUNT)
-  end
-
-  x.report('colordom (MCQ)') do
-    Colordom.mediancut(IMAGE, COUNT)
-  end
-
-  x.report('colordom (KMS)') do
-    Colordom.kmeans(IMAGE, COUNT)
-  end
-
-  x.report('colorscore (HST)') do
-    colorscore
-  end
-
-  x.report('miro (HST)') do
-    miro('histogram')
-  end
-
-  x.report('miro (PXG)') do
-    miro('pixel_group')
-  end
-
-  x.report('camalian (HST)') do
-    camalian(Camalian::QUANTIZATION_HISTOGRAM)
-  end
-
-  x.report('camalian (MCQ)') do
-    camalian(Camalian::QUANTIZATION_MEDIAN_CUT)
-  end
-
-  x.report('camalian (KMS)') do
-    camalian(Camalian::QUANTIZATION_K_MEANS)
-  end
-end
-
-Benchmark.ips do |x|
-  reports.call(x)
-  x.compare!
-end
-
-Benchmark.memory do |x|
-  reports.call(x)
-  x.compare!
-end

data/bin/compare

@@ -1,68 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-
-require 'tempfile'
-require 'base64'
-
-require 'colordom'
-require 'camalian'
-require 'colorscore'
-require 'miro'
-
-COUNT = 6
-IMAGE = File.join(__dir__, '..', 'samples/compare.png')
-TEMPL = File.read File.join(__dir__, '..', 'samples/compare.svg')
-
-TEMPL.sub!('compare.png', "data:image/png;base64,#{Base64.strict_encode64(File.read(IMAGE))}")
-
-def replace(prefix, colors)
-  colors.each_with_index do |color, index|
-    TEMPL.sub!("{{#{prefix}-#{index}}}", color)
-  end
-end
-
-def miro(method, prefix)
-  Miro.options[:color_count] = COUNT
-  Miro.options[:method] = method
-
-  colors = Miro::DominantColors.new(IMAGE)
-  replace("miro-#{prefix}", colors.to_hex)
-end
-
-def colorscore(prefix)
-  histogram = Colorscore::Histogram.new(IMAGE, COUNT)
-  replace("colorscore-#{prefix}", histogram.colors.map(&:html))
-end
-
-def camalian(quant, prefix)
-  image  = Camalian::load(IMAGE)
-  colors = image.prominent_colors(COUNT, quantization: quant)
-
-  replace("camalian-#{prefix}", colors.map(&:to_hex))
-end
-
-def colordom(method, prefix)
-  colors = Colordom.send(method, IMAGE, COUNT)
-  replace("colordom-#{prefix}", colors.map(&:to_hex))
-end
-
-colordom(:histogram, 'hst')
-colordom(:mediancut, 'mcq')
-colordom(:kmeans, 'kms')
-
-camalian(Camalian::QUANTIZATION_HISTOGRAM, 'hst')
-camalian(Camalian::QUANTIZATION_MEDIAN_CUT, 'mcq')
-camalian(Camalian::QUANTIZATION_K_MEANS, 'kms')
-
-colorscore('hst')
-
-miro('histogram', 'hst')
-miro('pixel_group', 'pxg')
-
-tempfile = Tempfile.create(['colordom-compare', '.svg'])
-
-tempfile.write(TEMPL)
-tempfile.close
-
-system("xdg-open #{tempfile.path}")