image_util 0.2.0 → 0.3.0

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
@@ -85,15 +85,6 @@ module ImageUtil
       end
 
       define_immutable_version :draw_function, :draw_line, :draw_circle
-
-      private
-
-      def axis_to_number(axis)
-        axis = 0 if axis == :x
-        axis = 1 if axis == :y
-        axis = 2 if axis == :z
-        axis
-      end
     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

data/lib/image_util/filter/redimension.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Redimension
+      extend ImageUtil::Filter::Mixin
+
+      def redimension!(*new_dimensions)
+        if fast_redimension?(new_dimensions)
+          begin
+            resize_buffer!(new_dimensions)
+            return self
+          rescue StandardError
+            # fall back to generic implementation
+          end
+        end
+
+        out = Image.new(*new_dimensions, color_bits: color_bits, channels: channels)
+
+        copy_counts = new_dimensions.map.with_index do |dim, idx|
+          [dim, dimensions[idx] || 1].min
+        end
+
+        ranges = copy_counts[1..] || []
+        each_coordinates(ranges) do |coords|
+          src_buf = row_buffer(coords)
+          out.buffer.copy_1d(src_buf, 0, *coords)
+        end
+
+        initialize_from_buffer(out.buffer)
+        self
+      end
+
+      define_immutable_version :redimension
+
+      private
+
+      def fast_redimension?(new_dimensions)
+        io = buffer.io_buffer
+        return false unless io.respond_to?(:resize)
+        return false if io.external? || io.locked?
+
+        dims = dimensions
+
+        min_len = [dims.length, new_dimensions.length].min
+        idx = 0
+        idx += 1 while idx < min_len && dims[idx] == new_dimensions[idx]
+
+        return false if idx == dims.length && idx == new_dimensions.length
+        return false unless (dims[(idx + 1)..] || []).all? { |d| d == 1 }
+        return false unless (dims[new_dimensions.length..] || []).all? { |d| d == 1 }
+
+        true
+      end
+
+      def resize_buffer!(new_dimensions)
+        new_size = new_dimensions.reduce(1, :*)
+        new_size *= channels
+        new_size *= color_bits / 8
+        buffer.io_buffer.resize(new_size)
+        initialize_from_buffer(Image::Buffer.new(new_dimensions, color_bits, channels, buffer.io_buffer))
+      end
+
+      def each_coordinates(ranges, prefix = [], &block)
+        if ranges.empty?
+          yield prefix
+        else
+          ranges.first.times do |i|
+            each_coordinates(ranges[1..], prefix + [i], &block)
+          end
+        end
+      end
+
+      def row_buffer(coords)
+        buf = buffer
+        coords_src = coords[0, dimensions.length - 1]
+        coords_src += [0] * (dimensions.length - 1 - coords_src.length)
+        coords_src.reverse_each { |c| buf = buf.last_dimension(c) }
+        buf
+      end
+    end
+  end
+end

data/lib/image_util/filter/resize.rb

@@ -10,7 +10,7 @@ module ImageUtil
           new_dim == 1 ? 0.0 : (old_dim - 1).to_f / (new_dim - 1)
         end
 
-        Image.new(*new_dimensions, color_bits: color_bits, color_length: color_length) do |loc|
+        Image.new(*new_dimensions, color_bits: color_bits, channels: channels) do |loc|
           src_loc = loc.zip(factors).map { |coord, factor| coord * factor }
           src[*src_loc]
         end

data/lib/image_util/filter/transform.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Transform
+      extend ImageUtil::Filter::Mixin
+
+      def flip!(axis = :x)
+        axis = Filter::Mixin.axis_to_number(axis)
+        dims = dimensions
+        out = Image.new(*dims, color_bits: color_bits, channels: channels)
+        each_pixel_location do |loc|
+          new_loc = loc.dup
+          new_loc[axis] = dims[axis] - 1 - loc[axis]
+          out[*new_loc] = self[*loc]
+        end
+        initialize_from_buffer(out.buffer)
+        self
+      end
+
+      def rotate!(angle, axes: %i[x y])
+        axes = axes.map { |a| Filter::Mixin.axis_to_number(a) }
+        turns = (angle.to_f / 90).round % 4
+        turns += 4 if turns.negative?
+        turns.times { rotate90_once!(*axes) }
+        self
+      end
+
+      define_immutable_version :flip, :rotate
+
+      private
+
+      def rotate90_once!(axis1 = 0, axis2 = 1)
+        dims = dimensions
+        new_dims = dims.dup
+        new_dims[axis1], new_dims[axis2] = dims[axis2], dims[axis1] # rubocop:disable Style/ParallelAssignment
+        out = Image.new(*new_dims, color_bits: color_bits, channels: channels)
+        each_pixel_location do |loc|
+          new_loc = loc.dup
+          new_loc[axis1] = dims[axis2] - 1 - loc[axis2]
+          new_loc[axis2] = loc[axis1]
+          out[*new_loc] = self[*loc]
+        end
+        initialize_from_buffer(out.buffer)
+      end
+    end
+  end
+end

data/lib/image_util/filter.rb

@@ -2,11 +2,15 @@
 
 module ImageUtil
   module Filter
-    autoload :Dither, "image_util/filter/dither"
+    autoload :Palette, "image_util/filter/palette"
     autoload :Background, "image_util/filter/background"
     autoload :Paste, "image_util/filter/paste"
     autoload :Draw, "image_util/filter/draw"
     autoload :Resize, "image_util/filter/resize"
+    autoload :Transform, "image_util/filter/transform"
+    autoload :Redimension, "image_util/filter/redimension"
+    autoload :Colors, "image_util/filter/colors"
+    autoload :BitmapText, "image_util/filter/bitmap_text"
 
     autoload :Mixin, "image_util/filter/_mixin"
   end

data/lib/image_util/generator/bitmap_text.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Generator
+    module BitmapText
+      def bitmap_text(text, font: BitmapFont.default_font, color: nil, align: :left)
+        fnt = BitmapFont.cached_load(font)
+        lines = text.split("\n")
+
+        rendered = lines.map { |line| fnt.render_line_of_text(line) }
+
+        width  = rendered.map(&:width).max || 0
+        height = rendered.map(&:height).first.to_i * rendered.length
+        height += rendered.length - 1 if rendered.length > 1
+
+        out = Image.new(width, height)
+        y = 0
+        rendered.each do |img|
+          x = case align
+              when :left
+                0
+              when :center
+                (width - img.width) / 2
+              when :right
+                width - img.width
+              else
+                raise ArgumentError, "invalid alignment #{align.inspect}"
+              end
+          out.paste!(img, x, y)
+          y += img.height + 1
+        end
+
+        out *= color if color
+        out
+      end
+    end
+  end
+end 

data/lib/image_util/generator/example.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Generator
+    module Example
+      def example_rose = Image.from_file("#{__dir__}/example/rose.png", :png)
+    end
+  end
+end    

data/lib/image_util/generator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Generator
+    autoload :BitmapText, "image_util/generator/bitmap_text"
+    autoload :Example, "image_util/generator/example"
+  end
+end

data/lib/image_util/image/buffer.rb

@@ -6,7 +6,7 @@ Warning[:experimental] = false
 module ImageUtil
   class Image
     class Buffer
-      def initialize(dimensions, color_bits, color_length, buffer = nil)
+      def initialize(dimensions, color_bits, channels, buffer = nil)
         @color_type = case color_bits
                       when 8
                         :U8
@@ -21,13 +21,15 @@ module ImageUtil
         @dimensions = dimensions.freeze
         @color_bits = color_bits
         @color_bytes = color_bits / 8
-        @color_length = color_length
+        @channels = channels
 
         @buffer_size = @dimensions.reduce(&:*)
-        @buffer_size *= @color_length
+        @buffer_size *= @channels
         @buffer_size *= @color_bytes
 
-        @io_buffer_types = ([@color_type]*@color_length).freeze
+        @pixel_bytes = @channels * @color_bytes
+
+        @io_buffer_types = ([@color_type]*@channels).freeze
 
         @buffer = buffer || IO::Buffer.new(@buffer_size)
 
@@ -36,7 +38,7 @@ module ImageUtil
         freeze
       end
 
-      attr_reader :dimensions, :color_bits, :color_bytes, :color_length
+      attr_reader :dimensions, :color_bits, :color_bytes, :channels, :pixel_bytes
 
       def offset_of(*location)
         location.length == @dimensions.length or raise ArgumentError, "wrong number of dimensions"
@@ -50,8 +52,6 @@ module ImageUtil
         offset * pixel_bytes
       end
 
-      def pixel_bytes = @color_length * @color_bytes
-
       def initialize_copy(_other)
         @buffer = @buffer.dup
       end
@@ -62,7 +62,7 @@ module ImageUtil
 
       def get_index(index)
         value = @buffer.get_values(@io_buffer_types, index)
-        Color.from_buffer(value, @color_bits)
+        Color.from_buffer(value, @color_bits).freeze
       end
 
       def set(location, value)
@@ -70,7 +70,7 @@ module ImageUtil
       end
 
       def set_index(index, value)
-        value = Color.from(value).to_buffer(@color_bits, @color_length)
+        value = Color.from_any_to_buffer(value, @color_bits, @channels)
         @buffer.set_values(@io_buffer_types, index, value)
       end
 
@@ -82,7 +82,7 @@ module ImageUtil
         Buffer.new(
           dimensions_without_last,
           @color_bits,
-          @color_length,
+          @channels,
           @buffer.slice(o0, o1 - o0)
         )
       end
@@ -126,7 +126,7 @@ module ImageUtil
       }.freeze
 
       OPT_GET_INDEX = {
-        8 => ->(index) { Color.new(*@buffer.get_values(@io_buffer_types, index)) }
+        8 => ->(index) { Color.new(*@buffer.get_values(@io_buffer_types, index)).freeze }
       }.freeze
     end
   end