pxlsrt 1.6.3 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61530233928fdf5537158612c19fb3709da5281d
-  data.tar.gz: fbda0d61a84d109a8f97865db731a9cf369f6db8
+  metadata.gz: 5a70f5d32502428d68f198d43c0ee703814b0827
+  data.tar.gz: 213ac35f136cf0de3cc07329e7ced721a47df470
 SHA512:
-  metadata.gz: b94363170de2be0c0dc41dc5c8d9430edb443c5981e33df4480895740c5108ee9f192857d59c053bba645df8097bee539470c14fb54746836f395004e9e38c49
-  data.tar.gz: d503edbbbdd822c1f4f6f2894a1d7983e1f21735d414a090759e5f9f5817c624cbc8982de1fa2a1bfc791dbecaacd8ec91de7522fc8e68ea84c3e22a2bc0852a
+  metadata.gz: 8b492703dd354aead349520473721db2a8ef810e9495fa7b8e4b6e2d362a4083496b563be6c8204d5cee8c6cb915a08ac933bbe77253a9b767ea2e95d407a9af
+  data.tar.gz: 9f2c0daebb6336b7dd56222c8eb04b03957d0cc3b5e9735a5e77593b56de6bb71e1de6e3309638390eaa49109f28ae7ddd743c30f6391b6e9398c4adfbf8d5f8

data/bin/pxlsrt

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
 require 'pxlsrt'
 require 'thor'
 
@@ -14,14 +13,14 @@ require 'thor'
 # * verbose - Have pxlsrt tell you what it's working on.
 # * help - More in depth commands.
 class CLI < Thor
-	class_option :reverse, :default => false, :aliases => "-r"
-	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 | cyan | magenta | yellow | alpha | sum-rgba | sum-hsba]", :aliases => "-m", :enum => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random", "cyan", "magenta", "yellow", "alpha", "sum-rgba", "sum-hsba"]
 	class_option :verbose, :type => :boolean, :default => false, :aliases => "-V"
-	class_option :middle, :default => false, :aliases => "-M"
 
+	option :reverse, :default => false, :aliases => "-r"
+	option :vertical, :type => :boolean, :default => false, :aliases => "-v"
+	option :diagonal, :type => :boolean, :default => false, :aliases => "-d"
+	option :smooth, :type => :boolean, :default => false, :aliases => "-s"
+	option :method, :type => :string, :default => "sum-rgb", :banner => "[#{Pxlsrt::Colors::METHODS.join(" | ")}]", :aliases => "-m", :enum => Pxlsrt::Colors::METHODS
+	option :middle, :default => false, :aliases => "-M"
 	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"
@@ -37,6 +36,12 @@ class CLI < Thor
 		Pxlsrt::Brute.suite(input, output, k)
 	end
 
+	option :reverse, :default => false, :aliases => "-r"
+	option :vertical, :type => :boolean, :default => false, :aliases => "-v"
+	option :diagonal, :type => :boolean, :default => false, :aliases => "-d"
+	option :smooth, :type => :boolean, :default => false, :aliases => "-s"
+	option :method, :type => :string, :default => "sum-rgb", :banner => "[#{Pxlsrt::Colors::METHODS.join(" | ")}]", :aliases => "-m", :enum => Pxlsrt::Colors::METHODS
+	option :middle, :default => false, :aliases => "-M"
 	option :absolute, :type => :boolean, :default => false, :aliases => "-a", :banner => "ABSOLUTE EDGE FINDING"
 	option :threshold, :type => :numeric, :default => 20, :aliases => "-t"
 	desc "smart INPUT OUTPUT [options]", "Smart pixel sorting"
@@ -51,6 +56,17 @@ class CLI < Thor
 		end
 		Pxlsrt::Smart.suite(input, output, k)
 	end
+
+	option :method, :type => :string, :default => "brightness", :aliases => "-m", :enum => ["brightness", "white", "black"]
+	option :value, :type => :numeric, :aliases => "-v"
+	desc "kim INPUT OUTPUT [outputs]", "Uses Kim Asendorf's algorithm"
+	def kim(input, output)
+		k= {:trusted => true}
+		for o in options.keys
+			k[o.to_sym] = options[o]
+		end
+		Pxlsrt::Kim.suite(input, output, k)
+	end
 end
 
 CLI.start(ARGV)

data/lib/pxlsrt.rb

@@ -4,4 +4,5 @@ require "pxlsrt/lines"
 require "pxlsrt/image"
 require "pxlsrt/colors"
 require "pxlsrt/brute"
-require "pxlsrt/smart"
+require "pxlsrt/smart"
+require "pxlsrt/kim"

data/lib/pxlsrt/brute.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'oily_png'
 
 module Pxlsrt
@@ -15,7 +14,7 @@ module Pxlsrt
 			end
 		end
 		##
-		# The main attraction of the Brute class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will return nil if it encounters an errors.
+		# The main attraction of the Brute class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will raise any error that occurs.
 		def self.brute(input, o={})
 			startTime=Time.now
 			defOptions={
@@ -35,7 +34,7 @@ module Pxlsrt
 				:vertical => [false, true],
 				:diagonal => [false, true],
 				:smooth => [false, true],
-				:method => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random", "cyan", "magenta", "yellow", "alpha", "sum-rgba", "sum-hsba"],
+				:method => Pxlsrt::Colors::METHODS,
 				:verbose => [false, true],
 				:min => [Float::INFINITY, {:class => [Fixnum]}],
 				:max => [Float::INFINITY, {:class => [Fixnum]}],
@@ -53,17 +52,14 @@ module Pxlsrt
 						else
 							Pxlsrt::Helpers.error("File #{input} is not a valid PNG.") if options[:verbose]
 							raise "Invalid PNG"
-							return
 						end
 					else
 						Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
 						raise "File doesn't exit"
-						return
 					end
 				elsif input.class!=String and input.class!=ChunkyPNG::Image
 					Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
 					raise "Invalid input (must be filename or ChunkyPNG::Image)"
-					return
 				end
 				Pxlsrt::Helpers.verbose("Brute mode.") if options[:verbose]
 				Pxlsrt::Helpers.verbose("Creating Pxlsrt::Image object") if options[:verbose]
@@ -86,7 +82,9 @@ module Pxlsrt
 				else
 					iterator = lines.keys
 				end
-				Pxlsrt::Helpers.verbose("Dividing and pixel sorting lines") if options[:verbose]
+				prr = 0
+				len = iterator.to_a.length
+				Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) if options[:verbose]
 				for k in iterator
 					line = lines[k]
 					divisions = Pxlsrt::Lines.randomSlices(line.length,options[:min],options[:max])
@@ -102,6 +100,8 @@ module Pxlsrt
 						png.replaceDiagonal(k, newLine) if !options[:vertical]
 						png.replaceRDiagonal(k, newLine) if options[:vertical]
 					end
+					prr += 1
+					Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) if options[:verbose]
 				end
 				endTime=Time.now
 				timeElapsed=endTime-startTime
@@ -117,7 +117,6 @@ module Pxlsrt
 			else
 				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
 				raise "Bad options"
-				return
 			end
 		end
 	end

data/lib/pxlsrt/colors.rb

@@ -4,6 +4,9 @@ module Pxlsrt
 	##
 	# Includes color operations.
 	class Colors
+		##
+		# List of sorting methods.
+		METHODS = ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random", "cyan", "magenta", "yellow", "alpha", "sum-rgba", "sum-hsba"]
 		##
 		# Converts a ChunkyPNG pixel into an array of the red, green, blue, and alpha values
 		def self.getRGBA(pxl)
@@ -15,38 +18,6 @@ module Pxlsrt
 			return File.open(path, 'rb').read(9).include?('PNG')
 		end
 		##
-		# Converts an RGB-like array ([red, green, blue]) into an HSB-like array ([hue, saturation, brightness]).
-		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
-		##
 		# Averages an array of RGB-like arrays.
 		def self.colorAverage(ca, chunky = false)
 			if ca.length==1
@@ -106,49 +77,49 @@ module Pxlsrt
 			Pxlsrt::Helpers.error(list) if list.length == 0
 			case how.downcase
 				when "sum-rgb"
-					mhm= list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
 				when "sum-rgba"
-					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c)+ChunkyPNG::Color.a(c) }
+					mhm =list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c)+ChunkyPNG::Color.a(c) }
 				when "red"
-					mhm= list.sort_by { |c| ChunkyPNG::Color.r(c) }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.r(c) }
 				when "yellow"
-					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c) }
+					mhm =list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c) }
 				when "green"
-					mhm= list.sort_by { |c| ChunkyPNG::Color.g(c) }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.g(c) }
 				when "cyan"
-					mhm=list.sort_by { |c| ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
+					mhm =list.sort_by { |c| ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
 				when "blue"
-					mhm= list.sort_by { |c| ChunkyPNG::Color.b(c) }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.b(c) }
 				when "magenta"
-					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.b(c) }
+					mhm =list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.b(c) }
 				when "hue"
-					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[0] }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.to_hsb(c)[0] % 360 }
 				when "saturation"
-					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[1] }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.to_hsb(c)[1] }
 				when "brightness"
-					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[2] }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.to_hsb(c)[2] }
 				when "sum-hsb"
-					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); k=Pxlsrt::Colors.rgb2hsb(d); k[0]*100.0/360+k[1]+k[2] }
+					mhm = list.sort_by { |c| k = ChunkyPNG::Color.to_hsb(c); (k[0] % 360) / 360.0 + k[1] + k[2] }
 				when "sum-hsba"
-					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); k=Pxlsrt::Colors.rgb2hsb(d); k[0]*100.0/360+k[1]+k[2]+d.a*100.0/255 }
+					mhm = list.sort_by { |c| k = ChunkyPNG::Color.to_hsb(c); (k[0] % 360) / 360.0 + k[1] + k[2] + ChunkyPNG::Color.a(c) / 255.0 }
 				when "uniqueness"
-					avg=Pxlsrt::Colors.colorAverage(list, true)
-					mhm=list.sort_by { |c| Pxlsrt::Colors.colorUniqueness(c, [avg], true) }
+					avg = Pxlsrt::Colors.colorAverage(list, true)
+					mhm = list.sort_by { |c| Pxlsrt::Colors.colorUniqueness(c, [avg], true) }
 				when "luma"
-					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)*0.2126+ChunkyPNG::Color.g(c)*0.7152+ChunkyPNG::Color.b(c)*0.0722 }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.r(c) * 0.2126 + ChunkyPNG::Color.g(c) * 0.7152 + ChunkyPNG::Color.b(c) * 0.0722 + ChunkyPNG::Color.a(c) }
 				when "random"
-					mhm=list.shuffle
+					mhm = list.shuffle
 				when "alpha"
-					mhm=list.sort_by{ |c| ChunkyPNG::Color.a(c) }
+					mhm = list.sort_by{ |c| ChunkyPNG::Color.a(c) }
 				else
-					mhm= list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
+					mhm = list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
 			end
 			if reverse == 0
 				return mhm
 			elsif reverse == 1
 				return mhm.reverse
 			else
-				return rand(0..1)==0 ? mhm : mhm.reverse
+				return [true, false].sample ? mhm : mhm.reverse
 			end
 		end
 		##

data/lib/pxlsrt/helpers.rb

@@ -18,6 +18,16 @@ module Pxlsrt
 			return "\e[36m#{what}\e[0m"
 		end
 		##
+		# Used to output a yellow string to the terminal.
+		def self.yellow(what)
+			return "\e[33m#{what}\e[0m"
+		end
+		##
+		# Used to output a green string to the terminal.
+		def self.green(what)
+			return "\e[32m#{what}\e[0m"
+		end
+		##
 		# Determines if a string can be a float or integer.
 		def self.isNumeric?(s)
 			true if Float(s) rescue false
@@ -90,5 +100,16 @@ module Pxlsrt
 		def self.verbose(what)
 			puts "#{Pxlsrt::Helpers.cyan("pxlsrt")} #{what}"
 		end
+		##
+		# Progress indication.
+		def self.progress(what, amount, outof)
+			progress = (amount.to_f * 100.0 / outof.to_f).to_i
+			if progress == 100
+				puts "\r#{Pxlsrt::Helpers.green("pxlsrt")} #{what} (#{Pxlsrt::Helpers.green("#{progress}%")})"
+			else
+				$stdout.write "\r#{Pxlsrt::Helpers.yellow("pxlsrt")} #{what} (#{Pxlsrt::Helpers.yellow("#{progress}%")})"
+				$stdout.flush
+			end
+		end
 	end
 end

data/lib/pxlsrt/image.rb

@@ -158,6 +158,16 @@ module Pxlsrt
 		def []=(x, y, color)
 			@modified[x, y] = color
 		end
+		def i(i)
+			x = i % @width
+			y = (i / @width).floor
+			return self[x, y]
+		end
+		def i=(i, color)
+			x = i % @width
+			y = (i / @width).floor
+			self[x, y] = color
+		end
 		##
 		# Return the original, unmodified image.
 		def returnOriginal
@@ -168,5 +178,11 @@ module Pxlsrt
 		def returnModified
 			return @modified
 		end
+		def getWidth
+			return @width
+		end
+		def getHeight
+			return @height
+		end
 	end
 end

data/lib/pxlsrt/kim.rb

@@ -0,0 +1,263 @@
+require 'oily_png'
+
+module Pxlsrt
+	##
+	# Uses Kim Asendorf's pixel sorting algorithm, orginally written in Processing. https://github.com/kimasendorf/ASDFPixelSort
+	class Kim
+		##
+		# Uses Pxlsrt::Kim.kim to input and output from one method.
+		def self.suite(inputFileName, outputFileName, o={})
+			kml=Pxlsrt::Kim.kim(inputFileName, o)
+			if Pxlsrt::Helpers.contented(kml)
+				kml.save(outputFileName)
+			end
+		end
+		##
+		# The main attraction of the Kim class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will raise any error that occurs.
+		def self.kim(input, o = {})
+			startTime = Time.now
+			defOptions={
+				:method => "brightness",
+				:verbose => false,
+				:value => false,
+				:trusted => false
+			}
+			defRules = {
+				:method => ["brightness", "black", "white"],
+				:verbose => [false, true],
+				:value => [false, {:class => [Fixnum]}],
+				:trusted => [false, true]
+			}
+			options = defOptions.merge(o)
+			if o.length == 0 or options[:trusted] == true or (options[:trusted] == false and o.length != 0 and Pxlsrt::Helpers.checkOptions(options, defRules) != false)
+				if input.class == String
+					Pxlsrt::Helpers.verbose("Getting image from file...") if options[:verbose]
+					if File.file?(input)
+						if Pxlsrt::Colors.isPNG?(input)
+							input = ChunkyPNG::Image.from_file(input)
+						else
+							Pxlsrt::Helpers.error("File #{input} is not a valid PNG.") if options[:verbose]
+							raise "Invalid PNG"
+						end
+					else
+						Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
+						raise "File doesn't exit"
+					end
+				elsif input.class != String and input.class != ChunkyPNG::Image
+					Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
+					raise "Invalid input (must be filename or ChunkyPNG::Image)"
+				end
+				Pxlsrt::Helpers.verbose("Kim Asendorf mode.") if options[:verbose]
+				Pxlsrt::Helpers.verbose("Creating Pxlsrt::Image object") if options[:verbose]
+				png = Pxlsrt::Image.new(input)
+				column = 0
+				row = 0
+				options[:value] ||= ChunkyPNG::Color.rgba(11, 220, 0, 1) if options[:method] == "black"
+				options[:value] ||= 60 if options[:method] == "brightness"
+				options[:value] ||= ChunkyPNG::Color.rgba(57, 167, 192, 1) if options[:method] == "white"
+				Pxlsrt::Helpers.progress("Sorting columns", column, png.getWidth) if options[:verbose]
+				while column < png.getWidth
+					x = column
+					y = 0
+					yend = 0
+					while yend < png.getHeight
+					  	case options[:method]
+					    when "black"
+					      	y = self.getFirstNotBlackY(png, x, y, options[:value])
+					      	yend = self.getNextBlackY(png, x, y, options[:value])
+					    when "brightness"
+					      	y = self.getFirstBrightY(png, x, y, options[:value])
+					      	yend = self.getNextDarkY(png, x, y, options[:value])
+					    when "white"
+					      	y = self.getFirstNotWhiteY(png, x, y, options[:value])
+					      	yend = self.getNextWhiteY(png, x, y, options[:value])
+					  	end
+					  	if y < 0 
+					  		break
+				  		end
+					  	sortLength = yend - y;
+					  	unsorted = []
+					  	sorted = []
+					  	for i in (0...sortLength)
+					    	unsorted[i] = png[x, y + i];
+					 	end
+					  	sorted = unsorted.sort
+					  	for i in (0...sortLength)
+					    	png[x, y + i] = sorted[i];
+					  	end
+					  	y = yend + 1;
+					end
+					column += 1
+					Pxlsrt::Helpers.progress("Sorting columns", column, png.getWidth) if options[:verbose]
+				end
+				Pxlsrt::Helpers.progress("Sorting rows", row, png.getHeight) if options[:verbose]
+				while row < png.getHeight
+					x = 0
+					y = row
+					xend = 0
+					while xend < png.getWidth
+					  	case options[:method]
+					    when "black"
+					      	x = self.getFirstNotBlackX(png, x, y, options[:value])
+					      	xend = self.getNextBlackX(png, x, y, options[:value])
+					    when "brightness"
+					      	x = self.getFirstBrightX(png, x, y, options[:value])
+					      	xend = self.getNextDarkX(png, x, y, options[:value])
+					    when "white"
+					      	x = self.getFirstNotWhiteX(png, x, y, options[:value])
+					      	xend = self.getNextWhiteX(png, x, y, options[:value])
+					    end
+					  	if x < 0 
+					  		break
+				  		end
+					  	sortLength = xend - x
+					   	unsorted = []
+					  	sorted = []
+					  	for i in (0...sortLength)
+					    	unsorted[i] = png[x + i, y]
+					  	end
+					  	sorted = unsorted.sort
+					  	for i in (0...sortLength)
+					    	png[x + i, y] = sorted[i];      
+					  	end
+					  	x = xend + 1;
+					end
+					row += 1
+					Pxlsrt::Helpers.progress("Sorting rows", row, png.getHeight) if options[:verbose]
+				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 png.returnModified
+			else
+				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
+				raise "Bad options"
+			end
+		end
+		# Helper methods
+		# Black
+		def self.getFirstNotBlackX(img, x, y, blackValue)
+			if x < img.getWidth
+				while img[x, y] < blackValue
+				  	x += 1
+				  	return -1 if x >= img.getWidth
+				end
+			end
+			return x
+		end
+		def self.getFirstNotBlackY(img, x, y, blackValue)
+			if y < img.getHeight
+				while img[x, y] < blackValue
+				  	y += 1
+				  	return -1 if y >= img.getHeight
+				end
+			end
+			return y
+		end
+		def self.getNextBlackX(img, x, y, blackValue)
+			x += 1
+			if x < img.getWidth
+				while img[x, y] > blackValue
+				  	x += 1
+				  	return (img.getWidth - 1) if x >= img.getWidth
+				end
+			end
+			return x - 1
+		end
+		def self.getNextBlackY(img, x, y, blackValue)
+			y += 1
+			if y < img.getHeight
+				while img[x, y] > blackValue
+				  	y += 1
+				  	return (img.getHeight - 1) if y >= img.getHeight
+				end
+			end
+			return y - 1
+		end
+		# Brightness
+		def self.getFirstBrightX(img, x, y, brightnessValue)
+			if x < img.getWidth
+				while ChunkyPNG::Color.to_hsb(img[x, y])[2] * 255 < brightnessValue
+				  	x += 1;
+				  	return -1 if x >= img.getWidth
+				end
+			end
+			return x
+		end
+		def self.getFirstBrightY(img, x, y, brightnessValue)
+			if y < img.getHeight
+				while ChunkyPNG::Color.to_hsb(img[x, y])[2] * 255 < brightnessValue
+				  	y += 1;
+				  	return -1 if y >= img.getHeight
+				end
+			end
+			return y
+		end
+		def self.getNextDarkX(img, x, y, brightnessValue)
+			x += 1
+			if x < img.getWidth
+				while ChunkyPNG::Color.to_hsb(img[x, y])[2] * 255 > brightnessValue
+				  	x += 1
+				  	return (img.getWidth - 1) if x >= img.getWidth
+				end
+			end
+			return x - 1
+		end
+		def self.getNextDarkY(img, x, y, brightnessValue)
+			y += 1
+			if y < img.getHeight
+				while ChunkyPNG::Color.to_hsb(img[x, y])[2] * 255 > brightnessValue
+				  	y += 1
+				  	return (img.getHeight - 1) if y >= img.getHeight
+				end
+			end
+			return y - 1
+		end
+		# White
+		def self.getFirstNotWhiteX(img, x, y, whiteValue)
+			if x < img.getWidth
+				while img[x, y] > whiteValue
+					x += 1
+					return -1 if x >= img.getWidth
+				end
+			end
+			return x
+		end
+		def self.getFirstNotWhiteY(img, x, y, whiteValue)
+			if y < img.getHeight
+				while img[x, y] > whiteValue
+					y += 1
+					return -1 if y >= img.getHeight
+				end
+			end
+			return y
+		end
+		def self.getNextWhiteX(img, x, y, whiteValue)
+			x += 1
+			if x < img.getWidth
+				while img[x, y] < whiteValue
+				  	x += 1
+				  	return (img.getWidth - 1) if x >= img.getWidth
+				end
+			end
+			return x - 1
+		end
+		def self.getNextWhiteY(img, x, y, whiteValue)
+			y += 1
+			if y < img.getHeight
+				while img[x, y] < whiteValue
+				  	y += 1
+				  	return (img.getHeight - 1) if y >= img.getHeight
+				end
+			end
+			return y - 1
+		end
+	end
+end

data/lib/pxlsrt/smart.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'oily_png'
 
 module Pxlsrt
@@ -16,7 +15,7 @@ module Pxlsrt
 			end
 		end
 		##
-		# The main attraction of the Smart class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will return nil if it encounters an errors.
+		# The main attraction of the Smart class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will raise any error that occurs.
 		def self.smart(input, o={})
 			startTime=Time.now
 			defOptions={
@@ -36,7 +35,7 @@ module Pxlsrt
 				:vertical => [false, true],
 				:diagonal => [false, true],
 				:smooth => [false, true],
-				:method => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random", "cyan", "magenta", "yellow", "alpha", "sum-rgba", "sum-hsba"],
+				:method => Pxlsrt::Colors::METHODS,
 				:verbose => [false, true],
 				:absolute => [false, true],
 				:threshold => [{:class => [Float, Fixnum]}],
@@ -54,17 +53,14 @@ module Pxlsrt
 						else
 							Pxlsrt::Helpers.error("File #{input} is not a valid PNG.") if options[:verbose]
 							raise "Invalid PNG"
-							return
 						end
 					else
 						Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
 						raise "File doesn't exist"
-						return
 					end
 				elsif input.class!=String and input.class!=ChunkyPNG::Image
 					Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
 					raise "Invalid input (must be filename or ChunkyPNG::Image)"
-					return
 				end
 				Pxlsrt::Helpers.verbose("Smart mode.") if options[:verbose]
 				png=Pxlsrt::Image.new(input)
@@ -88,7 +84,9 @@ module Pxlsrt
 				else
 					iterator = lines.keys
 				end
-				Pxlsrt::Helpers.verbose("Dividing and pixel sorting lines") if options[:verbose]
+				prr = 0
+				len = iterator.to_a.length
+				Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) if options[:verbose]
 				for k in iterator
 					line = lines[k]
 					divisions = []
@@ -133,6 +131,8 @@ module Pxlsrt
 						png.replaceDiagonal(k, newLine) if !options[:vertical]
 						png.replaceRDiagonal(k, newLine) if options[:vertical]
 					end
+					prr += 1
+					Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) if options[:verbose]
 				end
 				endTime=Time.now
 				timeElapsed=endTime-startTime
@@ -148,7 +148,6 @@ module Pxlsrt
 			else
 				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
 				raise "Bad options"
-				return
 			end
 		end
 	end

data/lib/pxlsrt/version.rb

@@ -1,5 +1,5 @@
 ##
 # The main module, your best friend.
 module Pxlsrt
-  VERSION = "1.6.3"
+  VERSION = "1.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pxlsrt
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.0
 platform: ruby
 authors:
 - EVA-01
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-13 00:00:00.000000000 Z
+date: 2014-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,7 @@ files:
 - lib/pxlsrt/colors.rb
 - lib/pxlsrt/helpers.rb
 - lib/pxlsrt/image.rb
+- lib/pxlsrt/kim.rb
 - lib/pxlsrt/lines.rb
 - lib/pxlsrt/smart.rb
 - lib/pxlsrt/version.rb