image_util 0.1.0 → 0.3.0

data/lib/image_util/color/css_colors.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  class Color < Array
+    CSS_COLORS = {
+      "aliceblue" => [240, 248, 255],
+      "antiquewhite" => [250, 235, 215],
+      "aqua" => [0, 255, 255],
+      "aquamarine" => [127, 255, 212],
+      "azure" => [240, 255, 255],
+      "beige" => [245, 245, 220],
+      "bisque" => [255, 228, 196],
+      "black" => [0, 0, 0],
+      "blanchedalmond" => [255, 235, 205],
+      "blue" => [0, 0, 255],
+      "blueviolet" => [138, 43, 226],
+      "brown" => [165, 42, 42],
+      "burlywood" => [222, 184, 135],
+      "cadetblue" => [95, 158, 160],
+      "chartreuse" => [127, 255, 0],
+      "chocolate" => [210, 105, 30],
+      "coral" => [255, 127, 80],
+      "cornflowerblue" => [100, 149, 237],
+      "cornsilk" => [255, 248, 220],
+      "crimson" => [220, 20, 60],
+      "cyan" => [0, 255, 255],
+      "darkblue" => [0, 0, 139],
+      "darkcyan" => [0, 139, 139],
+      "darkgoldenrod" => [184, 134, 11],
+      "darkgray" => [169, 169, 169],
+      "darkgrey" => [169, 169, 169],
+      "darkgreen" => [0, 100, 0],
+      "darkkhaki" => [189, 183, 107],
+      "darkmagenta" => [139, 0, 139],
+      "darkolivegreen" => [85, 107, 47],
+      "darkorange" => [255, 140, 0],
+      "darkorchid" => [153, 50, 204],
+      "darkred" => [139, 0, 0],
+      "darksalmon" => [233, 150, 122],
+      "darkseagreen" => [143, 188, 143],
+      "darkslateblue" => [72, 61, 139],
+      "darkslategray" => [47, 79, 79],
+      "darkslategrey" => [47, 79, 79],
+      "darkturquoise" => [0, 206, 209],
+      "darkviolet" => [148, 0, 211],
+      "deeppink" => [255, 20, 147],
+      "deepskyblue" => [0, 191, 255],
+      "dimgray" => [105, 105, 105],
+      "dimgrey" => [105, 105, 105],
+      "dodgerblue" => [30, 144, 255],
+      "firebrick" => [178, 34, 34],
+      "floralwhite" => [255, 250, 240],
+      "forestgreen" => [34, 139, 34],
+      "fuchsia" => [255, 0, 255],
+      "gainsboro" => [220, 220, 220],
+      "ghostwhite" => [248, 248, 255],
+      "gold" => [255, 215, 0],
+      "goldenrod" => [218, 165, 32],
+      "gray" => [128, 128, 128],
+      "grey" => [128, 128, 128],
+      "green" => [0, 128, 0],
+      "greenyellow" => [173, 255, 47],
+      "honeydew" => [240, 255, 240],
+      "hotpink" => [255, 105, 180],
+      "indianred" => [205, 92, 92],
+      "indigo" => [75, 0, 130],
+      "ivory" => [255, 255, 240],
+      "khaki" => [240, 230, 140],
+      "lavender" => [230, 230, 250],
+      "lavenderblush" => [255, 240, 245],
+      "lawngreen" => [124, 252, 0],
+      "lemonchiffon" => [255, 250, 205],
+      "lightblue" => [173, 216, 230],
+      "lightcoral" => [240, 128, 128],
+      "lightcyan" => [224, 255, 255],
+      "lightgoldenrodyellow" => [250, 250, 210],
+      "lightgray" => [211, 211, 211],
+      "lightgrey" => [211, 211, 211],
+      "lightgreen" => [144, 238, 144],
+      "lightpink" => [255, 182, 193],
+      "lightsalmon" => [255, 160, 122],
+      "lightseagreen" => [32, 178, 170],
+      "lightskyblue" => [135, 206, 250],
+      "lightslategray" => [119, 136, 153],
+      "lightslategrey" => [119, 136, 153],
+      "lightsteelblue" => [176, 196, 222],
+      "lightyellow" => [255, 255, 224],
+      "lime" => [0, 255, 0],
+      "limegreen" => [50, 205, 50],
+      "linen" => [250, 240, 230],
+      "magenta" => [255, 0, 255],
+      "maroon" => [128, 0, 0],
+      "mediumaquamarine" => [102, 205, 170],
+      "mediumblue" => [0, 0, 205],
+      "mediumorchid" => [186, 85, 211],
+      "mediumpurple" => [147, 112, 219],
+      "mediumseagreen" => [60, 179, 113],
+      "mediumslateblue" => [123, 104, 238],
+      "mediumspringgreen" => [0, 250, 154],
+      "mediumturquoise" => [72, 209, 204],
+      "mediumvioletred" => [199, 21, 133],
+      "midnightblue" => [25, 25, 112],
+      "mintcream" => [245, 255, 250],
+      "mistyrose" => [255, 228, 225],
+      "moccasin" => [255, 228, 181],
+      "navajowhite" => [255, 222, 173],
+      "navy" => [0, 0, 128],
+      "oldlace" => [253, 245, 230],
+      "olive" => [128, 128, 0],
+      "olivedrab" => [107, 142, 35],
+      "orange" => [255, 165, 0],
+      "orangered" => [255, 69, 0],
+      "orchid" => [218, 112, 214],
+      "palegoldenrod" => [238, 232, 170],
+      "palegreen" => [152, 251, 152],
+      "paleturquoise" => [175, 238, 238],
+      "palevioletred" => [219, 112, 147],
+      "papayawhip" => [255, 239, 213],
+      "peachpuff" => [255, 218, 185],
+      "peru" => [205, 133, 63],
+      "pink" => [255, 192, 203],
+      "plum" => [221, 160, 221],
+      "powderblue" => [176, 224, 230],
+      "purple" => [128, 0, 128],
+      "red" => [255, 0, 0],
+      "rosybrown" => [188, 143, 143],
+      "royalblue" => [65, 105, 225],
+      "saddlebrown" => [139, 69, 19],
+      "salmon" => [250, 128, 114],
+      "sandybrown" => [244, 164, 96],
+      "seagreen" => [46, 139, 87],
+      "seashell" => [255, 245, 238],
+      "sienna" => [160, 82, 45],
+      "silver" => [192, 192, 192],
+      "skyblue" => [135, 206, 235],
+      "slateblue" => [106, 90, 205],
+      "slategray" => [112, 128, 144],
+      "slategrey" => [112, 128, 144],
+      "snow" => [255, 250, 250],
+      "springgreen" => [0, 255, 127],
+      "steelblue" => [70, 130, 180],
+      "tan" => [210, 180, 140],
+      "teal" => [0, 128, 128],
+      "thistle" => [216, 191, 216],
+      "tomato" => [255, 99, 71],
+      "turquoise" => [64, 224, 208],
+      "violet" => [238, 130, 238],
+      "wheat" => [245, 222, 179],
+      "white" => [255, 255, 255],
+      "whitesmoke" => [245, 245, 245],
+      "yellow" => [255, 255, 0],
+      "yellowgreen" => [154, 205, 50],
+      "rebeccapurple" => [102, 51, 153]
+    }.transform_values(&:freeze).transform_keys(&:to_sym).freeze
+
+    CSS_COLORS_4C = CSS_COLORS.transform_values { |i| (i + [255]).freeze }.freeze
+  end
+end

data/lib/image_util/color.rb

@@ -6,6 +6,7 @@ module ImageUtil
       super(args)
     end
 
+    autoload :CSS_COLORS, "image_util/color/css_colors"
     def r = self[0]
     def g = self[1]
     def b = self[2]
@@ -40,7 +41,7 @@ module ImageUtil
       end.then { |val| new(*val) }
     end
 
-    def to_buffer(color_bits, color_length)
+    def to_buffer(color_bits, channels)
       map do |i|
         case color_bits
         when 8
@@ -48,9 +49,47 @@ module ImageUtil
         else
           (i.to_f * 2**(color_bits - 8)).to_i
         end
-      end + [255] * (color_length - length)
+      end + [255] * (channels - length)
     end
 
+    # rubocop:disable Metrics/BlockNesting
+
+    # Optimized shortpath for a heavily hit fragment. Let's skip creating colors if
+    # they are to be output to buffer instantly.
+    def self.from_any_to_buffer(value, color_bits, channels)
+      if color_bits == 8
+        case value
+        when Color
+          return value.to_buffer(color_bits, channels)
+        when Array
+          if channels == value.length && value.all? { |i| nice_int?(i) }
+            return value
+          elsif channels == 4 && value.length == 3 && value.all? { |i| nice_int?(i) }
+            return value + [255]
+          end
+        when Symbol, String
+          s = value.to_sym
+          if CSS_COLORS.key?(s)
+            if channels == 3
+              return CSS_COLORS[s]
+            elsif channels == 4
+              return CSS_COLORS_4C[s]
+            end
+          end
+        end
+      end
+      from(value).to_buffer(color_bits, channels)
+    end
+
+    # rubocop:enable Metrics/BlockNesting
+    # rubocop:disable Style/ClassEqualityComparison
+
+    def self.nice_int?(i)
+      i.class == Integer && i >= 0 && i <= 255
+    end
+
+    # rubocop:enable Style/ClassEqualityComparison
+
     def self.from(value)
       case value
       when Color
@@ -69,17 +108,20 @@ module ImageUtil
           new($1.to_i(16), $2.to_i(16), $3.to_i(16))
         when /\A#(\h{2})(\h{2})(\h{2})(\h{2})\z/
           new($1.to_i(16), $2.to_i(16), $3.to_i(16), $4.to_i(16))
-        when "black" then new(0, 0, 0)
-        when "white" then new(255, 255, 255)
-        when "red" then new(255, 0, 0)
-        when "lime" then new(0, 255, 0)
-        when "blue" then new(0, 0, 255)
         else
-          raise ArgumentError, "wrong String passed as color (passed: #{value.inspect})"
+          if (rgb = CSS_COLORS[value.downcase.to_sym])
+            new(*rgb)
+          else
+            raise ArgumentError, "wrong String passed as color (passed: #{value.inspect})"
+          end
         end
       when Symbol
-        from(value.to_s)
-      when Integer, Float, nil
+        if (rgb = CSS_COLORS[value])
+          new(*rgb)
+        else
+          from(value.to_s)
+        end
+      when Integer, Float, NilClass
         new(*[component_from_number(value)] * 3)
       else
         raise ArgumentError, "wrong type passed as color (passed: #{value.inspect})"
@@ -139,11 +181,22 @@ module ImageUtil
       Color.new(out_r, out_g, out_b, out_a * 255)
     end
 
-    # Multiplies the alpha channel by the given factor and returns a new color.
+    # If given a Numeric argument, multiplies the alpha channel by the given factor
+    # and returns a new color.
+    #
+    # If given a color, create a new one by multiplying all channels.
     def *(other)
-      raise TypeError, "factor must be numeric" unless other.is_a?(Numeric)
-
-      Color.new(r, g, b, (a * other).clamp(0, 255))
+      case other
+      when Numeric
+        Color.new(r, g, b, (a * other).clamp(0, 255))
+      when Color
+        Color.new(*map.with_index do |c, idx|
+          oc = other[idx] || (idx == 3 ? 255 : 0)
+          c * oc / 255
+        end)
+      else
+        raise TypeError, "factor must be either numeric or color"
+      end
     end
   end
 end

data/lib/image_util/extension.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Extension
+    EXTENSIONS = {
+      pam: [".pam"],
+      png: [".png"],
+      jpeg: [".jpg", ".jpeg"],
+      gif: [".gif"],
+      apng: [".apng"]
+    }.freeze
+
+    LOOKUP = EXTENSIONS.flat_map { |fmt, exts| exts.map { |e| [e, fmt] } }.to_h.freeze
+
+    module_function
+
+    def detect(path)
+      return nil unless path
+
+      ext = File.extname(path.to_s).downcase
+      LOOKUP[ext]
+    end
+  end
+end

data/lib/image_util/filter/_mixin.rb

@@ -10,6 +10,15 @@ module ImageUtil
           end
         end
       end
+
+      def axis_to_number(axis)
+        axis = 0 if axis == :x
+        axis = 1 if axis == :y
+        axis = 2 if axis == :z
+        axis
+      end
+
+      module_function :axis_to_number
     end
   end
 end

data/lib/image_util/filter/background.rb

@@ -4,15 +4,15 @@ module ImageUtil
   module Filter
     module Background
       def background(bgcolor)
-        return self if color_length == 3
+        return self if channels == 3
 
-        unless color_length == 4
+        unless channels == 4
           raise ArgumentError, "background only supported on RGB or RGBA images"
         end
 
         bg = Color.from(bgcolor)
-        img = Image.new(*dimensions, color_bits: color_bits, color_length: 3)
-        img.set_each_pixel_by_location do |loc|
+        img = Image.new(*dimensions, color_bits: color_bits, channels: 3)
+        img.set_each_pixel_by_location! do |loc|
           over = bg + self[*loc]
           Color.new(over.r, over.g, over.b)
         end

data/lib/image_util/filter/bitmap_text.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module BitmapText
+      extend ImageUtil::Filter::Mixin
+
+      def bitmap_text!(text, *location, **kwargs)
+        loc = location.dup
+        loc += [0] * (dimensions.length - loc.length)
+        paste!(Image.bitmap_text(text, **kwargs), *loc, respect_alpha: true)
+      end
+
+      define_immutable_version :bitmap_text
+    end
+  end
+end

data/lib/image_util/filter/colors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Colors
+      extend ImageUtil::Filter::Mixin
+
+      def color_multiply!(color)
+        col = Color.from(color)
+        set_each_pixel_by_location! do |loc|
+          self[*loc] * col
+        end
+        self
+      end
+
+      define_immutable_version :color_multiply
+
+      alias * color_multiply
+    end
+  end
+end

data/lib/image_util/filter/draw.rb

@@ -16,12 +16,12 @@ module ImageUtil
       )
         fp = self.view(view)
 
-        axis = axis_to_number(axis)
+        axis = Filter::Mixin.axis_to_number(axis)
         draw_axis ||= case axis
                       when 0 then 1
                       when 1 then 0
                       end
-        draw_axis = axis_to_number(draw_axis)
+        draw_axis = Filter::Mixin.axis_to_number(draw_axis)
 
         limit ||= (0..)
         limit = Range.new(limit.begin, dimensions[axis]-1, false) if limit.end == nil
@@ -62,16 +62,29 @@ module ImageUtil
         end
       end
 
-      define_immutable_version :draw_function, :draw_line
+      def draw_circle!(center, radius, color = Color[:black], view: View::Interpolated)
+        fp = self.view(view)
+        cx, cy = center
+        min_x = (cx - radius).ceil
+        max_x = (cx + radius).floor
+        min_x.upto(max_x) do |x|
+          dy = Math.sqrt(radius * radius - (x - cx)**2)
+          fp[x, cy + dy] = color
+          fp[x, cy - dy] = color
+        end
 
-      private
+        min_y = (cy - radius).ceil
+        max_y = (cy + radius).floor
+        min_y.upto(max_y) do |y|
+          dx = Math.sqrt(radius * radius - (y - cy)**2)
+          fp[cx + dx, y] = color
+          fp[cx - dx, y] = color
+        end
 
-      def axis_to_number(axis)
-        axis = 0 if axis == :x
-        axis = 1 if axis == :y
-        axis = 2 if axis == :z
-        axis
+        self
       end
+
+      define_immutable_version :draw_function, :draw_line, :draw_circle
     end
   end
 end

data/lib/image_util/filter/palette.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Palette
+      extend ImageUtil::Filter::Mixin
+
+      # A more descriptive name for this structure would be
+      # N-tree, where N = 2**color_components. Let's pretend
+      # we are dealing with 3-color component trees though,
+      # so Octree it is.
+      class ColorOctree < Array
+        def dig(nexthop, *rest)
+          self[nexthop] ||= ColorOctree.new(length)
+          super
+        end
+
+        def number_bits(number)
+          array = Array.new(8)
+          i = 0
+          number = number.to_i
+          while i < 8
+            array[7 - i] = ((number >> i) & 1)
+            i += 1
+          end
+          array
+        end
+
+        def generate_key(component_bits)
+          number = 0
+          component_bits.reverse_each do |i|
+            number <<= 1
+            number |= i
+          end
+          number
+        end
+
+        def key_array(color)
+          color.map do |component|
+            number_bits(component)
+          end.transpose.map do |i|
+            generate_key(i)
+          end
+        end
+
+        # rubocop:disable Style/Semicolon
+
+        # Optimized path for (r,g,b) colors.
+        def key_array3(color)
+          i = 0
+          r = color[0].to_i; g = color[1].to_i; b = color[2].to_i
+          array = Array.new(8)
+          while i < 8
+            array[7 - i] = (r & 1) | (g & 1) << 1 | (b & 1) << 2
+            r >>= 1; g >>= 1; b >>= 1
+            i += 1
+          end
+          array
+        end
+
+        # Optimized path for (r,g,b,a) colors.
+        def key_array4(color)
+          i = 0
+          r = color[0].to_i; g = color[1].to_i; b = color[2].to_i; a = color[3].to_i
+          array = Array.new(8)
+          while i < 8
+            array[7 - i] = (r & 1) | (g & 1) << 1 | (b & 1) << 2 | (a & 1) << 3
+            r >>= 1; g >>= 1; b >>= 1; a >>= 1
+            i += 1
+          end
+          array
+        end
+
+        # rubocop:enable Style/Semicolon
+
+        def build_from(colors)
+          colors.each do |color|
+            color_path = case color.length
+                         when 3
+                           key_array3(color)
+                         when 4
+                           key_array4(color)
+                         else
+                           key_array(color)
+                         end
+
+            dig(*color_path[0..-2])[color_path[-1]] = color
+          end
+
+          self
+        end
+
+        # rubocop:disable Style/StringConcatenation
+        def inspect
+          "#<Octree:[" +
+            filter_map.with_index do |i,idx|
+              "0b#{idx.to_s(2)} => #{i.inspect}," if i
+            end.join(", ") +
+            "]>"
+        end
+        # rubocop:enable Style/StringConcatenation
+
+        def available_with_index
+          each_with_index.select(&:first)
+        end
+
+        def pretty_print(pp)
+          pp.group(1, "#<Octree:", ">") do
+            pp.breakable ""
+            pp.group(1, "[", "]") do
+              pp.seplist(available_with_index) do |i,idx|
+                pp.text "0b#{idx.to_s(2)}"
+                pp.text " => "
+                pp.pp i
+              end
+            end
+          end
+        end
+
+        def empty?
+          compact.empty?
+        end
+
+        def take(n)
+          taken = []
+          length.times do |idx|
+            next unless (i = self[idx])
+
+            taken << i
+            self[idx] = nil
+
+            if taken.length >= n - 1 && !empty?
+              taken << self
+              break
+            elsif taken.length >= n
+              break
+            end
+          end
+
+          raise if taken.length > n
+
+          taken
+        end
+
+        def colors
+          select { |i| i.is_a? Color } +
+            select { |i| i.is_a? ColorOctree }.map { |i| i.colors }.flatten(1)
+        end
+      end
+
+      def palette_reduce!(count)
+        colors = unique_colors
+
+        return self if colors.length <= count
+
+        octree = ColorOctree.new
+        octree.build_from(colors)
+
+        queue = [octree]
+        while queue.length < count
+          elem = queue.shift
+          case elem
+          when Color
+            queue << elem
+          when ColorOctree
+            needed = count - queue.length
+            got = elem.take(needed)
+            queue += got
+          end
+        end
+
+        equiv = {}
+
+        queue.each do |i|
+          case i
+          when Color
+            equiv[i] = i
+          when ColorOctree
+            colors = i.colors
+            picked = colors[colors.length / 2]
+            colors.each do |color|
+              equiv[color] = picked
+            end
+          end
+        end
+
+        set_each_pixel_by_location! do |loc|
+          equiv[self[*loc]]
+        end
+
+        self
+      end
+
+      define_immutable_version :palette_reduce
+    end
+  end
+end

data/lib/image_util/filter/paste.rb

@@ -11,7 +11,7 @@ module ImageUtil
         if !respect_alpha &&
            image.dimensions.length == 1 &&
            image.color_bits == color_bits &&
-           image.color_length == color_length &&
+           image.channels == channels &&
            buffer.respond_to?(:copy_1d)
           loc = location.map(&:to_i)
           begin