pxlsrt 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c2b3280ae7ad02daa4da266d7da0754a3d7723b
+  data.tar.gz: 626ec7cf24c9c746e2cdc39f65acd300e2485330
+SHA512:
+  metadata.gz: 0e813eab6fb0931f8448cdc4c389c44fdc0cf958b32304ac8da870be94b5dd5422a925f1d72327b9c629b825eb41d31b6b88aa8d4f09e55c4d45d1a545880127
+  data.tar.gz: 77cb11792128cd2dfd458f76fa8f7adc0dbf1f0fed6bddd679a56bdfa5d8a81e93bb207e3f74a316c8b838052ee07c83d530d04a0bd89270dbc282a6de337cb7

data/bin/pxlsrt

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'pxlsrt'
+require 'thor'
+
+class PXLSRT < Thor
+	class_option :reverse, :type => :string, :default => "no", :banner => "[no | reverse | either]", :aliases => "-r", :enum => ["no", "reverse", "either"]
+	class_option :vertical, :type => :boolean, :default => false, :aliases => "-v"
+	class_option :diagonal, :type => :boolean, :default => false, :aliases => "-d"
+	class_option :smooth, :type => :boolean, :default => false, :aliases => "-s"
+	class_option :method, :type => :string, :default => "sum-rgb", :banner => "[sum-rgb | red | green | blue | sum-hsb | hue | saturation | brightness | uniqueness | luma | random]", :aliases => "-m", :enum => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random"]
+	class_option :diagonal, :type => :boolean, :default => false, :aliases => "-d"
+	class_option :verbose, :type => :boolean, :default => false, :aliases => "-V"
+
+	option :min, :type => :numeric, :default => Float::INFINITY, :banner => "MINIMUM BANDWIDTH"
+	option :max, :type => :numeric, :default => Float::INFINITY, :banner => "MAXIMUM BANDWIDTH"
+	desc "brute INPUT OUTPUT [options]", "Brute pixel sorting"
+	def brute(input, output)
+		k={}
+		for o in options.keys
+			k[o.to_sym]=options[o]
+		end
+		Pxlsrt::Brute.suite(input, output, true, k)
+	end
+
+	option :absolute, :type => :boolean, :default => false, :aliases => "-a", :banner => "ABSOLUTE EDGE FINDING"
+	option :threshold, :type => :numeric, :default => 20, :aliases => "-t"
+	option :edge, :type => :numeric, :default => 2, :aliases => "-e", :banner => "EDGE BUFFERING"
+	desc "smart INPUT OUTPUT [options]", "Smart pixel sorting"
+	def smart(input, output)
+		k={}
+		for o in options.keys
+			k[o.to_sym]=options[o]
+		end
+		Pxlsrt::Smart.suite(input, output, true, k)
+	end
+end
+
+PXLSRT.start(ARGV)

data/lib/pxlsrt/brute.rb

@@ -0,0 +1,137 @@
+require 'rubygems'
+require 'oily_png'
+
+module Pxlsrt
+	class Brute
+		def self.suite(inputFileName, outputFileName, trusted, o={})
+			kml=Pxlsrt::Brute.brute(inputFileName, trusted, o)
+			if Pxlsrt::Helpers.contented(kml)
+				kml.save(outputFileName)
+			end
+		end
+		def self.brute(input, trusted, o={})
+			startTime=Time.now
+			defOptions={
+				:reverse => "no",
+				:vertical => false,
+				:diagonal => false,
+				:smooth => false,
+				:method => "sum-rgb",
+				:verbose => false,
+				:min => Float::INFINITY,
+				:max => Float::INFINITY
+			}
+			defRules={
+				:reverse => ["no", "reverse", "either"],
+				:vertical => [false, true],
+				:diagonal => [false, true],
+				:smooth => [false, true],
+				:method => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random"],
+				:verbose => [false, true],
+				:min => [Float::INFINITY, {:class => [Fixnum]}],
+				:max => [Float::INFINITY, {:class => [Fixnum]}]
+			}
+			options=defOptions.merge(o)
+			if o.length==0 or trusted==true or (trusted==false and o.length!=0 and Pxlsrt::Helpers.checkOptions(options, defRules)!=false)
+				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
+				if input.class==String
+					Pxlsrt::Helpers.verbose("Getting image from file...") if options[:verbose]
+					input=ChunkyPNG::Image.from_file(input)
+				elsif input.class!=String and input.class!=ChunkyPNG::Image
+					Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
+					return
+				end
+				Pxlsrt::Helpers.verbose("Brute mode.") if options[:verbose]
+				case options[:reverse].downcase
+					when "reverse"
+						nre=1
+					when "either"
+						nre=-1
+					else
+						nre=0
+				end
+				png=input
+				w=png.dimension.width
+				h=png.dimension.height
+				sorted=ChunkyPNG::Image.new(w, h, ChunkyPNG::Color::TRANSPARENT)
+				Pxlsrt::Helpers.verbose("Retrieving RGB values of pixels...") if options[:verbose]
+				kml=[]
+				for xy in 0..(w*h-1)
+					kml.push(Pxlsrt::Colors.getRGB(png[xy % w,(xy/w).floor]))
+				end
+				if options[:vertical]==true
+					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
+					kml=Pxlsrt::Colors.rotateImage(kml, w, h, 3)
+					w,h=h,w
+				end
+				toImage=[]
+				if !options[:diagonal]
+					Pxlsrt::Helpers.verbose("Pixel sorting using method '#{options[:method]}'...") if options[:verbose]
+					for m in Pxlsrt::Colors.imageRGBLines(kml, w)
+						sliceRanges=Pxlsrt::Colors.randomSlices(m, options[:min], options[:max])
+						newInTown=[]
+						if options[:smooth]!=true
+							for ranger in sliceRanges
+								newInTown.concat(Pxlsrt::Colors.pixelSort(m[ranger[0]..ranger[1]], options[:method].downcase, nre))
+							end
+						else
+							for ranger in sliceRanges
+								k=(m[ranger[0]..ranger[1]]).group_by { |x| x }
+								g=Pxlsrt::Colors.pixelSort(k.keys, options[:method].downcase, nre)
+								j=g.map { |x| k[x] }.flatten(1)
+								newInTown.concat(j)
+							end
+						end
+						toImage.concat(newInTown)
+					end
+				else
+					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
+					dia=Pxlsrt::Colors.getDiagonals(kml,w,h)
+					Pxlsrt::Helpers.verbose("Pixel sorting using method '#{options[:method]}'...") if options[:verbose]
+					for m in dia.keys
+						sliceRanges=Pxlsrt::Colors.randomSlices(dia[m], options[:min], options[:max])
+						newInTown=[]
+						if options[:smooth]!=true
+							for ranger in sliceRanges
+								newInTown.concat(Pxlsrt::Colors.pixelSort(dia[m][ranger[0]..ranger[1]], options[:method].downcase, nre))
+							end
+						else
+							for ranger in sliceRanges
+								k=(dia[m][ranger[0]..ranger[1]]).group_by { |x| x }
+								g=Pxlsrt::Colors.pixelSort(k.keys, options[:method].downcase, nre)
+								j=g.map { |x| k[x] }.flatten(1)
+								newInTown.concat(j)
+							end
+						end
+						dia[m]=newInTown
+					end
+					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
+					toImage=Pxlsrt::Colors.fromDiagonals(dia,w)
+				end
+				if options[:vertical]==true
+					Pxlsrt::Helpers.verbose("Rotating back (because of vertical mode).") if options[:verbose]
+					toImage=Pxlsrt::Colors.rotateImage(toImage, w,h,1)
+					w,h=h,w
+				end
+				Pxlsrt::Helpers.verbose("Giving pixels new RGB values...") if options[:verbose]
+				for xy in 0..(w*h-1)
+					sorted[xy % w, (xy/w).floor]=Pxlsrt::Colors.arrayToRGB(toImage[xy])
+				end
+				endTime=Time.now
+				timeElapsed=endTime-startTime
+				if timeElapsed < 60
+					Pxlsrt::Helpers.verbose("Took #{timeElapsed.round(4)} second#{ timeElapsed!=1.0 ? "s" : "" }.") if options[:verbose]
+				else
+					minutes=(timeElapsed/60).floor
+					seconds=(timeElapsed % 60).round(4)
+					Pxlsrt::Helpers.verbose("Took #{minutes} minute#{ minutes!=1 ? "s" : "" } and #{seconds} second#{ seconds!=1.0 ? "s" : "" }.") if options[:verbose]
+				end
+				Pxlsrt::Helpers.verbose("Returning ChunkyPNG::Image...") if options[:verbose]
+				return sorted
+			else
+				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
+				return
+			end
+		end
+	end
+end

data/lib/pxlsrt/colors.rb

@@ -0,0 +1,183 @@
+require "oily_png"
+
+module Pxlsrt
+	class Colors
+		def self.getRGB(pxl)
+			return [ChunkyPNG::Color.r(pxl), ChunkyPNG::Color.g(pxl), ChunkyPNG::Color.b(pxl)]
+		end
+		def self.rotateImage(what, width, height, a)
+			nu=[]
+			case a
+				when 0, 360, 4
+					nu=what
+				when 1, 90
+					for xy in 0..(what.length-1)
+						nu[((height-1)-(xy/width).floor)+(xy % width)*height]=what[xy]
+					end
+				when 2, 180
+					nu=what.reverse
+				when 3, 270
+					for xy in 0..(what.length-1)
+						nu[(xy/width).floor+((width-1)-(xy % width))*height]=what[xy]
+					end
+			end
+			return nu
+		end
+		def self.imageRGBLines(image, width)
+			return image.each_slice(width).to_a
+		end
+		def self.randomSlices(arr, minLength, maxLength)
+			len=arr.length-1
+			if len!=0
+				min=[minLength, maxLength].min
+				max=[maxLength, minLength].max
+				if min > len
+					min=len
+				end
+				if max > len
+					max=len
+				end
+				nu=[[0, rand(min..max)]]
+				last=nu.first[1]
+				sorting=true
+				while sorting do
+					if (len-last) <= max
+						nu.push([last+1, len])
+						sorting=false
+					else
+						nu.push([last+1, last+1+rand(min..max)])
+						last=nu.last[1]
+					end
+				end
+			else
+				nu=[[0,0]]
+			end
+			return nu
+		end
+		def self.pxldex(pxl)
+			return pxl[0]+pxl[1]+pxl[2]
+		end
+		def self.rgb2hsb(rgb)
+			r = rgb[0] / 255.0
+			g = rgb[1] / 255.0
+			b = rgb[2] / 255.0
+			max = [r, g, b].max
+			min = [r, g, b].min
+			delta = max - min
+			v = max * 100
+			if (max != 0.0)
+				s = delta / max *100
+			else
+				s = 0.0
+			end
+			if (s == 0.0) 
+				h = 0.0
+			else
+				if (r == max)
+					h = (g - b) / delta
+				elsif (g == max)
+					h = 2 + (b - r) / delta
+				elsif (b == max)
+					h = 4 + (r - g) / delta
+				end
+				h *= 60.0
+				if (h < 0)
+					h += 360.0
+				end
+			end
+			return [h,s,v]
+		end
+		def self.colorAverage(ca)
+			if ca.length==1
+				return ca.first
+			end
+			r=((ca.collect { |c| c[0] }).inject{ |sum, el| sum+el }).to_f / ca.size
+			g=((ca.collect { |c| c[1] }).inject{ |sum, el| sum+el }).to_f / ca.size
+			b=((ca.collect { |c| c[2] }).inject{ |sum, el| sum+el }).to_f / ca.size
+			return [r,g,b]
+		end
+		def self.colorDistance(c1,c2)
+			return Math.sqrt((c1[0]-c2[0])**2+(c1[1]-c2[1])**2+(c1[2]-c2[2])**2)
+		end
+		def self.colorUniqueness(c, ca)
+			return Pxlsrt::Colors.colorDistance(c, Pxlsrt::Colors.colorAverage(ca))
+		end
+		def self.pixelSort(list, how, reverse)
+			mhm=[]
+			case how.downcase
+				when "sum-rgb"
+					mhm= list.sort_by { |c| Pxlsrt::Colors.pxldex(c) }
+				when "red"
+					mhm= list.sort_by { |c| c[0] }
+				when "green"
+					mhm= list.sort_by { |c| c[1] }
+				when "blue"
+					mhm= list.sort_by { |c| c[2] }
+				when "hue"
+					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[0] }
+				when "saturation"
+					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[1] }
+				when "brightness"
+					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[2] }
+				when "sum-hsb"
+					mhm= list.sort_by { |c| k=Pxlsrt::Colors.rgb2hsb(c); k[0]*100/360+k[1]+k[2] }
+				when "uniqueness"
+					avg=Pxlsrt::Colors.colorAverage(list)
+					mhm=list.sort_by { |c| Pxlsrt::Colors.colorUniqueness(c, [avg]) }
+				when "luma"
+					mhm=list.sort_by { |c| Pxlsrt::Colors.pxldex([c[0]*0.2126, c[1]*0.7152, c[2]*0.0722]) }
+				when "random"
+					mhm=list.shuffle
+				else
+					mhm= list.sort_by { |c| Pxlsrt::Colors.pxldex(c) }
+			end
+			if reverse == 0
+				return mhm
+			elsif reverse == 1
+				return mhm.reverse
+			else
+				return rand(0..1)==0 ? mhm : mhm.reverse
+			end
+		end
+		def self.getDiagonals(array, width, height)
+			dias={}
+			for x in (1-height)..(width-1)
+				z=[]
+				for y in 0..(height-1)
+					if (x+(width+1)*y).between?(width*y, (width*(y+1)-1))
+						z.push(array[(x+(width+1)*y)])
+					end
+				end
+				dias[x.to_s]=z
+			end
+			return dias
+		end
+		def self.fromDiagonals(obj, width)
+			ell=[]
+			for k in obj.keys
+				r=k.to_i
+				n=r < 0
+				if n
+					x=0
+					y=r.abs
+				else
+					x=r
+					y=0
+				end
+				ell[x+y*width]=obj[k].first
+				for v in 1..(obj[k].length-1)
+					x+=1
+					y+=1
+					ell[x+y*width]=obj[k][v]
+				end
+			end
+			return ell
+		end
+		def self.arrayToRGB(a)
+			return ChunkyPNG::Color.rgb(a[0], a[1], a[2])
+		end
+		def self.sobelate(i, x,y)
+			return ChunkyPNG::Color.to_grayscale_bytes(i[x,y]).first
+		end
+	end
+end

data/lib/pxlsrt/helpers.rb

@@ -0,0 +1,49 @@
+module Pxlsrt
+	class Helpers
+		def self.contented(c)
+			return (c.class!=NilClass and ((defined? c)!="nil") and ((/(\S)/.match("#{c}"))!=nil))
+		end
+		def self.red(what)
+			return "\e[31m#{what}\e[0m"
+		end
+		def self.cyan(what)
+			return "\e[36m#{what}\e[0m"
+		end
+		def self.checkOptions(options, rules)
+			match=true
+			for o in options.keys
+				o_match=false
+				if rules[o].class==Array
+					if rules[o].include?(options[o])
+						o_match=true
+					else
+						for r in 0...rules[o].length
+							if rules[o][r].class==Hash
+								for n in rules[o][r][:class]
+									if n==options[o].class
+										o_match=match
+										break
+									end
+								end
+							end
+							if o_match==true
+								break
+							end
+						end
+					end
+				end
+				match=(match and o_match)
+				if match==false
+					break
+				end
+			end
+			return match
+		end
+		def self.error(what)
+			puts "#{Pxlsrt::Helpers.red("pxlsrt")} #{what}"
+		end
+		def self.verbose(what)
+			puts "#{Pxlsrt::Helpers.cyan("pxlsrt")} #{what}"
+		end
+	end
+end

data/lib/pxlsrt/smart.rb

@@ -0,0 +1,219 @@
+require 'rubygems'
+require 'oily_png'
+require 'json'
+require 'pathname'
+require 'fileutils'
+require 'base64'
+
+module Pxlsrt
+	class Smart
+		def self.suite(inputFileName, outputFileName, trusted, o={})
+			kml=Pxlsrt::Smart.smart(inputFileName, trusted, o)
+			if Pxlsrt::Helpers.contented(kml)
+				kml.save(outputFileName)
+			end
+		end
+		def self.smart(input, trusted, o={})
+			startTime=Time.now
+			defOptions={
+				:reverse => "no",
+				:vertical => false,
+				:diagonal => false,
+				:smooth => false,
+				:method => "sum-rgb",
+				:verbose => false,
+				:absolute => false,
+				:threshold => 20,
+				:edge => 2
+			}
+			defRules={
+				:reverse => ["no", "reverse", "either"],
+				:vertical => [false, true],
+				:diagonal => [false, true],
+				:smooth => [false, true],
+				:method => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random"],
+				:verbose => [false, true],
+				:absolute => [false, true],
+				:threshold => [{:class => [Float, Fixnum]}],
+				:edge => [{:class => [Fixnum]}]
+			}
+			options=defOptions.merge(o)
+			if o.length==0 or trusted==true or (trusted==false and o.length!=0 and Pxlsrt::Helpers.checkOptions(options, defRules)!=false)
+				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
+				if input.class==String
+					Pxlsrt::Helpers.verbose("Getting image from file...") if options[:verbose]
+					input=ChunkyPNG::Image.from_file(input)
+				elsif input.class!=String and input.class!=ChunkyPNG::Image
+					Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
+					return
+				end
+				Pxlsrt::Helpers.verbose("Smart mode.") if options[:verbose]
+				case options[:reverse].downcase
+					when "reverse"
+						nre=1
+					when "either"
+						nre=-1
+					else
+						nre=0
+				end
+				img=input
+				w,h=img.width,img.height
+				sobel_x = [[-1,0,1], [-2,0,2], [-1,0,1]]
+				sobel_y = [[-1,-2,-1], [ 0, 0, 0], [ 1, 2, 1]]
+				edge = ChunkyPNG::Image.new(w, h, ChunkyPNG::Color::TRANSPARENT)
+				valued="start"
+				k=[]
+				Pxlsrt::Helpers.verbose("Getting Sobel values and colors for pixels...") if options[:verbose]
+				for xy in 0..(w*h-1)
+					x=xy % w
+					y=(xy/w).floor
+					if x!=0 and x!=(w-1) and y!=0 and y!=(h-1)
+						pixel_x=(sobel_x[0][0]*Pxlsrt::Colors.sobelate(img,x-1,y-1))+(sobel_x[0][1]*Pxlsrt::Colors.sobelate(img,x,y-1))+(sobel_x[0][2]*Pxlsrt::Colors.sobelate(img,x+1,y-1))+(sobel_x[1][0]*Pxlsrt::Colors.sobelate(img,x-1,y))+(sobel_x[1][1]*Pxlsrt::Colors.sobelate(img,x,y))+(sobel_x[1][2]*Pxlsrt::Colors.sobelate(img,x+1,y))+(sobel_x[2][0]*Pxlsrt::Colors.sobelate(img,x-1,y+1))+(sobel_x[2][1]*Pxlsrt::Colors.sobelate(img,x,y+1))+(sobel_x[2][2]*Pxlsrt::Colors.sobelate(img,x+1,y+1))
+						pixel_y=(sobel_y[0][0]*Pxlsrt::Colors.sobelate(img,x-1,y-1))+(sobel_y[0][1]*Pxlsrt::Colors.sobelate(img,x,y-1))+(sobel_y[0][2]*Pxlsrt::Colors.sobelate(img,x+1,y-1))+(sobel_y[1][0]*Pxlsrt::Colors.sobelate(img,x-1,y))+(sobel_y[1][1]*Pxlsrt::Colors.sobelate(img,x,y))+(sobel_y[1][2]*Pxlsrt::Colors.sobelate(img,x+1,y))+(sobel_y[2][0]*Pxlsrt::Colors.sobelate(img,x-1,y+1))+(sobel_y[2][1]*Pxlsrt::Colors.sobelate(img,x,y+1))+(sobel_y[2][2]*Pxlsrt::Colors.sobelate(img,x+1,y+1))
+						val = Math.sqrt(pixel_x * pixel_x + pixel_y * pixel_y).ceil
+					else
+						val = 2000000000
+					end
+					k.push({ "sobel" => val, "pixel" => [x, y], "color" => Pxlsrt::Colors.getRGB(img[x, y]) })
+				end
+				if options[:vertical]==true
+					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
+					k=Pxlsrt::Colors.rotateImage(k,w,h,3)
+					w,h=h,w
+				end
+				if !options[:diagonal]
+					lines=Pxlsrt::Colors.imageRGBLines(k, w)
+					Pxlsrt::Helpers.verbose("Determining bands with a#{options[:absolute] ? "n absolute" : " relative"} threshold of #{options[:threshold]}...") if options[:verbose]
+					bands=Array.new()
+					for j in lines
+						slicing=true
+						pixel=0
+						m=Array.new()
+						while slicing do
+							n=Array.new
+							if m.length > 1
+								while m.last.length < options[:edge]
+									if m.length > 1
+										m[-2].concat(m[-1])
+										m.pop
+									else
+										break
+									end
+								end
+							end
+							bandWorking=true
+							while bandWorking do
+								n.push(j[pixel]["color"])
+								if (options[:absolute] ? (j[pixel+1]["sobel"]) : (j[pixel+1]["sobel"]-j[pixel]["sobel"])) > options[:threshold]
+									bandWorking=false
+								end
+								if (pixel+1)==(j.length-1)
+									n.push(j[pixel+1]["color"])
+									slicing=false
+									bandWorking=false
+								end
+								pixel+=1
+							end
+							m.push(n)
+						end
+						bands.concat(m)
+					end
+					Pxlsrt::Helpers.verbose("Pixel sorting using method '#{options[:method]}'...") if options[:verbose]
+					image=[]
+					if options[:smooth]
+						for band in bands
+							u=band.group_by {|x| x}
+							image.concat(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1))
+						end
+					else
+						for band in bands
+							image.concat(Pxlsrt::Colors.pixelSort(band, options[:method], nre))
+						end
+					end
+				else
+					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
+					dia=Pxlsrt::Colors.getDiagonals(k,w,h)
+					Pxlsrt::Helpers.verbose("Determining bands with a#{options[:absolute] ? "n absolute" : " relative"} threshold of #{options[:threshold]}...") if options[:verbose]
+					for j in dia.keys
+						bands=[]
+						if dia[j].length>1
+							slicing=true
+							pixel=0
+							m=Array.new()
+							while slicing do
+								n=Array.new
+								if m.length > 1
+									while m.last.length < options[:edge]
+										if m.length > 1
+											m[-2].concat(m[-1])
+											m.pop
+										else
+											break
+										end
+									end
+								end
+								bandWorking=true
+								while bandWorking do
+									n.push(dia[j][pixel]["color"])
+									if (options[:absolute] ? (dia[j][pixel+1]["sobel"]) : (dia[j][pixel+1]["sobel"]-dia[j][pixel]["sobel"])) > options[:threshold]
+										bandWorking=false
+									end
+									if (pixel+1)==(dia[j].length-1)
+										n.push(dia[j][pixel+1]["color"])
+										slicing=false
+										bandWorking=false
+									end
+									pixel+=1
+								end
+								m.push(n)
+							end
+						else
+							m=[[dia[j].first["color"]]]
+						end
+						dia[j]=bands.concat(m)
+					end
+					Pxlsrt::Helpers.verbose("Pixel sorting using method '#{options[:method]}'...") if options[:verbose]
+					for j in dia.keys
+						ell=[]
+						if options[:smooth]
+							for band in dia[j]
+								u=band.group_by {|x| x}
+								ell.concat(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1))
+							end
+						else
+							for band in dia[j]
+								ell.concat(Pxlsrt::Colors.pixelSort(band, options[:method], nre))
+							end
+						end
+						dia[j]=ell
+					end
+					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
+					image=Pxlsrt::Colors.fromDiagonals(dia,w)
+				end
+				if options[:vertical]==true
+					Pxlsrt::Helpers.verbose("Rotating back (because of vertical mode).") if options[:verbose]
+					image=Pxlsrt::Colors.rotateImage(image,w,h,1)
+					w,h=h,w
+				end
+				Pxlsrt::Helpers.verbose("Giving pixels new RGB values...") if options[:verbose]
+				for px in 0..(w*h-1)
+					edge[px % w, (px/w).floor]=Pxlsrt::Colors.arrayToRGB(image[px])
+				end
+				endTime=Time.now
+				timeElapsed=endTime-startTime
+				if timeElapsed < 60
+					Pxlsrt::Helpers.verbose("Took #{timeElapsed.round(4)} second#{ timeElapsed.round(4)!=1.0 ? "s" : "" }.") if options[:verbose]
+				else
+					minutes=(timeElapsed/60).floor
+					seconds=(timeElapsed % 60).round(4)
+					Pxlsrt::Helpers.verbose("Took #{minutes} minute#{ minutes!=1 ? "s" : "" } and #{seconds} second#{ seconds!=1.0 ? "s" : "" }.") if options[:verbose]
+				end
+				Pxlsrt::Helpers.verbose("Returning ChunkyPNG::Image...") if options[:verbose]
+				return edge
+			else
+				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
+				return
+			end
+		end
+	end
+end

data/lib/pxlsrt/version.rb

@@ -0,0 +1,3 @@
+module Pxlsrt
+  VERSION = "1.0.0"
+end

data/lib/pxlsrt.rb

@@ -0,0 +1,5 @@
+require "pxlsrt/version"
+require "pxlsrt/colors"
+require "pxlsrt/helpers"
+require "pxlsrt/brute"
+require "pxlsrt/smart"

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: pxlsrt
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- EVA-01
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.2'
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+description: Pixel sort PNG files with ease!
+email:
+- j.bruno.che@gmail.com
+executables:
+- pxlsrt
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pxlsrt
+- lib/pxlsrt.rb
+- lib/pxlsrt/brute.rb
+- lib/pxlsrt/colors.rb
+- lib/pxlsrt/helpers.rb
+- lib/pxlsrt/smart.rb
+- lib/pxlsrt/version.rb
+homepage: https://github.com/EVA-01/pxlsrt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Pixel sort PNG files.
+test_files: []