image_util 0.1.0

data/lib/image_util/filter/dither.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Dither
+      extend ImageUtil::Filter::Mixin
+
+      private
+
+      def dither_distance_sq(c1, c2)
+        len = [c1.length, c2.length].max
+
+        case len
+        when 1
+          d = (c1[0] || 255) - (c2[0] || 255)
+          d * d
+        when 2
+          d0 = (c1[0] || 255) - (c2[0] || 255)
+          d1 = (c1[1] || 255) - (c2[1] || 255)
+          d0 * d0 + d1 * d1
+        when 3
+          d0 = (c1[0] || 255) - (c2[0] || 255)
+          d1 = (c1[1] || 255) - (c2[1] || 255)
+          d2 = (c1[2] || 255) - (c2[2] || 255)
+          d0 * d0 + d1 * d1 + d2 * d2
+        when 4
+          d0 = (c1[0] || 255) - (c2[0] || 255)
+          d1 = (c1[1] || 255) - (c2[1] || 255)
+          d2 = (c1[2] || 255) - (c2[2] || 255)
+          d3 = (c1[3] || 255) - (c2[3] || 255)
+          d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3
+        else
+          sum = 0
+          len.times do |i|
+            d = (c1[i] || 255) - (c2[i] || 255)
+            sum += d * d
+          end
+          sum
+        end
+      end
+
+      public
+
+      def dither!(count)
+        palette = histogram.sort_by { |_, v| -v - rand }.first(count).map(&:first)
+
+        cache = {}
+
+        nearest = lambda do |color|
+          key = (color[0] || 255) |
+                ((color[1] || 255) << 8) |
+                ((color[2] || 255) << 16) |
+                ((color[3] || 255) << 24)
+          cache[key] ||= begin
+            best = palette.first
+            best_dist = dither_distance_sq(color, best)
+            idx = 1
+            while idx < palette.length
+              c = palette[idx]
+              dist = dither_distance_sq(color, c)
+              if dist < best_dist
+                best = c
+                best_dist = dist
+              end
+              idx += 1
+            end
+            best
+          end
+        end
+
+        if dimensions.length == 2
+          w = width
+          h = height
+          buf = buffer
+          idx = 0
+          step = buf.pixel_bytes
+          h.times do
+            w.times do
+              color = buf.get_index(idx)
+              buf.set_index(idx, nearest.call(color))
+              idx += step
+            end
+          end
+        else
+          set_each_pixel_by_location do |loc|
+            color = self[*loc]
+            nearest.call(color)
+          end
+        end
+        self
+      end
+
+      define_immutable_version :dither
+    end
+  end
+end

data/lib/image_util/filter/draw.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Draw
+      extend ImageUtil::Filter::Mixin
+
+      # rubocop:disable Metrics/ParameterLists
+      def draw_function!(
+        color = Color[:black],
+        limit = nil,
+        axis:,
+        draw_axis: nil,
+        view: View::Interpolated,
+        plane: [0,0]
+      )
+        fp = self.view(view)
+
+        axis = axis_to_number(axis)
+        draw_axis ||= case axis
+                      when 0 then 1
+                      when 1 then 0
+                      end
+        draw_axis = axis_to_number(draw_axis)
+
+        limit ||= (0..)
+        limit = Range.new(limit.begin, dimensions[axis]-1, false) if limit.end == nil
+
+        limit.each do |axispoint|
+          draw = yield(axispoint)
+
+          loc = plane.dup
+          loc[axis] = axispoint
+          loc[draw_axis] = draw
+
+          fp[*loc] = color
+        end
+
+        self
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def draw_line!(begin_loc, end_loc, color = Color[:black], view: View::Interpolated)
+        begin_x, begin_y = begin_loc
+        end_x, end_y = end_loc
+
+        dist_x = (end_x - begin_x).abs
+        dist_y = (end_y - begin_y).abs
+
+        if dist_x < dist_y
+          begin_x, end_x, begin_y, end_y = end_x, begin_x, end_y, begin_y if begin_y > end_y
+          a = (end_x - begin_x).to_f / (end_y - begin_y)
+          draw_function!(color, begin_y..end_y, axis: :y, view: view) do |y|
+            begin_x + (y - begin_y) * a
+          end
+        else
+          begin_x, end_x, begin_y, end_y = end_x, begin_x, end_y, begin_y if begin_x > end_x
+          a = (end_y - begin_y).to_f / (end_x - begin_x)
+          draw_function!(color, begin_x..end_x, axis: :x, view: view) do |x|
+            begin_y + (x - begin_x) * a
+          end
+        end
+      end
+
+      define_immutable_version :draw_function, :draw_line
+
+      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/paste.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Paste
+      extend ImageUtil::Filter::Mixin
+
+      def paste!(image, *location, respect_alpha: false)
+        raise TypeError, "image must be an Image" unless image.is_a?(Image)
+
+        if !respect_alpha &&
+           image.dimensions.length == 1 &&
+           image.color_bits == color_bits &&
+           image.color_length == color_length &&
+           buffer.respond_to?(:copy_1d)
+          loc = location.map(&:to_i)
+          begin
+            check_bounds!(loc)
+          rescue IndexError
+            return self
+          end
+
+          if loc.first + image.length <= width
+            buffer.copy_1d(image.buffer, *loc)
+            return self
+          end
+        end
+
+        last_dim = image.dimensions.length - 1
+
+        image.each_with_index do |val, idx|
+          new_loc = location.dup
+          new_loc[last_dim] += idx
+
+          begin
+            if val.is_a?(Image)
+              paste!(val, *new_loc, respect_alpha: respect_alpha)
+            elsif respect_alpha
+              self[*new_loc] += val
+            else
+              self[*new_loc] = val
+            end
+          rescue IndexError
+            # do nothing, image overlaps
+          end
+        end
+
+        self
+      end
+
+      define_immutable_version :paste
+    end
+  end
+end

data/lib/image_util/filter/resize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Resize
+      def resize(*new_dimensions, view: View::Interpolated)
+        src = self.view(view)
+
+        factors = new_dimensions.zip(dimensions).map do |new_dim, old_dim|
+          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|
+          src_loc = loc.zip(factors).map { |coord, factor| coord * factor }
+          src[*src_loc]
+        end
+      end
+    end
+  end
+end

data/lib/image_util/filter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    autoload :Dither, "image_util/filter/dither"
+    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 :Mixin, "image_util/filter/_mixin"
+  end
+end

data/lib/image_util/image/buffer.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Silence a warning.
+Warning[:experimental] = false
+
+module ImageUtil
+  class Image
+    class Buffer
+      def initialize(dimensions, color_bits, color_length, buffer = nil)
+        @color_type = case color_bits
+                      when 8
+                        :U8
+                      when 16
+                        :u16
+                      when 32
+                        :u32
+                      else
+                        raise ArgumentError, "wrong color bits provided: #{color_bits.inspect}"
+                      end
+
+        @dimensions = dimensions.freeze
+        @color_bits = color_bits
+        @color_bytes = color_bits / 8
+        @color_length = color_length
+
+        @buffer_size = @dimensions.reduce(&:*)
+        @buffer_size *= @color_length
+        @buffer_size *= @color_bytes
+
+        @io_buffer_types = ([@color_type]*@color_length).freeze
+
+        @buffer = buffer || IO::Buffer.new(@buffer_size)
+
+        apply_singleton_optimizations!
+
+        freeze
+      end
+
+      attr_reader :dimensions, :color_bits, :color_bytes, :color_length
+
+      def offset_of(*location)
+        location.length == @dimensions.length or raise ArgumentError, "wrong number of dimensions"
+
+        offset = 0
+        location.reverse.zip(@dimensions.reverse) do |i,max|
+          offset *= max
+          offset += i
+        end
+
+        offset * pixel_bytes
+      end
+
+      def pixel_bytes = @color_length * @color_bytes
+
+      def initialize_copy(_other)
+        @buffer = @buffer.dup
+      end
+
+      def get(location)
+        get_index(offset_of(*location))
+      end
+
+      def get_index(index)
+        value = @buffer.get_values(@io_buffer_types, index)
+        Color.from_buffer(value, @color_bits)
+      end
+
+      def set(location, value)
+        set_index(offset_of(*location), value)
+      end
+
+      def set_index(index, value)
+        value = Color.from(value).to_buffer(@color_bits, @color_length)
+        @buffer.set_values(@io_buffer_types, index, value)
+      end
+
+      def last_dimension(i)
+        dimensions_without_last = dimensions[0..-2]
+        remaining_dimensions = dimensions_without_last.length
+        o0 = offset_of(*[0] * remaining_dimensions, i)
+        o1 = offset_of(*[0] * remaining_dimensions, i + 1)
+        Buffer.new(
+          dimensions_without_last,
+          @color_bits,
+          @color_length,
+          @buffer.slice(o0, o1 - o0)
+        )
+      end
+
+      def last_dimension_split
+        dimensions.last.times.map do |i|
+          last_dimension(i)
+        end
+      end
+
+      def get_string = @buffer.get_string
+
+      def io_buffer = @buffer
+
+      def copy_1d(other, *location)
+        index = offset_of(*location)
+        length = [other.width, width - location.first].min
+        return if length <= 0
+
+        @buffer.copy(other.io_buffer, index, length * pixel_bytes)
+      end
+
+      # Optimizations for most common usecases:
+      def apply_singleton_optimizations!
+        # rubocop:disable Style/GuardClause
+        if OPT_OFFSET_OF.key?(@dimensions.length)
+          singleton_class.define_method(:offset_of, &OPT_OFFSET_OF[@dimensions.length])
+        end
+
+        if OPT_GET_INDEX.key?(@color_bits)
+          singleton_class.define_method(:get_index, &OPT_GET_INDEX[@color_bits])
+        end
+        # rubocop:enable Style/GuardClause
+      end
+
+      def width = dimensions[0]
+
+      OPT_OFFSET_OF = {
+        1 => ->(x) { x * pixel_bytes },
+        2 => ->(x,y) { (y * width + x) * pixel_bytes }
+      }.freeze
+
+      OPT_GET_INDEX = {
+        8 => ->(index) { Color.new(*@buffer.get_values(@io_buffer_types, index)) }
+      }.freeze
+    end
+  end
+end

data/lib/image_util/image.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  class Image
+    autoload :Buffer, "image_util/image/buffer"
+    autoload :PixelView, "image_util/image/pixel_view"
+
+    Util.irb_fixup
+
+    ALL = nil..nil
+
+    def initialize(*dimensions, color_bits: 8, color_length: 4, &block)
+      @buf = Buffer.new(dimensions, color_bits, color_length)
+
+      set_each_pixel_by_location(&block) if block_given?
+    end
+
+    def initialize_from_buffer(buffer)
+      @buf = buffer
+    end
+
+    def initialize_copy(_other)
+      @buf = @buf.dup
+    end
+
+    def self.from_buffer(...)
+      allocate.tap { |i| i.initialize_from_buffer(...) }
+    end
+
+    def self.from_string(data, format = nil, codec: nil, **kwargs)
+      format ||= Codec.detect(data)
+      raise ArgumentError, "could not detect format" unless format
+
+      Codec.decode(format, data, codec: codec, **kwargs)
+    end
+
+    def self.from_file(path_or_io, format = nil, codec: nil, **kwargs)
+      if format
+        if path_or_io.respond_to?(:read)
+          path_or_io.binmode if path_or_io.respond_to?(:binmode)
+          Codec.decode_io(format, path_or_io, codec: codec, **kwargs)
+        else
+          File.open(path_or_io, "rb") do |io|
+            Codec.decode_io(format, io, codec: codec, **kwargs)
+          end
+        end
+      elsif path_or_io.respond_to?(:read)
+        path_or_io.binmode if path_or_io.respond_to?(:binmode)
+        fmt, io = Magic.detect_io(path_or_io)
+        raise ArgumentError, "could not detect format" unless fmt
+
+        Codec.decode_io(fmt, io, codec: codec, **kwargs)
+      else
+        File.open(path_or_io, "rb") do |io|
+          fmt, io = Magic.detect_io(io)
+          raise ArgumentError, "could not detect format" unless fmt
+
+          Codec.decode_io(fmt, io, codec: codec, **kwargs)
+        end
+      end
+    end
+
+    def buffer = @buf
+    def dimensions = @buf.dimensions
+    def width = dimensions[0]
+    def height = dimensions[1]
+    def length = dimensions[2]
+    def color_bits = @buf.color_bits
+    def color_length = @buf.color_length
+    def pixel_bytes = @buf.pixel_bytes
+
+    def location_expand(location)
+      counts = []
+
+      location = location.reverse.map.with_index do |i,idx|
+        if i.is_a?(Range) && i.begin == nil
+          i = Range.new(0, i.end, i.exclude_end?)
+        end
+        if i.is_a?(Range) && i.end == nil
+          i = Range.new(i.begin, dimensions[-idx-1]-1, false)
+        end
+
+        i = i.to_i if i.is_a? Float
+
+        i = Array(i)
+
+        counts << i.count
+
+        i
+      end
+
+      [counts.reverse, location.shift.product(*location).map(&:reverse)]
+    end
+
+    def check_bounds!(location)
+      location.each_with_index do |i,idx|
+        if i < 0 || i >= dimensions[idx]
+          raise IndexError, "out of bounds image access (#{location.inspect} exceeds #{dimensions.inspect})"
+        end
+      end
+    end
+
+    def [](*location)
+      if location.all?(Numeric)
+        location = location.map(&:to_i)
+        check_bounds!(location)
+        @buf.get(location)
+      else
+        new_dimensions, locations = location_expand(location)
+        new_image = Image.new(*new_dimensions, 
+                              color_bits: color_bits,
+                              color_length: color_length)
+
+        locations.each_with_index do |i, idx|
+          new_image.buffer.set_index(idx * @buf.pixel_bytes, @buf.get(i))
+        end
+
+        new_image
+      end
+    end
+
+    def full_image_location = [ALL]*dimensions.length
+
+    def all=(value)
+      self[*full_image_location] = value
+    end
+
+    def []=(*location, value)
+      if location.all?(Numeric)
+        case value
+        when Image
+          paste!(value, *location)
+        else
+          location = location.map(&:to_i)
+          check_bounds!(location)
+          @buf.set(location, value)
+        end
+      else
+        _, locations = location_expand(location)
+        locations.each do |loc|
+          self[*loc] = value
+        end
+      end
+    end
+
+    def to_a
+      if dimensions.length == 1
+        dimensions.first.times.map { |i| self[i] }
+      else
+        @buf.last_dimension_split.map { |i| Image.from_buffer(i) }
+      end
+    end
+
+    def deep_to_a
+      to_a.map do |i|
+        case i
+        when Image
+          i.deep_to_a
+        else
+          i
+        end
+      end
+    end
+
+    def each(...)
+      to_a.each(...)
+    end
+  
+    include Enumerable
+    include Filter::Dither
+    include Filter::Background
+    include Filter::Paste
+    include Filter::Draw
+    include Filter::Resize
+    include Statistic::Color
+
+    def length = dimensions.last
+
+    def to_pam(fill_to: nil)
+      Codec.encode(:pam, self, fill_to: fill_to)
+    end
+
+    def to_string(format, codec: nil, **kwargs)
+      Codec.encode(format, self, codec: codec, **kwargs)
+    end
+
+    def to_file(path_or_io, format, codec: nil, **kwargs)
+      if path_or_io.respond_to?(:write)
+        path_or_io.binmode if path_or_io.respond_to?(:binmode)
+        Codec.encode_io(format, self, path_or_io, codec: codec, **kwargs)
+      else
+        File.open(path_or_io, "wb") do |io|
+          Codec.encode_io(format, self, io, codec: codec, **kwargs)
+        end
+      end
+    end
+
+    def to_sixel
+      Codec.encode(:sixel, self)
+    end
+
+    alias inspect to_sixel
+    
+    def pretty_print(p)
+      p.flush
+      p.output << to_sixel
+      p.text("", 0)
+    end
+
+    def pixel_count(locations) = location_expand(locations).first.reduce(:*)
+
+    def each_pixel_location(locations = full_image_location, ...)
+      location_expand(locations).last.each(...)
+    end
+
+    def each_pixel(locations = full_image_location)
+      return enum_for(:each_pixel) { pixel_count(locations) } unless block_given?
+
+      each_pixel_location(locations) do |location|
+        yield self[*location]
+      end
+    end
+
+    def set_each_pixel_by_location(locations = full_image_location)
+      return enum_for(:set_each_pixel_by_location) { pixel_count(locations) } unless block_given?
+
+      each_pixel_location(locations) do |location|
+        value = yield location
+        self[*location] = value if value
+      end
+    end
+
+    def view(obj)
+      if block_given?
+        yield obj.new(self)
+        self
+      else
+        obj.new(self)
+      end
+    end
+  end
+end

data/lib/image_util/magic.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module ImageUtil
+  module Magic
+    MAGIC_NUMBERS = {
+      pam: "P7\n".b,
+      png: "\x89PNG\r\n\x1a\n".b,
+      jpeg: "\xFF\xD8".b
+    }.freeze
+
+    BYTES_NEEDED = MAGIC_NUMBERS.values.map(&:bytesize).max
+
+    module_function
+
+    def bytes_needed = BYTES_NEEDED
+
+    def detect(data)
+      return nil unless data
+
+      MAGIC_NUMBERS.each do |fmt, magic|
+        return fmt if data.start_with?(magic)
+        crlf_magic = magic.gsub("\n", "\r\n")
+        return fmt if crlf_magic != magic && data.start_with?(crlf_magic)
+      end
+      nil
+    end
+
+    def detect_io(io)
+      
+      pos = io.pos
+      data = io.read(BYTES_NEEDED)
+      io.seek(pos)
+      [detect(data), io]
+    rescue Errno::ESPIPE, IOError
+      data = io.read(BYTES_NEEDED)
+      fmt = detect(data)
+      rest = io.read
+      new_io = StringIO.new((data || "") + (rest || ""))
+      [fmt, new_io]
+      
+    end
+  end
+end

data/lib/image_util/statistic/color.rb

@@ -0,0 +1,9 @@
+module ImageUtil
+  module Statistic
+    module Color
+      def histogram = each_pixel.to_a.tally
+      def unique_colors = histogram.keys
+      def unique_color_count = unique_colors.length
+    end
+  end
+end

data/lib/image_util/statistic.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Statistic
+    autoload :Color, "image_util/statistic/color"
+  end
+end