image_util 0.1.0 → 0.3.0

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

data/lib/image_util/image.rb

@@ -3,16 +3,15 @@
 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)
+    def initialize(*dimensions, color_bits: 8, channels: 4, &block)
+      @buf = Buffer.new(dimensions, color_bits, channels)
 
-      set_each_pixel_by_location(&block) if block_given?
+      set_each_pixel_by_location!(&block) if block_given?
     end
 
     def initialize_from_buffer(buffer)
@@ -66,10 +65,10 @@ module ImageUtil
     def height = dimensions[1]
     def length = dimensions[2]
     def color_bits = @buf.color_bits
-    def color_length = @buf.color_length
+    def channels = @buf.channels
     def pixel_bytes = @buf.pixel_bytes
 
-    def location_expand(location)
+    def location_expand(location = full_image_location)
       counts = []
 
       location = location.reverse.map.with_index do |i,idx|
@@ -109,10 +108,10 @@ module ImageUtil
         new_dimensions, locations = location_expand(location)
         new_image = Image.new(*new_dimensions, 
                               color_bits: color_bits,
-                              color_length: color_length)
+                              channels: channels)
 
         locations.each_with_index do |i, idx|
-          new_image.buffer.set_index(idx * @buf.pixel_bytes, @buf.get(i))
+          new_image.buffer.set_index(idx * pixel_bytes, @buf.get(i))
         end
 
         new_image
@@ -136,9 +135,11 @@ module ImageUtil
           @buf.set(location, value)
         end
       else
-        _, locations = location_expand(location)
-        locations.each do |loc|
-          self[*loc] = value
+        sizes, locations = location_expand(location)
+        if value.is_a?(Image)
+          paste!(value.resize(*sizes), *locations.first)
+        else
+          locations.each { |loc| self[*loc] = value }
         end
       end
     end
@@ -167,28 +168,39 @@ module ImageUtil
     end
   
     include Enumerable
-    include Filter::Dither
+    include Filter::Palette
     include Filter::Background
     include Filter::Paste
     include Filter::Draw
     include Filter::Resize
-    include Statistic::Color
+    include Filter::Transform
+    include Filter::Redimension
+    include Filter::Colors
+    include Filter::BitmapText
+    include Statistic::Colors
+    extend Generator::BitmapText
+    extend Generator::Example
 
     def length = dimensions.last
 
-    def to_pam(fill_to: nil)
-      Codec.encode(:pam, self, fill_to: fill_to)
+    def to_pam
+      Codec.encode(:pam, self)
     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)
+    def to_file(path_or_io, format = nil, codec: nil, **kwargs)
       if path_or_io.respond_to?(:write)
+        raise ArgumentError, "format required" unless format
+
         path_or_io.binmode if path_or_io.respond_to?(:binmode)
         Codec.encode_io(format, self, path_or_io, codec: codec, **kwargs)
       else
+        format ||= Extension.detect(path_or_io)
+        raise ArgumentError, "could not detect format" unless format
+
         File.open(path_or_io, "wb") do |io|
           Codec.encode_io(format, self, io, codec: codec, **kwargs)
         end
@@ -199,12 +211,14 @@ module ImageUtil
       Codec.encode(:sixel, self)
     end
 
-    alias inspect to_sixel
-    
     def pretty_print(p)
-      p.flush
-      p.output << to_sixel
-      p.text("", 0)
+      if (image = Terminal.output_image($stdin, $stdout, self))
+        p.flush
+        p.output << image
+        p.text("", 0)
+      else
+        super
+      end
     end
 
     def pixel_count(locations) = location_expand(locations).first.reduce(:*)
@@ -221,12 +235,26 @@ module ImageUtil
       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?
+    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
+      if locations == full_image_location
+        # Optimized path
+        pixels, locations = location_expand
+
+        iter = 0
+        pixels = pixels.reduce(:*)
+  
+        while iter < pixels
+          value = yield locations[iter]
+          buffer.set_index(iter * pixel_bytes, value) if value
+          iter += 1
+        end
+      else
+        each_pixel_location(locations) do |location|
+          value = yield location
+          self[*location] = value if value
+        end
       end
     end
 

data/lib/image_util/magic.rb

@@ -7,7 +7,8 @@ module ImageUtil
     MAGIC_NUMBERS = {
       pam: "P7\n".b,
       png: "\x89PNG\r\n\x1a\n".b,
-      jpeg: "\xFF\xD8".b
+      jpeg: "\xFF\xD8".b,
+      gif: "GIF8".b
     }.freeze
 
     BYTES_NEEDED = MAGIC_NUMBERS.values.map(&:bytesize).max
@@ -19,16 +20,18 @@ module ImageUtil
     def detect(data)
       return nil unless data
 
+      if data.start_with?(MAGIC_NUMBERS[:png]) && data.byteslice(0, 256).include?("acTL")
+        return :apng
+      end
+
       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)
-      
+    def detect_io(io)      
       pos = io.pos
       data = io.read(BYTES_NEEDED)
       io.seek(pos)
@@ -39,7 +42,6 @@ module ImageUtil
       rest = io.read
       new_io = StringIO.new((data || "") + (rest || ""))
       [fmt, new_io]
-      
     end
   end
 end

data/lib/image_util/statistic/{color.rb → colors.rb}

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

data/lib/image_util/statistic.rb

@@ -2,6 +2,6 @@
 
 module ImageUtil
   module Statistic
-    autoload :Color, "image_util/statistic/color"
+    autoload :Colors, "image_util/statistic/colors"
   end
 end

data/lib/image_util/terminal.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module ImageUtil
+  module Terminal
+    module_function
+
+    def detect_support(termin = $stdin, termout = $stdout)
+      return [] if !termin.tty? || !termout.tty?
+      
+      supported = termout.instance_variable_get(:@imageutil_support_cache)
+      return supported if supported
+
+      supported = [:tty]
+
+      # Send kitty query
+      query_terminal(termin, termout, "\e_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\e\\\e[c".b) do |resp|
+        resp.start_with?("\e_G".b) && resp.include?("OK".b)
+      end and supported << :kitty
+
+      # Send sixel query
+      query_terminal(termin, termout, "\e[0c".b) do |resp|
+        resp.include?(";4".b)
+      end and supported << :sixel
+
+      termout.instance_variable_set(:@imageutil_support_cache, supported)
+    end
+
+    def query_terminal(termin, termout, query, timeout = 0.2)
+      resp = ""
+      termin.raw do
+        termout.write query
+        termout.flush
+        t0 = Time.now
+        loop do
+          begin
+            resp += termin.read_nonblock(512)
+            break if resp.start_with?("\e".b)
+          rescue IO::WaitReadable
+            IO.select([termin], nil, nil, timeout)
+          end
+          break if Time.now - t0 > timeout
+        end
+      end
+      yield resp
+    rescue EOFError, Errno::EBADF
+      false
+    end
+
+    def output_image(termin, termout, image)
+      support = detect_support(termin, termout)
+
+      if support.include? :kitty
+        image.to_string(:kitty)
+      elsif support.include? :sixel
+        image.to_string(:sixel)
+      end
+    end
+  end
+end

data/lib/image_util/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ImageUtil
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/image_util/view/interpolated.rb

@@ -24,7 +24,7 @@ module ImageUtil
       end
 
       def [](*location)
-        accum = Array.new(image.color_length, 0.0)
+        accum = Array.new(image.channels, 0.0)
         generate_subpixel_hash(location).each do |loc, weight|
           image[*loc].each_with_index do |val, idx|
             accum[idx] += val * weight

data/lib/image_util.rb

@@ -6,12 +6,18 @@ module ImageUtil
   class Error < StandardError; end
   # Your code goes here...
 
+  autoload :BitmapFont, "image_util/bitmap_font"
   autoload :Color, "image_util/color"
   autoload :Image, "image_util/image"
   autoload :Util, "image_util/util"
   autoload :Codec, "image_util/codec"
   autoload :Magic, "image_util/magic"
+  autoload :Extension, "image_util/extension"
   autoload :Filter, "image_util/filter"
+  autoload :Generator, "image_util/generator"
   autoload :Statistic, "image_util/statistic"
+  autoload :Terminal, "image_util/terminal"
   autoload :View, "image_util/view"
+  autoload :CLI, "image_util/cli"
+  autoload :Benchmarking, "image_util/benchmarking"
 end