rbimg 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8777c22553d8cd7837e91cd6256a52f2ea1d5a97c56335b8c3ce5568068ecd86
-  data.tar.gz: 9e88203b31a329c63774bb0c8150d6dbddf83d56de6117dac8100a6538b4cea8
+  metadata.gz: 866ea03a52665264e1685f5c058c86d757bd172302eb81a3ce0eeeb92f6b16e0
+  data.tar.gz: 34f65d90480aa2b55f49e0931dea21edaeb990b8ed46fc44e77b4cf144746277
 SHA512:
-  metadata.gz: b65faba907fcb333d95d142ef55c6dfb37ac43e827320775f386725dc92a70817e02ed1d8208985095b771db155351de094be99cc9bc93be2ffcaa427a915443
-  data.tar.gz: 5978647adb099633d64aa03394382d075b12e86022241a52bf736c1546c85f47a87383e342b2f1da436b6009de1642ca82a5cf2f415e799828177e9dacb06c30
+  metadata.gz: 32f94fd46bc3f7a63671364a3284efcd014e8801079a5453b1371554a8030965f45b63c09342cc103f5fc5bda981dc90eb2b2570d0d9b812a1284bc2e1889063
+  data.tar.gz: 630f3b9e6e68425badbb430c61e870b6d9a4ff0da74595ef27a1cfabdd54a7fa03d2646f0a03d4abbff48e38eda6dd104ce6893d8f3d610f83bddc2756fd5da0

data/Gemfile

@@ -7,4 +7,4 @@ gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem 'gspec', '~> 0.1.3', group: :development
 gem "pry", "~> 0.13.1", group: :development
-gem "byteman", "~> 0.1.0"
+gem "byteman", "~> 0.1.1"

data/Gemfile.lock

@@ -1,15 +1,15 @@
 PATH
   remote: .
   specs:
-    rbimg (0.1.3)
+    rbimg (0.1.4)
       byteman (~> 0.1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    byteman (0.1.0)
+    byteman (0.1.1)
     coderay (1.1.3)
-    diff-lcs (1.4.2)
+    diff-lcs (1.4.4)
     gspec (0.1.3)
     method_source (1.0.0)
     pry (0.13.1)
@@ -34,7 +34,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  byteman (~> 0.1.0)
+  byteman (~> 0.1.1)
   gspec (~> 0.1.3)
   pry (~> 0.13.1)
   rake (~> 12.0)

data/README.md

@@ -4,7 +4,15 @@ Allows simple creation and reading of images (currently only PNG images).
 
 Supports all required chunk types (IHDR, PLTE, IDAT, IEND)
 
-Filtering is not currently supported.
+All filtering methods for individual scanlines are supported for reading PNG images, but it will always write with a filtering method of 0 (so re-writing may give you a different format than the original image)
+
+All bit depths for PNG images are supported. See PNG documentation or source code for specifics (ArgumentError thrown if an incorrect bit depth is used for a specific color type)
+
+All PNG color types are supported: greyscale, greyscale with alpha, rgb, rgba, and palette. All with their respective bit_depth sizes.
+
+As of now this gem will be able to retrieve the correct pixel information for all PNG images except for those with an interlace method other than 0, which, as far as I can tell, are most PNG images.
+
+Non-required chunk types are not currently supported.
 
 This gem is primarily for simple manipulation of images using pixel data.
 
@@ -67,7 +75,7 @@ end
 png = Rbimg::PNG.new(pixels: pixels.flatten, type: :greyscale_alpha, width: 300, height: 500)
 png.write(path: './greyscale_alpha')
 ```
-Write a greyscale image from the MSNT dataset:
+Write a greyscale image from the MNIST dataset:
 
 ```ruby
 img_data = File.read("./data/t10k-images-idx3-ubyte").bytes
@@ -77,7 +85,7 @@ num_rows = img_data[8...12]
 num_cols = img_data[12...16]
 pixels = img_data[16...(16 + 784)]
 png = Rbimg::PNG.new(pixels: pixels, type: :greyscale, width: 28, height: 28)
-png.write(path: 'mnst_test')
+png.write(path: 'mnist_test')
 ```
 
 Read a PNG image and get the pixel array from a path
@@ -95,6 +103,22 @@ png = Rbimg::PNG.read(data: data)
 puts png.pixels
 ```
 
+Write a 16-bit-depth rgba image with random colors and alpha:
+
+```ruby
+height = 140
+width = 123
+r = Random.new
+pixels = Array.new(3 * width * height) do |i|
+    r.rand(2 ** 16)
+end
+
+png = Rbimg::PNG.new(pixels: pixels, type: :rgb, width: width, height: height, bit_depth: 16)
+png.write(path: "./rgba_16bit")
+```
+
+Combine images in rows or columns: 
+
 
 
 ## Installation
@@ -113,9 +137,7 @@ Or install it yourself as:
 
     $ gem install rbimg
 
-## Usage
 
-TODO: Write usage instructions here
 
 ## Development
 
@@ -125,6 +147,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
+The feature that will make this gem fully-functional for all PNG images is the implementation of interlaced PNGs. Any help is welcomed. This gem was developed using the documentation found and libpng.org/png/spec/1.2
+Information about interlaced PNGs can be found there. 
+
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rbimg. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rbimg/blob/master/CODE_OF_CONDUCT.md).
 
 

data/TODO.md

@@ -0,0 +1,7 @@
+# TODO
+
+- Convert between image types
+- Allow image combination of different types and sizes
+- Allow image scaling
+- Quantize images to different bit_depths
+- Support interlace PNGs

data/lib/image_types/png.rb

@@ -15,17 +15,109 @@ class Rbimg::PNG
         rgba: 6
     }
 
+    def self.combine(*images, divider: nil, as: :row) 
+        raise ArgumentError.new("as: must be :row or :col") if as != :row && as != :col 
+        raise ArgumentError.new("Images and divider must all be an Rbimg::PNG") if !images.all?{|i| i.is_a?(Rbimg::PNG)} 
+        type = images.first.type
+        height = images.first.height
+        width = images.first.width
+        bit_depth = images.first.bit_depth
+
+        color_type = COLOR_TYPES[type]
+
+        logical_pixel_width = width * Rbimg::PNG.pixel_size_for(color_type: color_type)
+
+        if divider
+            width_multiplier = logical_pixel_width / width
+            divider_width = divider.width * width_multiplier
+            if as == :row
+                raise ArgumentError.new("divider must have the same height as images if aligning as a row") if divider.height != height
+            elsif as == :col
+                raise ArgumentError.new("divider must have the same width as images if aligning as a column") if divider.width != width
+            end
+            raise ArgumentError.new("divider must have the same type and bit_depth as images") if divider.type != type || divider.bit_depth != bit_depth
+        end
+
+        images.each do |i|
+            if i.type != type || i.height != height || i.width != width || i.bit_depth != bit_depth
+                raise ArgumentError.new("Currently all images must have the same type, height, width, and bit_depth to be combined")
+            end
+        end
+
+
+        if as == :row
+            new_width = images.length * width 
+            new_height = height
+            
+            if divider
+                new_width += (divider.width * (images.length - 1))
+            end
+
+            new_pixels = height.times.map do |row|
+                row_start = row * logical_pixel_width
+                divider_row_start = row * divider_width if divider
+                images.map do |img|
+                    row_pixels = img.pixels[row_start...(row_start + logical_pixel_width)] 
+                    ((img == images.last) || divider.nil?) ? row_pixels : row_pixels + divider.pixels[divider_row_start...(divider_row_start + divider_width)]
+                end
+            end.flatten
+        
+        else
+            new_width = width
+            new_height = images.length * height
+            if divider
+                new_height += (divider.height * (images.length - 1))
+            end
+
+            new_pixels = images.map do |img|
+                img_pixels = img.pixels
+                if divider && img != images.last
+                    img_pixels + divider.pixels
+                else
+                    img_pixels
+                end
+            end.flatten
+        end
+
+        begin
+        new_img = Rbimg::PNG.new(pixels: new_pixels, type: type, width: new_width, height: new_height, bit_depth: bit_depth)
+        rescue
+            binding.pry
+        end
+
+    end
+
+    def self.pixel_size_for(color_type:)
+        case color_type
+        when 0
+            1
+        when 2
+            3
+        when 3
+            1
+        when 4
+            2
+        when 6
+            4
+        else
+            raise ArgumentError.new("#{color_type} is not a valid color type. Must be 0,2,3,4, or 6")
+        end
+    end
+
     def self.read(path: nil, data: nil)
         
         raise ArgumentError.new(".read must be initialized with a path or a datastream") if (path.nil? && data.nil?) || (!path.nil? && !data.nil?)
         raise ArgumentError.new("data must be an array of byte integers or a byte string") if data && !data.is_a?(Array) && !data.is_a?(String)
         raise ArgumentError.new("data must be an array of byte integers or a byte string") if data && data.is_a?(Array) && !data.first.is_a?(Integer) 
+        path += ".png" if path && !path.end_with?('.png')
         begin
+
             if path
                 data = File.read(path).bytes
             else
                 data = data.bytes if data.is_a?(String)
             end
+            
             chunk_start = 8
             chunks = []
             loop do 
@@ -46,6 +138,7 @@ class Rbimg::PNG
                 end
 
                 chunk_start = chunk_end
+                #TODO: Make sure last chunk is IEND
                 break if chunk_end >= data.length - 1
 
             end
@@ -57,40 +150,125 @@ class Rbimg::PNG
             compression_method = chunks.first[:compression_method]
             filter_method = chunks.first[:filter_method]
             interlace_method = chunks.first[:interlace_method]
+
             all_idats = chunks.filter{ |c| c.is_a?(Hash) && c[:type] == "IDAT" }
-            compressed_pixels = all_idats.reduce([]){ |mem, idat| mem + idat[:compressed_pixels] }
+            compressed_pixels = all_idats.reduce([]) { |mem, idat| mem + idat[:compressed_pixels] }
             pixels_and_filter = Zlib::Inflate.inflate(compressed_pixels.pack("C*")).unpack("C*")
+            
 
-            case color_type
-            when 0
-                pixel_width = width
-            when 2
-                pixel_width = width * 3
-            when 3
-                pixel_width = width 
-            when 4
-                pixel_width = width * 2
-            when 6
-                pixel_width = width * 4
+            logical_pixel_width = Rbimg::PNG.pixel_size_for(color_type: color_type) * width
+
+            pixel_width = (logical_pixel_width * (bit_depth / 8.0)).ceil
+
+
+            scanline_filters = Array.new(height, nil)
+            pixels = Array.new(pixels_and_filter.length - height, nil)
+            
+            pixels_and_filter.each.with_index do |pixel,i| 
+                scanline = i / (pixel_width + 1)
+                pixel_number = (i % (pixel_width + 1)) - 1
+                pixel_loc = scanline * pixel_width + pixel_number
+                if (pixel_number == -1)
+                    scanline_filters[scanline] = pixel
+                else
+                    case scanline_filters[scanline]
+                    when 0
+                        pixels[pixel_loc] = pixel
+                    when 1
+                        x = pixel_number
+                        bpp = (pixel_width / width) * (bit_depth / 8.0).ceil
+                        prev_raw = x - bpp < 0 ? 0 : pixels[pixel_loc - bpp]
+                        new_pixel = (pixel + prev_raw) % 256
+                        pixels[pixel_loc] = new_pixel
+                    when 2
+                        x = pixel_number
+                        prev_raw = scanline == 0 ? 0 : pixels[pixel_loc - pixel_width]
+                        new_pixel = (pixel + prev_raw) % 256
+                        pixels[pixel_loc] = new_pixel
+                    when 3
+                        x = pixel_number
+                        bpp = (pixel_width / width) * (bit_depth / 8.0).ceil
+                        left_pix = x - bpp < 0 ? 0 : pixels[pixel_loc - bpp]
+                        above_pix = scanline == 0 ? 0 : pixels[pixel_loc - pixel_width]
+                        new_pixel = (pixel + ((left_pix + above_pix) / 2).floor) % 256
+                        pixels[pixel_loc] = new_pixel
+                    when 4
+                        x = pixel_number
+                        bpp = (pixel_width / width) * (bit_depth / 8.0).ceil
+
+                        paeth_predictor = Proc.new do |left, above, upper_left|
+                            p = left + above - upper_left
+                            pa = (p - left).abs
+                            pb = (p - above).abs
+                            pc = (p - upper_left).abs
+                            if pa <= pb && pa <= pc
+                                left
+                            elsif pb <= pc
+                                above
+                            else
+                                upper_left
+                            end
+                        end
+
+                        left_pix = x - bpp < 0 ? 0 : pixels[pixel_loc - bpp]
+                        above_pix = scanline == 0 ? 0 : pixels[pixel_loc - pixel_width]
+                        upper_left_pix = scanline == 0 ? 0 : x - bpp < 0 ? 0 : pixels[pixel_loc - pixel_width - bpp]
+                        pp_out = paeth_predictor[left_pix, above_pix, upper_left_pix]
+                        new_pixel = (pixel + pp_out) % 256
+                        pixels[pixel_loc] = new_pixel
+                    else
+                        raise Rbimg::FormatError.new("Incorrect Filtering type used on this PNG file")
+                    end
+                end
+            end
+
+
+            
+
+            if bit_depth != 8
+                corrected_pixels = Array.new(logical_pixel_width * height, nil)
+                height.times do |row_num| 
+                    row_start = row_num * pixel_width
+                    row_end = row_start + pixel_width
+                    row_data = pixels[row_start...row_end]
+                    binary_data = Byteman.buf2int(row_data).to_s(2)
+                    pad_size = ((logical_pixel_width * bit_depth) / 8.0).ceil * 8
+                    binary_data = Byteman.pad(num: binary_data, len: pad_size, type: :bits)
+                    corrected_row_start = row_num * logical_pixel_width
+                    logical_pixel_width.times do |pixel_num_in_row|
+                        binary_segment_start = pixel_num_in_row * bit_depth
+                        binary_segment_end = binary_segment_start + bit_depth
+                        binary_segment = binary_data[binary_segment_start...binary_segment_end]
+                        logical_pixel_value = binary_segment.to_i(2)
+                        corrected_pixel_location = corrected_row_start + pixel_num_in_row
+                        corrected_pixels[corrected_pixel_location] = logical_pixel_value
+                    end
+                end
             else
-                raise ArgumentError.new("#{color_type} is not a valid color type. Must be 0,2,3,4, or 6")
+                corrected_pixels = pixels
             end
-            pixels = pixels_and_filter.filter.with_index{ |_,i| i % (pixel_width + 1) != 0}
-            args = {pixels: pixels, type: color_type, width: width, height: height, bit_depth: bit_depth}
+
+            args = {pixels: corrected_pixels, type: color_type, width: width, height: height, bit_depth: bit_depth}
             plte = chunks.find{|c| c[:type] == "PLTE" unless c.is_a?(Array)}
             args[:palette] = plte[:chunk_data] if plte
             new(**args)
-        rescue 
-            raise Rbimg::FormatError.new("This PNG file is not in the correct format or has been corrupted")
+        rescue Errno::ENOENT => e
+            raise ArgumentError.new("Invalid path #{path}")
+        rescue => e
+            raise e if e.is_a?(Rbimg::FormatError)
+            raise Rbimg::FormatError.new("This PNG file is not in the correct format or has been corrupted :)")
         end
     end
 
+
     
     attr_reader :pixels, :width, :height, :bit_depth, :compression_method, :filter_method, :interlace_method
-
-    def initialize(pixels: nil, type: nil, width: , height: , bit_depth: 8, compression_method: 0, filter_method: 0, interlace_method: 0, palette: nil)
+    attr_reader :pixel_size
+    def initialize(pixels: nil, type: nil, width: nil, height: nil, bit_depth: 8, compression_method: 0, filter_method: 0, interlace_method: 0, palette: nil)
         @pixels, @width, @height, @compression_method, @filter_method, @interlace_method = pixels, width, height, compression_method, filter_method, interlace_method
         @bit_depth = bit_depth
+        type = :greyscale if type.nil?
+
         @type = type.is_a?(Integer) ? type : COLOR_TYPES[type]
         raise ArgumentError.new("#{type} is not a valid color type. Please use one of: #{COLOR_TYPES.keys}") if type.nil?
         raise ArgumentError.new("Palettes are not compatible with color types 0 and 4") if palette && (@type == 0 || @type == 4)
@@ -117,8 +295,25 @@ class Rbimg::PNG
         ]
         @chunks.insert(1, Chunk.PLTE(palette)) if !palette.nil?
 
+        @pixel_size = Rbimg::PNG.pixel_size_for(color_type: @type)
+
+    end
+
+    def pixel(num)
+        start = num * @pixel_size
+        pend = start + @pixel_size
+        pixels[start...pend]
     end
 
+    def row(rownum)
+        return nil if rownum > self.height
+        pix_width = pixel_size * width
+        start = rownum * pix_width
+        pend = start + pix_width
+        pixels[start...pend]
+    end
+
+
     def type
         COLOR_TYPES.each do |k,v|
             return k if v == @type
@@ -134,6 +329,8 @@ class Rbimg::PNG
         File.write(path + postscript, bytes)
     end
 
+
+
     private
 
     def all_data 
@@ -196,7 +393,7 @@ class Rbimg::PNG
             test_length(width)
             test_length(height) 
             raise ArgumentError.new('Color code types must be 0, 2, 3, 4, or 6') if ![0,2,3,4,6].include?(color_type)
-            raise ArgumentError.new('Bit depth must be related to color_type as such: #{bit_depth_rules}') if !bit_depth_rules[color_type].include?(bit_depth) 
+            raise ArgumentError.new("Bit depth must be related to color_type as such: color_value => bit_depth_options: #{bit_depth_rules}") if !bit_depth_rules[color_type].include?(bit_depth) 
 
 
             wbytes = Byteman.pad(len: 4, num: Byteman.int2buf(width))
@@ -247,21 +444,35 @@ class Rbimg::PNG
 
                 case bit_depth
                 when 1
-                    [0] + Byteman.hex(bit_strm.map{|b| b.to_s(2)}.join('').to_i(2))
+                    raise ArgumentError.new("If bit depth is 1, all pixel values must be a 1 or 0") if bit_strm.any?{ |b| b != 0 && b != 1 }
+                    bits = bit_strm.join('') + ("0" * ((-1 * bit_strm.length % 8) % 8 ))
+                    Byteman.hex(0) + Byteman.pad(num: Byteman.hex(bits.to_i(2)), len: bits.length / 8)
                 when 2
-                    [0] + Byteman.hex(bit_strm.map{|b| Byteman.pad(num: b.to_s(2), len: 2)}.join('').to_i(2))
-                when 4
-                    [0] + Byteman.hex(bit_strm.map{|b| Byteman.pad(num: b.to_s(2), len: 4)}.join('').to_i(2))
+                    bits = bit_strm.map do |b| 
+                        raise ArgumentError.new("If bit depth is 2, all pixel values must be between 0 and 3") if !b.between?(0,3)
+                        Byteman.pad(num: b, len: 2, type: :bits)
+                    end.join('')
+                    padded_bits = bits + ("0" * ((-1 * bit_strm.length * 2) % 8) % 8)
+                    Byteman.hex(0) + Byteman.pad(num: Byteman.hex(padded_bits.to_i(2)), len: padded_bits.length / 8)
+                when 4       
+                    bits = bit_strm.map do |b|
+                        raise ArgumentError.new("If bit depth is 4, all pixel values must be between 0 and 15") if !b.between?(0,15)
+                        Byteman.pad(num: b, len: 4, type: :bits)
+                    end.join('')
+                    padded_bits = bits + ("0" * ((-1 * bit_strm.length * 4) % 8) % 8)
+                    Byteman.hex(0) + Byteman.pad(num: Byteman.hex(padded_bits.to_i(2)), len: padded_bits.length / 8)
                 when 8
+                    raise ArgumentError.new("If bit depth is 8, all pixel values must be between 0 and 255") if bit_strm.any?{|b| !b.between?(0,255)}
                     ([0] + bit_strm).pack("C*")
                 when 16
-                    ([0] + bit_strm).pack("S*")
+                    raise ArgumentError.new("If bit depth is 16, all pixel values must be between 0 and 65535") if bit_strm.any?{|b| !b.between?(0,65535)}
+                    Byteman.hex(0) + bit_strm.map{|b| Byteman.pad(num: Byteman.hex(b), len: 2)}.join('')
                 else
                     ArgumentError.new("bit_depth can only be 1,2,4,8, or 16 bits")
                 end
 
             end
-
+            
             z = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, Zlib::MAX_WBITS, Zlib::MAX_MEM_LEVEL, Zlib::RLE)
             zstrm = z.deflate(scanlines.join(''), Zlib::FINISH)
             z.close
@@ -317,4 +528,7 @@ class Rbimg::PNG
 
     end
 
+     
+    
+
 end

data/lib/rbimg.rb

@@ -2,6 +2,7 @@ require_relative "./rbimg/version"
 require 'byteman'
 require 'zlib'
 
+
 module Rbimg
   class Error < StandardError; end
   # Your code goes here...

data/lib/rbimg/version.rb

@@ -1,3 +1,3 @@
 module Rbimg
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbimg
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - micahshute
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-02 00:00:00.000000000 Z
+date: 2020-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byteman
@@ -42,6 +42,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - bin/console
 - bin/setup
 - lib/errors/crc_error.rb