image_util 0.2.0 → 0.3.0

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
@@ -169,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
@@ -201,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(:*)
@@ -223,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.2.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: image_util
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - hmdne
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  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: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -23,11 +37,40 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: io-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: Lightweight Color and Image classes for manipulating pixels. Provides
   SIXEL output plus FFI bindings for libpng, libturbojpeg and libsixel.
 email:
 - 54514036+hmdne@users.noreply.github.com
-executables: []
+executables:
+- image_util
 extensions: []
 extra_rdoc_files: []
 files:
@@ -38,16 +81,34 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/cli.md
 - docs/samples/background.png
+- docs/samples/bitmap_text.png
+- docs/samples/colors.png
+- docs/samples/constructor.png
 - docs/samples/dither.png
 - docs/samples/draw.png
+- docs/samples/iterator.png
 - docs/samples/paste.png
+- docs/samples/pdither.png
+- docs/samples/pipe.png
+- docs/samples/range.png
+- docs/samples/redimension.png
 - docs/samples/resize.png
 - docs/samples/sixel.png
+- docs/samples/transform.png
+- exe/image_util
 - lib/image_util.rb
+- lib/image_util/benchmarking.rb
+- lib/image_util/bitmap_font.rb
+- lib/image_util/bitmap_font/fonts/smfont/charset.txt
+- lib/image_util/bitmap_font/fonts/smfont/font.png
+- lib/image_util/cli.rb
 - lib/image_util/codec.rb
 - lib/image_util/codec/_guard.rb
+- lib/image_util/codec/chunky_png.rb
 - lib/image_util/codec/image_magick.rb
+- lib/image_util/codec/kitty.rb
 - lib/image_util/codec/libpng.rb
 - lib/image_util/codec/libsixel.rb
 - lib/image_util/codec/libturbojpeg.rb
@@ -55,18 +116,28 @@ files:
 - lib/image_util/codec/ruby_sixel.rb
 - lib/image_util/color.rb
 - lib/image_util/color/css_colors.rb
+- lib/image_util/extension.rb
 - lib/image_util/filter.rb
 - lib/image_util/filter/_mixin.rb
 - lib/image_util/filter/background.rb
-- lib/image_util/filter/dither.rb
+- lib/image_util/filter/bitmap_text.rb
+- lib/image_util/filter/colors.rb
 - lib/image_util/filter/draw.rb
+- lib/image_util/filter/palette.rb
 - lib/image_util/filter/paste.rb
+- lib/image_util/filter/redimension.rb
 - lib/image_util/filter/resize.rb
+- lib/image_util/filter/transform.rb
+- lib/image_util/generator.rb
+- lib/image_util/generator/bitmap_text.rb
+- lib/image_util/generator/example.rb
+- lib/image_util/generator/example/rose.png
 - lib/image_util/image.rb
 - lib/image_util/image/buffer.rb
 - lib/image_util/magic.rb
 - lib/image_util/statistic.rb
-- lib/image_util/statistic/color.rb
+- lib/image_util/statistic/colors.rb
+- lib/image_util/terminal.rb
 - lib/image_util/util.rb
 - lib/image_util/version.rb
 - lib/image_util/view.rb

data/lib/image_util/filter/dither.rb

@@ -1,96 +0,0 @@
-# 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