rbimg 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1c6d36ad031f09377de5a8d7b3ddd3288de61247281e030a443f01f6091fee1
+  data.tar.gz: 8742e79c6a0b56309c46f99bf40b8b8c91788f299dee77012e06b23af7acbe27
+SHA512:
+  metadata.gz: e059f158f9b4d8a3da410d6009a9117f2b11f0b22452b4a55de8dbe59e28e1cf37f0ce9d5e366f5327507f7dc62e293c15a0a31fd8155ecd7daf1f79714ae9e2
+  data.tar.gz: 662a64d34818283e21ef1c10252a2ae3e665f3ba5776bbddfc5fecdc2f9120d15ff4ba71affb66938e8892ea8dd420af754f70e4d58a84f50af283d8abf523e7

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/data/
+# rspec failure tracking
+.rspec_status
+
+*.png
+test.rb

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at micah.shute@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rbimg.gemspec
+gemspec
+
+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"

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    rbimg (0.1.1)
+      byteman (~> 0.1.0)
+      require_all (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byteman (0.1.0)
+    coderay (1.1.3)
+    diff-lcs (1.4.2)
+    gspec (0.1.3)
+    method_source (1.0.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (12.3.3)
+    require_all (3.0.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byteman (~> 0.1.0)
+  gspec (~> 0.1.3)
+  pry (~> 0.13.1)
+  rake (~> 12.0)
+  rbimg!
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 micahshute
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# Rbimg
+
+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.
+
+This gem is primarily for simple manipulation of images using pixel data.
+
+You can easily write images from an array of pixel data, and retrieve pixel data from a PNG image.
+
+Examples: 
+
+Write simple 100x100 green-blue image
+
+```ruby
+pixels = []
+100.times do
+    pixels << Array.new(100, [0,255,255])
+end
+png = Rbimg::PNG.new(pixels: pixels.flatten, type: :rgb, width: 100, height: 100)
+png.write(path: './green-blue')
+```
+
+Write simple 500x500 half blue half red rgba image
+
+```ruby
+pixels = []
+500.times do |row|
+    if row >= 250
+        pixels << Array.new(500, [0,0,255,127])
+    else
+        pixels << Array.new(500, [255,0,0,127])
+    end
+end
+png = Rbimg::PNG.new(pixels: pixels.flatten, type: :rgba, width: 500, height: 500)
+png.write(path: './blue-red-alpha')
+```
+
+Write simple 300x500 half white half black greyscale image
+
+```ruby
+pixels = []
+500.times do |row|
+    if row >= 250
+        pixels << Array.new(300, 255)
+    else
+        pixels << Array.new(300, 0)
+    end
+end
+png = Rbimg::PNG.new(pixels: pixels.flatten, type: :greyscale, width: 300, height: 500)
+png.write(path: './greyscale')
+```
+
+Write a greyscale-alpha version of the image above
+
+```ruby
+pixels = []
+500.times do |row|
+    if row >= 250
+        pixels << Array.new(300, [255,175])
+    else
+        pixels << Array.new(300, [0,175])
+    end
+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:
+
+```ruby
+img_data = File.read("./data/t10k-images-idx3-ubyte").bytes
+mag_num = img_data[0...4]
+num_imgs = img_data[4...8]
+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')
+```
+
+Read a PNG image and get the pixel array from a path
+
+```ruby
+png = Rbimg::PNG.read(path: './data/smiley.png')
+puts png.pixels
+```
+
+Read a PNG image and get the pixel array from raw data
+
+```ruby
+data = File.read('./data/smiley.png')
+png = Rbimg::PNG.read(data: data)
+puts png.pixels
+```
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbimg'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rbimg
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+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).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rbimg project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rbimg/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+spec = Gem::Specification.find_by_name 'gspec'
+load "#{spec.gem_dir}/lib/gspec/tasks/generator.rake"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc "Open interactive console for this project"
+task :console do 
+    require 'pry'
+    require_relative './lib/rbimg'
+    Pry.start
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbimg"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/errors/crc_error.rb

@@ -0,0 +1,3 @@
+class Rbimg::CRCError < StandardError
+
+end

data/lib/errors/format_error.rb

@@ -0,0 +1,3 @@
+class Rbimg::FormatError < StandardError
+
+end

data/lib/image_types/png.rb

@@ -0,0 +1,320 @@
+class Rbimg::PNG
+
+    
+    REQUIRED_CHUNKS = [
+        :IHDR,
+        :IDAT,
+        :IEND
+    ]
+
+    COLOR_TYPES = {
+        greyscale: 0,
+        rgb: 2,
+        pallet: 3,
+        greyscale_alpha: 4,
+        rgba: 6
+    }
+
+    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) 
+        begin
+            if path
+                data = File.read(path).bytes
+            else
+                data = data.bytes if data.is_a?(String)
+            end
+            chunk_start = 8
+            chunks = []
+            loop do 
+                len_end = chunk_start + 4
+                type_end = len_end + 4
+                len = Byteman.buf2int(data[chunk_start...len_end])
+                type = data[len_end...type_end]
+                chunk_end = type_end + len + 4
+                case type.pack("C*")
+                when "IHDR"
+                    chunks << Chunk.readIHDR(data[chunk_start...chunk_end])
+                when "IDAT"
+                    chunks << Chunk.readIDAT(data[chunk_start...chunk_end])
+                when "PLTE"
+                    chunks << Chunk.readPLTE(data[chunk_start...chunk_end])
+                else
+                    chunks << data[chunk_start...chunk_end]
+                end
+
+                chunk_start = chunk_end
+                break if chunk_end >= data.length - 1
+
+            end
+
+            width = chunks.first[:width]
+            height = chunks.first[:height]
+            bit_depth = chunks.first[:bit_depth]
+            color_type = chunks.first[:color_type]
+            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] }
+            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
+            else
+                raise ArgumentError.new("#{color_type} is not a valid color type. Must be 0,2,3,4, or 6")
+            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}
+            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")
+        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)
+        @pixels, @width, @height, @compression_method, @filter_method, @interlace_method = pixels, width, height, compression_method, filter_method, interlace_method
+        @bit_depth = bit_depth
+        @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)
+        raise ArgumentError.new("palette must be an array") if palette && !palette.is_a?(Array)
+        @signature = [137, 80, 78, 71, 13, 10, 26, 10]
+        @chunks = [
+            Chunk.IHDR(
+                width: @width, 
+                height: @height, 
+                bit_depth: @bit_depth, 
+                color_type: @type, 
+                compression_method: @compression_method, 
+                filter_method: @filter_method, 
+                interlace_method: interlace_method
+            ),
+            *Chunk.IDATs(
+                pixels, 
+                color_type: @type, 
+                bit_depth: @bit_depth, 
+                width: @width, 
+                height: @height
+            ),
+            Chunk.IEND
+        ]
+        @chunks.insert(1, Chunk.PLTE(palette)) if !palette.nil?
+
+    end
+
+    def type
+        COLOR_TYPES.each do |k,v|
+            return k if v == @type
+        end
+    end
+
+    def bytes
+        all_data.pack("C*")
+    end
+
+    def write(path: Dir.pwd + "/output.png")
+        postscript = path.split(".").last == "png" ? "" : ".png"
+        File.write(path + postscript, bytes)
+    end
+
+    private
+
+    def all_data 
+        @signature + @chunks.map(&:data).flatten 
+    end
+
+    class Chunk
+
+        def self.readChunk(bytes)
+            bytes = bytes.bytes if bytes.is_a?(String)
+            data = {}
+            data[:length] = Byteman.buf2int(bytes[0...4])
+            data[:type] = Byteman.buf2hex(bytes[4...8])
+            data[:crc] = bytes[-4..-1]
+            data[:chunk_data] = bytes[8...(8 + data[:length])]
+            raise Rbimg::CRCError.new("CRC does not match expected") if !crc_valid?(type: data[:type].unpack("C*"), data: data[:chunk_data], crc: data[:crc])
+            data
+        end
+
+        def self.readIHDR(bytes)
+            bytes = bytes.bytes if bytes.is_a?(String)
+            raise ArgumentError.new("IHDR must be 25 bytes long") if bytes.length != 25
+ 
+            data = readChunk(bytes)
+            data[:width] = Byteman.buf2int(bytes[8...12])
+            data[:height] = Byteman.buf2int(bytes[12...16])
+            data[:bit_depth] = bytes[16]
+            data[:color_type] = bytes[17]
+            data[:compression_method] = bytes[18]
+            data[:filter_method] = bytes[19]
+            data[:interlace_method] = bytes[20]
+            data
+        end
+
+        def self.readIDAT(bytes)
+            data = readChunk(bytes)
+            data[:compressed_pixels] = data[:chunk_data]
+            data
+        end
+
+        def self.readPLTE(bytes)
+            readChunk(bytes)
+        end
+
+        def self.crc_valid?(type:, data:, crc:)
+            c = new(type: type, data: data)
+            c.bytes[-4..-1].bytes == crc
+        end
+
+        def self.IHDR(width: , height: , bit_depth: , color_type: , compression_method: 0, filter_method: 0, interlace_method: 0)
+            bit_depth_rules = {
+                0 => [1,2,4,8,16],
+                2 => [8, 16],
+                3 => [1,2,4,8],
+                4 => [8,16],
+                6 => [8,16]
+            }
+
+            raise ArgumentError.new("Width or height cannot be 0") if width == 0 || height == 0
+            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) 
+
+
+            wbytes = Byteman.pad(len: 4, num: Byteman.int2buf(width))
+            hbytes = Byteman.pad(len: 4, num: Byteman.int2buf(height))
+            bdbyte = [bit_depth]
+            ctbyte = [color_type]
+            cmbyte = [compression_method]
+            fmbyte = [filter_method]
+            ilmbyte = [interlace_method]
+            data = wbytes + hbytes + bdbyte + ctbyte + cmbyte + fmbyte + ilmbyte
+            Chunk.new(type: "IHDR", data: data) 
+        end
+
+        def self.PLTE(data)
+            data = data.bytes if data.is_a?(String)
+            raise ArgumentError.new("Number of bytes must be a multiple of 3") if data.length % 3 != 0
+            raise ArgumentError.new("Pallette length must be between 1 and 256") if data.length < 3 || data.length > (256 * 3)
+            Chunk.new(type: "PLTE", data: data)
+        end
+
+        def self.IDATs(pixels, color_type: ,bit_depth:, width: , height: , idat_size: 2 ** 20)
+
+            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
+            else
+                raise ArgumentError.new("#{color_type} is not a valid color type. Must be 0,2,3,4, or 6")
+            end
+            expected_pixels = pixel_width * height
+            raise ArgumentError.new("pixel count (#{pixels.length}) does not match expected pixel count (#{expected_pixels})") if pixels.length != expected_pixels
+            pixel_square = Array.new(height, nil)
+            pixel_square = pixel_square.map{ |_| [nil] * pixel_width}
+            for i in 0...pixels.length
+                row = i / pixel_width
+                col = i % pixel_width
+                pixel_square[row][col] = pixels[i]
+            end
+
+            scanlines = pixel_square.map do |bit_strm|
+
+                case bit_depth
+                when 1
+                    [0] + Byteman.hex(bit_strm.map{|b| b.to_s(2)}.join('').to_i(2))
+                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))
+                when 8
+                    ([0] + bit_strm).pack("C*")
+                when 16
+                    ([0] + bit_strm).pack("S*")
+                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
+            idats = []
+            zstrm.bytes.each_slice(idat_size) do |dstrm|
+                idats << Chunk.new(type: "IDAT", data: dstrm)
+            end
+            
+            idats
+        end 
+
+        def self.IEND
+            Chunk.new(type: "IEND", data: nil)
+        end
+       
+
+        attr_reader :length, :type, :data
+
+        def initialize(type: ,data:)
+            raise ArgumentError.new("Type must be a string, symbol, or an array") if !type.is_a?(String) && !type.is_a?(Symbol) && !type.is_a?(Array)
+            @data = data.nil? ? [] : data
+            @length = Byteman.pad(len: 4, num: Byteman.int2buf(@data.length))
+            self.class.test_length(@data.length)
+ 
+            if type.is_a?(String) || type.is_a?(Symbol)
+                @type = type.to_s.bytes
+            else
+                @type = type
+            end
+            @crc_strategy = Rbimg::Strategies::CRCTableLookup
+            @crc = crc
+        end
+
+        def data
+            @length + @type + @data + @crc
+        end
+
+        def bytes
+            data.pack("C*")
+        end 
+
+        private
+
+
+        def self.test_length(num, limit: 2 ** 31 - 1)
+            raise ArgumentError.new("Length cannot exceed 2^31 - 1") if num > limit
+        end
+
+
+        def crc
+            @crc_strategy.crc(@type, @data)
+        end
+
+    end
+
+end

data/lib/rbimg/version.rb

@@ -0,0 +1,3 @@
+module Rbimg
+  VERSION = "0.1.1"
+end

data/lib/rbimg.rb

@@ -0,0 +1,14 @@
+require_relative "./rbimg/version"
+require 'byteman'
+require 'zlib'
+
+module Rbimg
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+require_relative './errors/crc_error'
+require_relative './errors/format_error'
+require_relative './strategies/strategies'
+require_relative './strategies/crc_strategies/crc_table_lookup_strategy'
+require_relative './image_types/png'

data/lib/strategies/crc_strategies/crc_table_lookup_strategy.rb

@@ -0,0 +1,35 @@
+class Rbimg::Strategies::CRCTableLookup
+
+    @@crc_table = {}
+
+    def self.make_crc_table
+        for n in 0...256
+            c = n
+            for k in 0...8
+                if c.odd? 
+                    c = 3988292384 ^ (c >> 1)
+                else
+                    c = c >> 1
+                end
+            end
+            @@crc_table[n] = c
+        end
+    end 
+
+    def self.crc_table_computed
+        @@crc_table.length > 0
+    end
+
+
+
+    def self.crc(type, data)
+        c = ([255] * 4).pack("C4").unpack("L").first
+        buff = type + data
+        make_crc_table if !crc_table_computed
+        for n in 0...buff.length
+            c = @@crc_table[(c ^ buff[n]) & 255] ^ (c >> 8)
+        end
+        Byteman.int2buf(c ^ Byteman.buf2int([255] * 4))
+    end
+
+end

data/lib/strategies/strategies.rb

@@ -0,0 +1,3 @@
+class Rbimg::Strategies
+
+end

data/rbimg.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/rbimg/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbimg"
+  spec.version       = Rbimg::VERSION
+  spec.authors       = ["micahshute"]
+  spec.email         = ["micah.shute@gmail.com"]
+
+  spec.summary       = %q{Create, read, and manipulate images via arrays of pixel data}
+  spec.description   = %q{This gem allows you to read and/or create a valid picture by working with an array of pixel data. This can be used to easily visualize the MSNT dataset, ecrypt/decrypt images, create graphs and charts, etc.}
+  spec.homepage      = "https://github.com"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # spec.metadata["allowed_push_host"] = "http://rubygems.com"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com"
+  spec.metadata["changelog_uri"] = "https://github.com"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency 'byteman', "~> 0.1.0"
+  spec.add_dependency 'require_all', "~> 3.0"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: rbimg
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- micahshute
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byteman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This gem allows you to read and/or create a valid picture by working
+  with an array of pixel data. This can be used to easily visualize the MSNT dataset,
+  ecrypt/decrypt images, create graphs and charts, etc.
+email:
+- micah.shute@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/errors/crc_error.rb
+- lib/errors/format_error.rb
+- lib/image_types/png.rb
+- lib/rbimg.rb
+- lib/rbimg/version.rb
+- lib/strategies/crc_strategies/crc_table_lookup_strategy.rb
+- lib/strategies/strategies.rb
+- rbimg.gemspec
+homepage: https://github.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com
+  source_code_uri: https://github.com
+  changelog_uri: https://github.com
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Create, read, and manipulate images via arrays of pixel data
+test_files: []