stitchify 0.1.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fabe4da3f056ddc450e8cc6cd31d1711ab5d99ad
-  data.tar.gz: d4a5381f7a0a36219fa70c22fbbd3c73372fba4f
+  metadata.gz: 7566ac54885d62ccd4d9da595890b392e6d60b9e
+  data.tar.gz: c7036ec503541d34cdef582cb3b72911a072169b
 SHA512:
-  metadata.gz: f9ba66eb51de13e0e01839f20788664c40877ffaf972c8586186ad0ce4e0f9f950dcb11812e226be59bb30ce19caf15b26dc454bd8e6b06c1e144fdffd6128df
-  data.tar.gz: dd8fdb4c3bb93ed32891d6ec253dfa0976ba91ef01fc2a41c0bea8504ce01e7717006054d2919c637de1ff2eaf1ed9a462ec7d27e0f075f6f6e9312c99161898
+  metadata.gz: d2f411cfa0219988b2187b8cd1b831c2df4748e111457657689acca81ecf5229daf49614aea2e2d4f8256ff91a43da721d4b86bec836d1dda7b951de19dd7efd
+  data.tar.gz: 57ba44e163b9c1f65ef02e9f15fb49eedf4b771c1e5d54c201da10fae01ef6e64e727dc3e17acaa35ce335a89908ef01f4de01dc6667c93669ee96502aead611

data/lib/stitchify.rb

@@ -1,287 +1,158 @@
-        class Stitchifier
-            require 'nokogiri'
-            require 'open-uri'
-            require 'pry'
-            require 'rasem'
-            require 'asciiart'
-            require 'hex256'
-
-            OPEN_BRACKET = "\e[38;5;"
-            CLOSE_BRACKET = "\e[0m"
-
-            attr_accessor :px, :pos_x, :pos_y, :width, :height, :ascii_width
-
-            def initialize(px = 10, ascii_width = nil)
-                self.px = px
-                self.pos_x = 0
-                self.pos_y = 0
-                self.width = 4 * px
-                self.height = 4 * px
-                self.ascii_width = ascii_width
-            end
-
-            def stitch(img, file = 'stitchify.svg')
-                ascii = img_processor(img)
-                arrs = paragraph_builder(ascii)
-                rasem = arrs_to_rasem(arrs, grid)
-                write(rasem, file)
-                clear_vars
-            end
-
-            def stitch_to_output(img)
-                ascii = img_processor(img)
-                arrs = paragraph_builder(ascii)
-                ret = arrs_to_rasem(arrs, grid).to_s
-                clear_vars
-                ret
-            end
-
-            # ".~:+=o*x^%#@$MW\n .~:+=o*x^%#@$M\nW.~:+=o*x^%  #@$MW"
-
-            def stitch_string(str, file = 'stitchify.svg')
-                arrs = paragraph_builder(str)
-                rasem = arrs_to_rasem(arrs, grid)
-                write(rasem, file)
-                clear_vars
-            end
-
-            def clear_vars
-                self.pos_x = 0
-                self.pos_y = 0
-                self.width = 0
-                self.height = 0
-            end
-
-            def ascii_conditions
-                ret = {}
-                ret[:color] = true
-                ret[:width] = self.ascii_width unless self.ascii_width.nil?
-                ret
-            end
-
-            def img_processor(img)
-                AsciiArt.new(img).to_ascii_art(ascii_conditions)
-            end
-
-            def arrs_to_rasem(arrs, grid)
-                Rasem::SVGImage.new(width: self.width, height: self.height) do
-                    for line_data in arrs
-                        line line_data[0], line_data[1], line_data[2], line_data[3], :stroke_width=>2, :fill=>line_data[4], :stroke=>line_data[4]
-                    end
-                    for line_data in grid
-                        line line_data[0], line_data[1], line_data[2], line_data[3], :stroke_width=>line_data[5]
-                    end
-                end
-            end
-
-            def write(rasem, file)
-                File.open(file, "w") do |f|
-                    rasem.write(f)
-                end
-            end
-
-            def grid
-                n = 10
-                output = []
-                (width / n).times do |i|
-                    x = 1
-                    x = 2 if (i % 10 == 0)
-                    output << [i * n, 0, i * n, height, 'black', x]
-                end
-                (height / n).times do |i|
-                    x = 1
-                    x = 2 if i % 10 == 0
-                    output << [0, i * n, width, i * n, 'black', x]
-                end
-                output
-            end
-
-            def paragraph_builder(str)
-                self.height = 0
-                arr = str.split("\n")
-                output = []
-                arr.each do |line|
-                    output = output + line_builder(line)
-                    self.pos_y = self.pos_y + (3 * px)
-                    self.pos_x = 0
-                    self.height = self.height + (3 * px)
-                end
-                output
-            end
-
-            def line_builder(line)
-                self.width = 0
-                line_output = []
-
-                l = line.split(OPEN_BRACKET)
-
-                l.each do |segment|
-
-                    char_data = segment.split("m")
-
-                    # if the midpoint doesn't exist
-                    if char_data.length == 1 
-                        char_data[0].chars.each do |char|
-                            line_output = line_output + char_builder(char, '#000000')
-                            self.pos_x = self.pos_x + (2 * px)
-                            self.width = self.width + (2 * px)
-                        end
-                    else
-                        char = char_data[1].delete(CLOSE_BRACKET)
-                        line_output = line_output + char_builder(char, HexConverter.ansi_to_hex(char_data[0]))
-                        self.pos_x = self.pos_x + (2 * px)
-                        self.width = self.width + (2 * px)
-                    end
-                end
-
-                line_output
-            end
-
-            def char_builder(char, hex_str)
-                output = []
-                case char
-                when '.'
-                    output << pos_slope_one(1.5 * px, 2.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                when '~'
-                    output << pos_slope_one((0 - px / 2), 2.5 * px, px, hex_str)
-                    output << neg_slope_one(px / 2,       1.5 * px, px, hex_str)
-                    output << pos_slope_one(1.5 * px,     2.5 * px, px, hex_str)
-                when ':'
-                    output << pos_slope_one(1.5 * px, 2.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                    output << pos_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, px / 2,   px, hex_str)
-                when '+'
-                    output << vertical_line(1.5 * px, px / 2,   2 * px, hex_str)
-                    output << horizontal_line(px / 2, 1.5 * px, 2 * px, hex_str)
-                when '='
-                    output << horizontal_line(px / 2, 1.5 * px, 2 * px, hex_str)
-                    output << horizontal_line(px / 2, 2.5 * px, 2 * px, hex_str)
-                when 'o'
-                    output << pos_slope_one(px / 2,   1.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, px / 2,   px, hex_str)
-                    output << pos_slope_one(1.5 * px, 2.5 * px, px, hex_str)
-                    output << neg_slope_one(px / 2,   1.5 * px, px, hex_str)
-                when '*'
-                    output << pos_slope_one(px / 2,   2.5 * px , 2 * px, hex_str)
-                    output << neg_slope_one(px / 2,   px / 2,    2 * px, hex_str)
-                    output << vertical_line(1.5 * px, px / 2,    2 * px, hex_str)
-                when 'x'
-                    output << pos_slope_one(px / 2,   2.5 * px , 2 * px, hex_str)
-                    output << neg_slope_one(px / 2,   px / 2,    2 * px, hex_str)
-                when '^'
-                    output << pos_slope_one(px / 2,   1.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, px / 2,   px, hex_str)
-                when '%'
-                    output << pos_slope_one(px / 2,   1.5 * px, px, hex_str)
-                    output << neg_slope_one(px / 2,   px / 2,   px, hex_str)
-                    output << pos_slope_one(px / 2,   2.5 * px, 2 * px, hex_str)
-                    output << pos_slope_one(1.5 * px, 2.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                when '#'
-                    output << pos_slope_two(px / 2,   2.5 * px, px, hex_str)
-                    output << pos_slope_two(1.5 * px, 2.5 * px, px, hex_str)
-                    output << horizontal_line(px / 2, 1.5 * px, 2 * px, hex_str)
-                    output << horizontal_line(px / 2, 2.5 * px, 2 * px, hex_str)
-                when '@'
-                    output << pos_slope_one(1.5 * px,   2.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px,   1.5 * px, px, hex_str)
-                    output << vertical_line(2.5 * px,   px / 2,   2 * px, hex_str)
-                    output << horizontal_line(1.5 * px, px / 2,   px, hex_str)
-                    output << pos_slope_one(px / 2,     1.5 * px, px, hex_str)
-                    output << neg_slope_one(px / 2,     1.5 * px, px, hex_str)
-                    output << horizontal_line(1.5 * px, 2.5 * px, px, hex_str)
-                when '$'
-                    output << horizontal_line(px / 2, px / 2,   2 * px, hex_str)
-                    output << neg_slope_one(px / 2,   px / 2,   2 * px, hex_str)
-                    output << horizontal_line(px / 2, 2.5 * px, 2 * px, hex_str)
-                    output << vertical_line(1.5 * px, px / 2,   2 * px, hex_str)
-                when 'M'
-                    output << vertical_line(px / 2,   px / 2,   2 * px, hex_str)
-                    output << neg_slope_one(px / 2,   px / 2,   px, hex_str)
-                    output << pos_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                    output << vertical_line(2.5 * px, px / 2,   2 * px, hex_str)
-                when 'W'
-                    output << vertical_line(px / 2,   px / 2,   2 * px, hex_str)
-                    output << pos_slope_one(px / 2,   2.5 * px, px, hex_str)
-                    output << neg_slope_one(1.5 * px, 1.5 * px, px, hex_str)
-                    output << vertical_line(2.5 * px, px / 2,   2 * px, hex_str)
-                when '|'
-                    output << vertical_line(2.5 * px, px / 2, 2 * px, hex_str)
-                when '-'
-                    output << horizontal_line(px / 2, 2.5 * px, 2 * px, hex_str)
-                end
-                output
-            end
-
-            def pos_slope_one(startX, startY, length, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + length,
-                    startY + pos_y - length,
-                    hex_str
-                ]
-            end
-
-            def neg_slope_one(startX, startY, length, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + length,
-                    startY + pos_y + length,
-                    hex_str
-                ]
-            end
-
-            def vertical_line(startX, startY, length, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x,
-                    startY + pos_y + length,
-                    hex_str
-                ]
-            end
-
-            def horizontal_line(startX, startY, length, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + length,
-                    startY + pos_y,
-                    hex_str
-                ]
-            end
-
-            def pos_slope_two(startX, startY, width, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + width,
-                    startY + pos_y - (2 * width),
-                    hex_str
-                ]
-            end
-
-            def neg_slope_half(startX, startY, height, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + (2 * height),
-                    startY + pos_y + height,
-                    hex_str
-                ]
-            end
-
-            def neg_slope_two(startX, startY, width, hex_str)
-                [
-                    startX + pos_x,
-                    startY + pos_y,
-                    startX + pos_x + width,
-                    startY + pos_y + (2 * width),
-                    hex_str
-                ]
-            end
-        end
+require 'chroma'
+require 'color'
+require 'miro'
+require 'pry'
+require 'rasem'
+require 'RMagick'
+
+require 'stitchify/draw_rasem.rb'
+require 'stitchify/pixelfy.rb'
+
+class Stitchifier
+    include Chroma
+    include Magick
+    include Miro
+
+    HSLA_BLACK = [0, 0, 0, 1]
+    HSLA_WHITE = [0, 0, 100, 1]
+    HSL_OPEN_CONST = "hsl("
+    FILLABLE_SHAPES = [
+        'sm_rectangle',
+        'triangle',
+        'circle',
+        'diamond',
+        'reverse_triangle',
+        'left_triangle',
+        'right_triangle'
+    ]
+
+    attr_accessor :base_pixel_arr,
+                  :dominant_colors,
+                  :img,
+                  :img_path,
+                  :num_of_colors,
+                  :num_of_off_colors,
+                  :pos_x,
+                  :pos_y,
+                  :px,
+                  :stitch_map,
+                  :width
+
+    def initialize(img_path = '', width = 50, px=10, num_of_colors = 8)
+        # sets variables
+        self.num_of_colors = num_of_colors
+        set_num_colors
+        self.width = width
+        self.num_of_colors = num_of_colors
+        self.img_path = img_path
+        self.dominant_colors = []
+        self.stitch_map = []
+        self.px = px
+
+        unless img_path.empty?
+            make_img
+            set_dominant_colors
+            build_pixel_array
+
+            d = DrawRasem.new(self.stitch_map, self.width, self.px)
+            d.stitch
+        end
+    end
+
+    def make_img
+        self.img = ImageList.new(img_path).resize_to_fit(width)
+    end
+
+    def set_dominant_colors
+        color_pos = 0
+        colors = black_and_white
+        set_num_colors
+        if self.num_of_colors > 3 && !img_path.empty?
+            miro_data = Miro::DominantColors.new(self.img_path).to_hex unless self.img_path.empty?
+            main_color = miro_data.slice!(0, 1)[0]
+            miro_px = miro_data.map{|x| Pixelfy.from_hex(x)}
+            off_colors = build_off_color_arr(main_color)
+            colors = miro_px + off_colors + colors
+        end
+        colors.each do |px|
+            if px.shape.nil?
+                px.shape = FILLABLE_SHAPES[color_pos]
+                color_pos = (color_pos + 1) % FILLABLE_SHAPES.length
+            end
+        end
+        self.dominant_colors = colors.uniq
+    end
+
+    def black_and_white
+        [Pixelfy.new(0, 0, 0, 'x'), Pixelfy.new(0, 0, 100, 'circle')]
+    end
+
+    def build_pixel_array
+        get_pixels
+        colorize_pixels
+    end
+
+    def get_pixels
+        px = []
+
+        unless self.img.nil?
+            self.img.each_pixel do | pixel, col, row |
+                pixel = pixel.to_hsla
+                px << Pixelfy.new(pixel[0], pixel[1], pixel[2])
+            end
+        end
+        self.base_pixel_arr = px
+    end
+
+    def colorize_pixels
+        self.base_pixel_arr.each {|px| self.stitch_map << px.colorize(self.dominant_colors) }
+    end
+
+    def set_num_colors
+        num = self.num_of_colors - 2
+        case num
+        when 1
+            set_miro(1, 0)
+        when 2
+            set_miro(1, 1)
+        when 3
+            set_miro(2, 1)
+        when 4
+            set_miro(2, 2)
+        when 5
+            set_miro(3, 2)
+        when 6
+            set_miro(3, 3)
+        else
+            set_miro(num - 3, 3)
+        end 
+    end
+
+    def set_miro(cc, off_c)
+        Miro.options[:color_count] = cc
+        self.num_of_off_colors = off_c
+    end
+
+    def build_off_color_arr(color)
+        palette = []
+        if !!color
+            c = Chroma::Color.new(color)
+            palette = c.palette
+            case self.num_of_off_colors
+            when 0
+                palette = []
+            when 1
+                palette = palette.complement.map{|x| Pixelfy.from_hex(x.to_s)}
+            when 2
+                palette = palette.triad.map{|x| Pixelfy.from_hex(x.to_s)}
+            when 3
+                palette = palette.tetrad.map{|x| Pixelfy.from_hex(x.to_s)}
+            end
+        end
+        palette
+    end
+
+    def view_miro_opts
+        Miro.options
+    end
+end

data/lib/stitchify/draw_rasem.rb

@@ -0,0 +1,96 @@
+class DrawRasem
+
+    attr_accessor :px_arr, :width, :px, :pos_x, :pos_y, :height
+
+    def initialize(px_arr, width=50, px=10)
+        self.px_arr = px_arr
+        self.width = width
+        self.px = px
+        clear_vars
+    end
+
+    def stitch
+        write(build_rasem_data, file='stitchify.svg')
+        clear_vars
+    end
+
+    def clear_vars
+        self.pos_x = self.px
+        self.pos_y = self.px
+    end
+
+    def write(rasem, file)
+        File.open(file, "w") do |f|
+            rasem.write(f)
+        end
+    end
+
+
+    def build_rasem_data
+        rasem_obj = self
+
+        Rasem::SVGImage.new(width: 1000000000, height: 100000000) do
+
+            for line_data in rasem_obj.grid
+                line line_data[0], line_data[1], line_data[2], line_data[3], :stroke_width=>line_data[5]
+            end
+
+            for pixel in rasem_obj.px_arr
+                pos_x = rasem_obj.pos_x
+                pos_y = rasem_obj.pos_y
+                px = rasem_obj.px
+
+                case pixel.shape
+                when 'rectangle'
+                    rectangle pos_x, pos_y, px, px, fill: pixel.hex
+                when 'x'
+                    line pos_x, pos_y, pos_x + px, pos_y + px
+                    line pos_x, pos_y + px, pos_x + px, pos_y
+                when 'circle'
+                    circle (pos_x + px/2), (pos_y + px/2), px / 2 - 1, fill: pixel.hex
+                when 'sm_rectangle'
+                    rectangle pos_x + 1, pos_y + 1, px - 2, px - 2, fill: pixel.hex
+                when 'triangle'
+                    polygon [pos_x + px/2, pos_y + 1], [pos_x + 1, pos_y + px - 1], [pos_x + px - 1, pos_y + px - 1], fill: pixel.hex
+                when 'diamond'
+                    polygon [pos_x + px/2, pos_y + 1], [pos_x + 1, pos_y + px/2], [pos_x + px/2, pos_y + px - 1], [pos_x + px - 1, pos_y + px/2], fill: pixel.hex
+                when 'reverse_triangle'
+                    polygon [pos_x + px/2, pos_y + px - 1], [pos_x + 1, pos_y + 1], [pos_x + px - 1, pos_y + 1], fill: pixel.hex
+                when 'left_triangle'
+                    polygon [pos_x + 1, pos_y + px/2], [pos_x + px - 1, pos_y + 1], [pos_x + px - 1, pos_y + px - 1], fill: pixel.hex
+                when 'right_triangle'
+                    polygon [pos_x + px - 1, pos_y + px/2], [pos_x + 1, pos_y + 1], [pos_x + 1, pos_y + px - 1], fill: pixel.hex
+                else
+                    rectangle pos_x, pos_y, px, px, fill: pixel.hex
+                end
+
+                rasem_obj.update_positions
+            end
+        end
+    end
+
+    def grid
+        n = 10
+        output = []
+        (self.width + 1).times do |i|
+            x = 1
+            x = 2 if (i % 10 == 0)
+            output << [(i + 1) * self.px, self.px, (i + 1) * self.px, (self.width + 1) * self.px, 'black', x]
+        end
+        (self.width + 1).times do |i|
+            x = 1
+            x = 2 if i % 10 == 0
+            output << [self.px, (i + 1) * self.px, (self.width + 1) * self.px, (i + 1) * self.px, 'black', x]
+        end
+        output
+    end
+
+    def update_positions
+        if (self.pos_x / self.px) < self.width
+            self.pos_x = self.pos_x + self.px
+        else
+            self.pos_x = self.px
+            self.pos_y = self.pos_y + self.px
+        end
+    end
+end

data/lib/stitchify/pixelfy.rb

@@ -0,0 +1,79 @@
+class Pixelfy
+  require 'chroma'
+  include Chroma
+
+  attr_accessor :hue, :saturation, :lightness, :shape
+
+  HSL_OPEN_CONST = "hsl("
+
+  def initialize(hue, saturation, lightness, shape=nil)
+    self.hue = hue
+    self.saturation = saturation
+    self.lightness = lightness
+    self.shape = shape
+  end
+
+  def self.from_hex(hex_str)
+    px = ''
+    if hex_str
+      color_str = Chroma::Color.new(hex_str).to_hsl
+      color_str.slice!(HSL_OPEN_CONST)
+      color_str.slice!("%)")
+      color_str.slice!('%')
+      color_arr = color_str.split(', ')
+
+      px = self.new(color_arr[0].to_i, color_arr[1].to_i, color_arr[2].to_i)
+    end
+    px
+  end
+
+  def hex
+    Chroma::Color.new(hsl).to_hex
+  end
+
+  def hsl
+    "#{HSL_OPEN_CONST} #{self.hue}, #{self.saturation}%, #{self.lightness}%)"
+  end
+
+  def hsla
+    "#{HSL_OPEN_CONST} #{self.hue}, #{self.saturation}%, #{self.lightness}%, 1)"
+  end
+
+  def colorize(map)
+    deltae = 100000000000
+    closest_px = map[0]
+
+    map.each do |dom_px|
+      hue_delta = (dom_px.hue - self.hue).abs
+
+      if hue_delta < deltae
+
+        deltae = hue_delta
+        closest_px = dom_px
+
+      elsif hue_delta == deltae
+        dom_px_delta = self.get_full_delta(dom_px)
+        current_px_delta = self.get_full_delta(closest_px)
+        if dom_px_delta < current_px_delta
+            deltae = hue_delta
+            closest_px = dom_px
+        end
+      end 
+    end
+
+    self.hue = closest_px.hue
+    self.saturation = closest_px.saturation
+    self.lightness = closest_px.lightness
+    self.shape = closest_px.shape
+
+    self
+  end
+
+  def get_full_delta(px)
+    hue_delta = (px.hue - self.hue).abs
+    sat_delta = (px.saturation - self.saturation).abs
+    lit_delta = (px.lightness - self.lightness).abs
+
+    hue_delta + sat_delta + lit_delta
+  end
+end

metadata

@@ -1,71 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: stitchify
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Ellen Wondra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-05 00:00:00.000000000 Z
+date: 2018-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: rasem
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
-  name: rasem
+  name: miro
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
-  name: asciiart
+  name: color
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: '1.8'
 - !ruby/object:Gem::Dependency
-  name: hex256
+  name: chroma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.1
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,13 +108,16 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: input an HTML document and output an SVG cross stitching pattern
+description: ultimate goal is to input an HTML document and output an SVG cross stitching
+  pattern
 email: ellenfromillinois@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/stitchify.rb
+- lib/stitchify/draw_rasem.rb
+- lib/stitchify/pixelfy.rb
 homepage: http://rubygems.org/gems/stitchify
 licenses:
 - MIT
@@ -124,5 +141,5 @@ rubyforge_project:
 rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
-summary: converts an HTML document into a cross stitching pattern
+summary: converts an image into a cross stitching pattern
 test_files: []