image_util 0.2.0 → 0.3.0

data/lib/image_util/codec/image_magick.rb

@@ -3,7 +3,7 @@
 module ImageUtil
   module Codec
     module ImageMagick
-      SUPPORTED_FORMATS = %i[sixel jpeg png].freeze
+      SUPPORTED_FORMATS = %i[sixel jpeg png gif apng].freeze
 
       extend Guard
 
@@ -15,43 +15,101 @@ module ImageUtil
         @magick_available = system("magick", "-version", out: File::NULL, err: File::NULL)
       end
 
-      def supported?(format = nil)
+      # Some codecs, like APNG won't work on Windows :(
+      def win_platform? = Gem.win_platform?
+
+      def magick_formats
+        return @magick_formats if defined?(@magick_formats)
+
+        out = IO.popen(%w[magick -list format], &:read)
+        @magick_formats = out.lines.filter_map do |line|
+          next unless line.start_with?(" ")
+
+          fmt = line[0,9].gsub(" ", "").downcase
+          fmt.empty? ? nil : fmt
+
+          next unless fmt
+
+          [fmt, line[21,2]]
+        end.to_h
+        @magick_formats
+      rescue StandardError
+        @magick_formats = {}
+      end
+
+      def supported?(format = nil, direction = "rw")
         return false unless magick_available?
 
         return true if format.nil?
 
-        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+        return false if win_platform? && format == :apng
+
+        fmt = format.to_s.downcase
+        SUPPORTED_FORMATS.include?(fmt.to_sym) && magick_formats.key?(fmt) &&
+          magick_formats[fmt].include?(direction.to_s)
       end
 
       def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
 
         fmt = format.to_s.downcase
-        pam = Codec::Pam.encode(:pam, image, fill_to: fmt == "sixel" ? 6 : nil)
 
-        IO.popen(["magick", "pam:-", "#{fmt}:-"], "r+") do |proc_io|
-          proc_io << pam
-          proc_io.close_write
-          proc_io.read
-        end
-      end
+        if image.dimensions.length <= 2 || fmt == "sixel"
+          img = image
+          if img.dimensions.length == 1
+            img = img.redimension(img.width, 1)
+          end
+          if fmt == "sixel"
+            pad = (6 - (img.height % 6)) % 6
+            img = img.redimension(img.width, img.height + pad) if pad > 0
+          end
+          pam = Codec::Pam.encode(:pam, img)
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
+          IO.popen(["magick", "pam:-", "#{fmt}:-"], "r+b") do |proc_io|
+            proc_io << pam
+            proc_io.close_write
+            proc_io.read
+          end
+        else
+          frames = image.buffer.last_dimension_split.map { |b| Image.from_buffer(b) }
+          stream = frames.map { |f| Codec::Pam.encode(:pam, f) }.join
+          IO.popen(["magick", "pam:-", "#{fmt}:-"], "r+b") do |proc_io|
+            proc_io << stream
+            proc_io.close_write
+            proc_io.read
+          end
+        end
       end
 
       def decode(format, data)
         guard_supported_format!(format, SUPPORTED_FORMATS)
 
-        IO.popen(["magick", "#{format}:-", "pam:-"], "r+") do |proc_io|
+        cmd = ["magick", "#{format}:-"]
+        cmd << "-coalesce" if %i[gif apng].include?(format.to_s.downcase.to_sym)
+        cmd += ["-depth", "8", "pam:-"]
+        IO.popen(cmd, "r+b") do |proc_io|
           proc_io << data
           proc_io.close_write
-          Pam.decode(:pam, proc_io.read)
-        end
-      end
 
-      def decode_io(format, io)
-        decode(format, io.read)
+          frames = []
+          while (frame = Codec::Pam.decode_frame(proc_io))
+            frames << frame
+          end
+
+          if frames.length == 1
+            frames.first
+          else
+            first = frames.first
+            img = Image.new(first.width, first.height, frames.length,
+                            color_bits: first.color_bits, channels: first.channels)
+            frames.each_with_index do |frame, idx|
+              offset = img.buffer.offset_of(0, 0, idx)
+              bytes = frame.width * frame.height * frame.pixel_bytes
+              img.buffer.io_buffer.copy(frame.buffer.io_buffer, offset, bytes)
+            end
+            img
+          end
+        end
       end
     end
   end

data/lib/image_util/codec/kitty.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ImageUtil
+  module Codec
+    module Kitty
+      SUPPORTED_FORMATS = [:kitty].freeze
+
+      extend Guard
+
+      module_function
+
+      def supported?(format = nil)
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      # Kitty format supports more options:
+      # https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference
+      def encode(format, image, options: nil)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        guard_image_class!(image)
+        guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
+
+        img = image
+        img = img.redimension(img.width, 1) if img.dimensions.length == 1
+
+        bits = img.pixel_bytes * 8
+        width = img.width
+        height = img.height
+
+        rest = Base64.strict_encode64(img.buffer.get_string)
+
+        first = true
+
+        out = +""
+
+        options ||= begin
+          opts = {}
+          opts[:a] = "T" # immediately display
+          opts[:q] = 2   # don't report anything
+          opts
+        end
+
+        loop do
+          payload, rest = rest[...4096], rest[4096..] # rubocop:disable Style/ParallelAssignment
+
+          opts = {}
+
+          if first
+            opts = opts.merge(options)
+            opts[:f] = bits
+            opts[:s] = width
+            opts[:v] = height
+            opts[:m] = 1 if rest
+          elsif rest
+            opts[:m] = 1
+          else
+            opts[:m] = 0
+          end
+
+          opts = opts.map { |k,v| "#{k}=#{v}" }.join(",")
+            
+          out << "\e_G#{opts};#{payload}\e\\".b
+
+          first = false
+          break unless rest
+        end
+
+        out
+      end
+
+      def decode(*)
+        raise UnsupportedFormatError, "decode not supported for sixel"
+      end
+    end
+  end
+end

data/lib/image_util/codec/libpng.rb

@@ -69,7 +69,7 @@ module ImageUtil
         guard_2d_image!(image)
         guard_8bit_colors!(image)
 
-        fmt = if image.color_length == 4
+        fmt = if image.channels == 4
                 PNG_FORMAT_RGBA
               else
                 PNG_FORMAT_RGB
@@ -83,7 +83,7 @@ module ImageUtil
         img[:flags] = 0
         img[:colormap_entries] = 0
 
-        row_stride = image.width * image.color_length
+        row_stride = image.width * image.channels
         buffer_ptr = FFI::MemoryPointer.from_string(image.buffer.get_string)
         size_ptr = FFI::MemoryPointer.new(:size_t)
 
@@ -100,10 +100,6 @@ module ImageUtil
         png_image_free(img) if img
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(format, data)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libpng not available" unless AVAILABLE
@@ -129,10 +125,6 @@ module ImageUtil
       ensure
         png_image_free(img) if img
       end
-
-      def decode_io(format, io)
-        decode(format, io.read)
-      end
     end
   end
 end

data/lib/image_util/codec/libsixel.rb

@@ -56,10 +56,18 @@ module ImageUtil
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libsixel not available" unless AVAILABLE
 
-        guard_2d_image!(image)
+        guard_image_class!(image)
         guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
 
-        fmt = image.color_length == 4 ? SIXEL_PIXELFORMAT_RGBA8888 : SIXEL_PIXELFORMAT_RGB888
+        img = image
+        if img.dimensions.length == 1
+          img = img.redimension(img.width, 1)
+        end
+        pad = (6 - (img.height % 6)) % 6
+        img = img.redimension(img.width, img.height + pad) if pad > 0
+
+        fmt = img.channels == 4 ? SIXEL_PIXELFORMAT_RGBA8888 : SIXEL_PIXELFORMAT_RGB888
 
         data = "".b
         writer = FFI::Function.new(:int, %i[pointer int pointer]) do |ptr, size, _|
@@ -79,15 +87,15 @@ module ImageUtil
 
         dither = dither_ptr.read_pointer
 
-        pixels = image.buffer.get_string
+        pixels = img.buffer.get_string
         buf_ptr = FFI::MemoryPointer.new(:uchar, pixels.bytesize)
         buf_ptr.put_bytes(0, pixels)
 
         res = sixel_dither_initialize(
           dither,
           buf_ptr,
-          image.width,
-          image.height,
+          img.width,
+          img.height,
           fmt,
           SIXEL_LARGE_AUTO,
           SIXEL_REP_AUTO,
@@ -97,7 +105,7 @@ module ImageUtil
 
         sixel_dither_set_diffusion_type(dither, SIXEL_DIFFUSE_AUTO)
 
-        res = sixel_encode(buf_ptr, image.width, image.height, fmt, dither, output)
+        res = sixel_encode(buf_ptr, img.width, img.height, fmt, dither, output)
         raise StandardError, "sixel_encode failed" if res != 0
 
         data
@@ -106,17 +114,9 @@ module ImageUtil
         sixel_output_unref(output) if defined?(output) && output && !output.null?
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(*)
         raise UnsupportedFormatError, "decode not supported for sixel"
       end
-
-      def decode_io(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
-      end
     end
   end
 end

data/lib/image_util/codec/libturbojpeg.rb

@@ -2,7 +2,6 @@
 
 module ImageUtil
   module Codec
-    # rubocop:disable Metrics/ModuleLength
     module Libturbojpeg
       SUPPORTED_FORMATS = [:jpeg].freeze
 
@@ -70,7 +69,7 @@ module ImageUtil
         guard_2d_image!(image)
         guard_8bit_colors!(image)
 
-        fmt = image.color_length == 4 ? TJPF_RGBA : TJPF_RGB
+        fmt = image.channels == 4 ? TJPF_RGBA : TJPF_RGB
 
         handle = tjInitCompress
         raise StandardError, "tjInitCompress failed" if handle.null?
@@ -91,10 +90,6 @@ module ImageUtil
         tjDestroy(handle) if handle && !handle.null?
       end
 
-      def encode_io(format, image, io, **kwargs)
-        io << encode(format, image, **kwargs)
-      end
-
       def decode(format, data)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libturbojpeg not available" unless AVAILABLE
@@ -131,11 +126,6 @@ module ImageUtil
       ensure
         tjDestroy(handle) if handle && !handle.null?
       end
-
-      def decode_io(format, io)
-        decode(format, io.read)
-      end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/image_util/codec/pam.rb

@@ -17,40 +17,29 @@ module ImageUtil
         SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
       end
 
-      def encode(format, image, fill_to: nil)
+      def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         unless image.dimensions.length <= 2
           raise ArgumentError, "can't convert to PAM more than 2 dimensions"
         end
 
-        unless [3, 4].include?(image.color_length)
+        unless [3, 4].include?(image.channels)
           raise ArgumentError, "can't convert to PAM if color length isn't 3 or 4"
         end
 
-        fill_height = image.height || 1
-        fill_buffer = "".b
-        if fill_to
-          remaining = fill_height % fill_to
-          added = remaining.zero? ? 0 : fill_to - remaining
-          fill_height += added
-          fill_buffer = "\0".b * added * image.pixel_bytes * image.width
-        end
+        height = image.height || 1
 
         header = <<~PAM.b
           P7
           WIDTH #{image.width}
-          HEIGHT #{fill_height}
-          DEPTH #{image.color_length}
+          HEIGHT #{height}
+          DEPTH #{image.channels}
           MAXVAL #{2**image.color_bits - 1}
-          TUPLTYPE #{image.color_length == 3 ? "RGB" : "RGB_ALPHA"}
+          TUPLTYPE #{image.channels == 3 ? "RGB" : "RGB_ALPHA"}
           ENDHDR
         PAM
 
-        header + image.buffer.get_string + fill_buffer
-      end
-
-      def encode_io(format, image, io, **kwargs)
-        io << encode(format, image, **kwargs)
+        header + image.buffer.get_string
       end
 
       def decode(format, data)
@@ -62,20 +51,33 @@ module ImageUtil
       def decode_io(format, io)
         guard_supported_format!(format, SUPPORTED_FORMATS)
 
+        decode_frame(io)
+      end
+
+      def decode_frame(io)
         header = {}
-        while (line = io.gets)
-          line = line.chomp
-          break if line == "ENDHDR"
+        line = io.gets&.chomp
+        return nil unless line
+
+        line = io.gets&.chomp
+        return nil unless line
 
+        until line.chomp == "ENDHDR"
           key, val = line.split(" ", 2)
           header[key] = val
+          line = io.gets&.chomp
+          return nil unless line
         end
+
         width = header["WIDTH"].to_i
         height = header["HEIGHT"].to_i
         depth = header["DEPTH"].to_i
         maxval = header["MAXVAL"].to_i
         color_bits = Math.log2(maxval + 1).to_i
-        raw = io.read
+        bytes = width * height * depth * (color_bits / 8)
+        raw = io.read(bytes)
+        return nil unless raw && raw.bytesize == bytes
+
         io_buf = IO::Buffer.for(raw)
         buf = Image::Buffer.new([width, height], color_bits, depth, io_buf)
         Image.from_buffer(buf)

data/lib/image_util/codec/ruby_sixel.rb

@@ -18,13 +18,20 @@ module ImageUtil
 
       def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
-        guard_2d_image!(image)
+        guard_image_class!(image)
         guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
 
-        img = if image.unique_color_count <= 256
-                image
+        img = image
+        if img.dimensions.length == 1
+          img = img.redimension(img.width, 1)
+        end
+        pad = (6 - (img.height % 6)) % 6
+        img = img.redimension(img.width, img.height + pad) if pad > 0
+        img = if img.unique_color_count <= 256
+                img
               else
-                image.dither(256)
+                img.palette_reduce(256)
               end
 
         height = img.height || 1
@@ -100,17 +107,9 @@ module ImageUtil
         out
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(*)
         raise UnsupportedFormatError, "decode not supported for sixel"
       end
-
-      def decode_io(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
-      end
     end
   end
 end

data/lib/image_util/codec.rb

@@ -101,17 +101,21 @@ module ImageUtil
     autoload :Guard, "image_util/codec/_guard"
 
     autoload :Libpng, "image_util/codec/libpng"
+    autoload :ChunkyPng, "image_util/codec/chunky_png"
     autoload :Libturbojpeg, "image_util/codec/libturbojpeg"
     autoload :Pam, "image_util/codec/pam"
     autoload :Libsixel, "image_util/codec/libsixel"
     autoload :ImageMagick, "image_util/codec/image_magick"
     autoload :RubySixel, "image_util/codec/ruby_sixel"
+    autoload :Kitty, "image_util/codec/kitty"
 
     register_codec :Pam, :pam
+    register_codec :Kitty, :kitty
     register_codec :Libpng, :png
     register_codec :Libturbojpeg, :jpeg
     register_encoder :Libsixel, :sixel
-    register_codec :ImageMagick, :png, :jpeg, :sixel
+    register_codec :ImageMagick, :png, :jpeg, :sixel, :gif, :apng
+    register_codec :ChunkyPng, :png
     register_encoder :RubySixel, :sixel
   end
 end

data/lib/image_util/color/css_colors.rb

@@ -151,6 +151,8 @@ module ImageUtil
       "yellow" => [255, 255, 0],
       "yellowgreen" => [154, 205, 50],
       "rebeccapurple" => [102, 51, 153]
-    }.freeze
+    }.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

@@ -41,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
@@ -49,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
@@ -71,15 +109,19 @@ module ImageUtil
         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))
         else
-          if (rgb = CSS_COLORS[value.downcase])
+          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