image_util 0.1.0

data/lib/image_util/codec/libturbojpeg.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Codec
+    # rubocop:disable Metrics/ModuleLength
+    module Libturbojpeg
+      SUPPORTED_FORMATS = [:jpeg].freeze
+
+      extend Guard
+
+      begin
+        require "ffi"
+
+        extend FFI::Library
+        ffi_lib [
+          "libturbojpeg.so.0", # Linux
+          "libturbojpeg.so", "libturbojpeg", # generic
+          "turbojpeg.dll", "libturbojpeg.dll", # Windows
+          "libturbojpeg.dylib", "turbojpeg.dylib" # macOS
+        ]
+
+        AVAILABLE = true
+      rescue LoadError
+        AVAILABLE = false
+      end
+
+      TJPF_RGB  = 0
+      TJPF_RGBA = 7
+
+      if AVAILABLE
+        attach_function :tjInitCompress, [], :pointer
+        attach_function :tjInitDecompress, [], :pointer
+        attach_function :tjCompress2,
+                        %i[pointer pointer int int int int pointer pointer int int int],
+                        :int
+
+        begin
+          attach_function :tjDecompressHeader3,
+                          %i[pointer pointer ulong pointer pointer pointer pointer],
+                          :int
+          DECOMPRESS_HEADER_FUNC = :tjDecompressHeader3
+        rescue FFI::NotFoundError
+          attach_function :tjDecompressHeader2,
+                          %i[pointer pointer ulong pointer pointer pointer],
+                          :int
+          DECOMPRESS_HEADER_FUNC = :tjDecompressHeader2
+        end
+
+        attach_function :tjDecompress2,
+                        %i[pointer pointer ulong pointer int int int int int],
+                        :int
+        attach_function :tjDestroy, [:pointer], :int
+        attach_function :tjFree, [:pointer], :void
+      end
+
+      module_function
+
+      def supported?(format = nil)
+        return false unless AVAILABLE
+
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      def encode(format, image, quality: 75)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        raise UnsupportedFormatError, "libturbojpeg not available" unless AVAILABLE
+
+        guard_2d_image!(image)
+        guard_8bit_colors!(image)
+
+        fmt = image.color_length == 4 ? TJPF_RGBA : TJPF_RGB
+
+        handle = tjInitCompress
+        raise StandardError, "tjInitCompress failed" if handle.null?
+
+        src_ptr = FFI::MemoryPointer.from_string(image.buffer.get_string)
+        jpeg_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+        jpeg_size_ptr = FFI::MemoryPointer.new(:ulong)
+
+        res = tjCompress2(handle, src_ptr, image.width, 0, image.height, fmt, jpeg_ptr_ptr, jpeg_size_ptr, 0, quality, 0)
+        raise StandardError, "compression failed" if res != 0
+
+        jpeg_ptr = jpeg_ptr_ptr.read_pointer
+        jpeg_size = jpeg_size_ptr.read_ulong
+        data = jpeg_ptr.read_string(jpeg_size)
+        tjFree(jpeg_ptr)
+        data
+      ensure
+        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
+
+        handle = tjInitDecompress
+        raise StandardError, "tjInitDecompress failed" if handle.null?
+
+        jpeg_buf = FFI::MemoryPointer.from_string(data)
+        width_ptr = FFI::MemoryPointer.new(:int)
+        height_ptr = FFI::MemoryPointer.new(:int)
+        subsamp_ptr = FFI::MemoryPointer.new(:int)
+        cs_ptr = FFI::MemoryPointer.new(:int)
+
+        header_args = [handle, jpeg_buf, data.bytesize, width_ptr, height_ptr]
+        if DECOMPRESS_HEADER_FUNC == :tjDecompressHeader3
+          header_args += [subsamp_ptr, cs_ptr]
+        else
+          header_args << subsamp_ptr
+        end
+        res = public_send(DECOMPRESS_HEADER_FUNC, *header_args)
+        raise StandardError, "header decode failed" if res != 0
+
+        width = width_ptr.read_int
+        height = height_ptr.read_int
+
+        dst_ptr = FFI::MemoryPointer.new(:uchar, width * height * 4)
+        res = tjDecompress2(handle, jpeg_buf, data.bytesize, dst_ptr, width, 0, height, TJPF_RGBA, 0)
+        raise StandardError, "decompress failed" if res != 0
+
+        raw = dst_ptr.read_string(width * height * 4)
+        io_buf = IO::Buffer.for(raw)
+        buf = Image::Buffer.new([width, height], 8, 4, io_buf)
+        Image.from_buffer(buf)
+      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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module ImageUtil
+  module Codec
+    module Pam
+      SUPPORTED_FORMATS = [:pam].freeze
+
+      extend Guard
+
+      module_function
+
+      def supported?(format = nil)
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      def encode(format, image, fill_to: nil)
+        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)
+          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
+
+        header = <<~PAM.b
+          P7
+          WIDTH #{image.width}
+          HEIGHT #{fill_height}
+          DEPTH #{image.color_length}
+          MAXVAL #{2**image.color_bits - 1}
+          TUPLTYPE #{image.color_length == 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)
+      end
+
+      def decode(format, data)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+
+        decode_io(format, StringIO.new(data))
+      end
+
+      def decode_io(format, io)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+
+        header = {}
+        while (line = io.gets)
+          line = line.chomp
+          break if line == "ENDHDR"
+
+          key, val = line.split(" ", 2)
+          header[key] = val
+        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
+        io_buf = IO::Buffer.for(raw)
+        buf = Image::Buffer.new([width, height], color_bits, depth, io_buf)
+        Image.from_buffer(buf)
+      end
+    end
+  end
+end

data/lib/image_util/codec/ruby_sixel.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Codec
+    module RubySixel
+      SUPPORTED_FORMATS = [:sixel].freeze
+      CHAR_MAP = (0..63).map { |b| (63 + b).chr }.freeze
+
+      extend Guard
+
+      module_function
+
+      def supported?(format = nil)
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      def encode(format, image)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        guard_2d_image!(image)
+        guard_8bit_colors!(image)
+
+        img = if image.unique_color_count <= 256
+                image
+              else
+                image.dither(256)
+              end
+
+        height = img.height || 1
+        width = img.width || 1
+
+        palette = []
+        palette_map = {}
+        idx_image = Array.new(height * width)
+        buf = img.buffer
+        idx = 0
+        step = buf.pixel_bytes
+
+        height.times do |y|
+          row = y * width
+          width.times do |x|
+            color = buf.get_index(idx)
+            key = (color[0] || 255) |
+                  ((color[1] || 255) << 8) |
+                  ((color[2] || 255) << 16) |
+                  ((color[3] || 255) << 24)
+            pal_idx = palette_map[key]
+            unless pal_idx
+              pal_idx = palette.length
+              palette_map[key] = pal_idx
+              palette << color
+            end
+            idx_image[row + x] = pal_idx
+            idx += step
+          end
+        end
+
+        out = "\ePq".dup
+        palette.each_with_index do |c, idx|
+          out << format("#%d;2;%d;%d;%d", idx, c.r * 100 / 255, c.g * 100 / 255, c.b * 100 / 255)
+        end
+
+        (0...height).step(6) do |y|
+          palette.each_index do |idx|
+            out << "##{idx}"
+            run_char = nil
+            run_len = 0
+            x = 0
+            while x < width
+              bits = 0
+              yy = y
+              i = 0
+              while i < 6
+                if yy < height && idx_image[yy * width + x] == idx
+                  bits |= 1 << i
+                end
+                yy += 1
+                i += 1
+              end
+              char = CHAR_MAP[bits]
+              if char == run_char
+                run_len += 1
+              else
+                out << "!#{run_len}" << run_char if run_len > 1
+                out << run_char if run_len == 1
+                run_char = char
+                run_len = 1
+              end
+              x += 1
+            end
+            out << "!#{run_len}" << run_char if run_len > 1
+            out << run_char if run_len == 1
+            out << "$"
+          end
+          out << "-"
+        end
+
+        out << "\e\\"
+        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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Codec
+    class UnsupportedFormatError < Error; end
+
+    @encoders = []
+    @decoders = []
+
+    class << self
+      attr_reader :encoders, :decoders
+
+      def register_encoder(codec_const, *formats)
+        encoders << { codec: codec_const, formats: formats.map { |f| f.to_s.downcase } }
+      end
+
+      def register_decoder(codec_const, *formats)
+        decoders << { codec: codec_const, formats: formats.map { |f| f.to_s.downcase } }
+      end
+
+      def register_codec(codec_const, *formats)
+        register_encoder(codec_const, *formats)
+        register_decoder(codec_const, *formats)
+      end
+
+      def supported?(format)
+        fmt = format.to_s.downcase
+        encoders.any? { |r| r[:formats].include?(fmt) && codec_supported?(r[:codec], fmt) } ||
+          decoders.any? { |r| r[:formats].include?(fmt) && codec_supported?(r[:codec], fmt) }
+      end
+
+      def encode(format, image, codec: nil, **kwargs)
+        codec = find_codec(encoders, format, codec)
+        codec.encode(format, image, **kwargs)
+      end
+
+      def decode(format, data, codec: nil, **kwargs)
+        codec = find_codec(decoders, format, codec)
+        codec.decode(format, data, **kwargs)
+      end
+
+      def encode_io(format, image, io, codec: nil, **kwargs)
+        codec = find_codec(encoders, format, codec)
+        if codec.respond_to?(:encode_io)
+          codec.encode_io(format, image, io, **kwargs)
+        else
+          io << codec.encode(format, image, **kwargs)
+        end
+      end
+
+      def decode_io(format, io, codec: nil, **kwargs)
+        codec = find_codec(decoders, format, codec)
+        if codec.respond_to?(:decode_io)
+          codec.decode_io(format, io, **kwargs)
+        else
+          codec.decode(format, io.read, **kwargs)
+        end
+      end
+
+      def detect(data)
+        Magic.detect(data)
+      end
+
+      def detect_io(io)
+        Magic.detect_io(io).first
+      end
+
+      private
+
+      def find_codec(list, format, preferred = nil)
+        fmt = format.to_s.downcase
+        if preferred
+          r = list.find { |e| e[:formats].include?(fmt) && e[:codec].to_s == preferred.to_s }
+          raise UnsupportedFormatError, "unsupported format #{format}" unless r
+
+          codec = const_get(r[:codec])
+          unless !codec.respond_to?(:supported?) || codec.supported?(fmt.to_sym)
+            raise UnsupportedFormatError, "unsupported format #{format}"
+          end
+
+          return codec
+        end
+
+        list.each do |r|
+          next unless r[:formats].include?(fmt)
+
+          codec = const_get(r[:codec])
+          next if codec.respond_to?(:supported?) && !codec.supported?(fmt.to_sym)
+
+          return codec
+        end
+        raise UnsupportedFormatError, "unsupported format #{format}"
+      end
+
+      def codec_supported?(codec_const, fmt)
+        codec = const_get(codec_const)
+        !codec.respond_to?(:supported?) || codec.supported?(fmt.to_sym)
+      end
+    end
+
+    autoload :Guard, "image_util/codec/_guard"
+
+    autoload :Libpng, "image_util/codec/libpng"
+    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"
+
+    register_codec :Pam, :pam
+    register_codec :Libpng, :png
+    register_codec :Libturbojpeg, :jpeg
+    register_encoder :Libsixel, :sixel
+    register_encoder :ImageMagick, :sixel
+    register_encoder :RubySixel, :sixel
+  end
+end

data/lib/image_util/color.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  class Color < Array
+    def initialize(*args)
+      super(args)
+    end
+
+    def r = self[0]
+    def g = self[1]
+    def b = self[2]
+    def a = self[3] || 255
+
+    def r=(val); self[0] = val; end
+    def g=(val); self[1] = val; end
+    def b=(val); self[2] = val; end
+    def a=(val); self[3] = val; end
+
+    def self.component_from_number(number)
+      case number
+      when nil
+        number
+      when Integer
+        number.clamp(0, 255)
+      when Float
+        (number * 255).clamp(0, 255)
+      else
+        raise ArgumentError, "wrong type passed as component (passed: #{number})"
+      end
+    end
+
+    def self.from_buffer(buffer, color_bits)
+      buffer.map do |i|
+        case color_bits
+        when 8
+          i
+        else
+          i.to_f / 2**(color_bits - 8)
+        end
+      end.then { |val| new(*val) }
+    end
+
+    def to_buffer(color_bits, color_length)
+      map do |i|
+        case color_bits
+        when 8
+          i
+        else
+          (i.to_f * 2**(color_bits - 8)).to_i
+        end
+      end + [255] * (color_length - length)
+    end
+
+    def self.from(value)
+      case value
+      when Color
+        value
+      when Array
+        value.map do |i|
+          component_from_number(i)
+        rescue ArgumentError
+          raise ArgumentError, "wrong type passed as array index (passed: #{value.inspect})"
+        end.then { |val| new(*val) }
+      when String
+        case value
+        when /\A#(\h)(\h)(\h)\z/
+          new($1.to_i(16) * 0x11, $2.to_i(16) * 0x11, $3.to_i(16) * 0x11)
+        when /\A#(\h{2})(\h{2})(\h{2})\z/
+          new($1.to_i(16), $2.to_i(16), $3.to_i(16))
+        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))
+        when "black" then new(0, 0, 0)
+        when "white" then new(255, 255, 255)
+        when "red" then new(255, 0, 0)
+        when "lime" then new(0, 255, 0)
+        when "blue" then new(0, 0, 255)
+        else
+          raise ArgumentError, "wrong String passed as color (passed: #{value.inspect})"
+        end
+      when Symbol
+        from(value.to_s)
+      when Integer, Float, nil
+        new(*[component_from_number(value)] * 3)
+      else
+        raise ArgumentError, "wrong type passed as color (passed: #{value.inspect})"
+      end
+    end
+
+    def self.[](*value)
+      value = value.first if value.is_a?(Array) && value.length == 1
+      from(value)
+    end
+
+    def inspect
+      if a != 255
+        "#%02x%02x%02x%02x" % [r, g, b, a]
+      else
+        "#%02x%02x%02x" % [r, g, b]
+      end
+    end
+
+    def pretty_print(q)
+      q.text inspect
+    end
+
+    def ==(other)
+      other = begin
+        Color.from(other)
+      rescue StandardError
+        nil
+      end
+      return false unless other.is_a?(Color)
+
+      self_rgb  = self[0, 3]
+      other_rgb = other[0, 3]
+      return false unless self_rgb == other_rgb
+
+      (self[3] || 255) == (other[3] || 255)
+    end
+
+    alias eql? ==
+
+    # Overlays another color on top of this one taking the alpha
+    # channel of both colors into account.
+    def +(other)
+      other = Color.from(other)
+
+      base_a = a.to_f / 255
+      over_a = other.a.to_f / 255
+
+      out_a = over_a + base_a * (1 - over_a)
+
+      return Color.new(0, 0, 0, 0) if out_a.zero?
+
+      out_r = (other.r * over_a + r * base_a * (1 - over_a)) / out_a
+      out_g = (other.g * over_a + g * base_a * (1 - over_a)) / out_a
+      out_b = (other.b * over_a + b * base_a * (1 - over_a)) / out_a
+
+      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.
+    def *(other)
+      raise TypeError, "factor must be numeric" unless other.is_a?(Numeric)
+
+      Color.new(r, g, b, (a * other).clamp(0, 255))
+    end
+  end
+end

data/lib/image_util/filter/_mixin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Mixin
+      def define_immutable_version(*names)
+        names.each do |name|
+          define_method(name) do |*args, **kwargs, &block|
+            dup.tap { |obj| obj.public_send("#{name}!", *args, **kwargs, &block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/image_util/filter/background.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Filter
+    module Background
+      def background(bgcolor)
+        return self if color_length == 3
+
+        unless color_length == 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|
+          over = bg + self[*loc]
+          Color.new(over.r, over.g, over.b)
+        end
+        img
+      end
+    end
+  end
+end