pxlsrt 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ef9f339272ae1b0a3e64f18977fbff964134b27
-  data.tar.gz: 7b2b1da4aed79741292035875de61a5021e914be
+  metadata.gz: 6d8dde41dd5c41e17cc78c762f2ff4078b49ea74
+  data.tar.gz: c61a4474522cb49ef19a38b8fbf14f23021947c3
 SHA512:
-  metadata.gz: 806ffa517135b62506f57c4f25f000c6850318474241090da870e9778ac112da2216ec31f131bcc2b766a9313f73add3523c409889f04903cbaac58382945a6c
-  data.tar.gz: e50c87887ec75c396874dedb234521b6eeff6e3440ffb44f4a243ebbbaddd116e7eb0e58f6f4f61c8dd55d16c99c9d9bf5284b582d028c7375af65b8e7f974ad
+  metadata.gz: 17bf3a4c5c6d18fe8861c703b2f0e388d3c76156e353a8a2e801d2bd9a384b342c97998ef4df32b16733760734c88d50d911985d48250721e595f8e47ed12bfc
+  data.tar.gz: 49d453ad7ca2842aeefeaa4236e0b4830399f1da58b234f65265209caf4516087d6bcbddad3544632d1da32fbbb383336f2cd59c81e6e88776847962246c0582

data/bin/pxlsrt

@@ -1,56 +1,56 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'pxlsrt'
-require 'thor'
-
-##
-# The command line. Created using Thor. Universal options:
-# * reverse - Reverses the bands or randomly reverses or doesn't reverse.
-# * vertical - Sorts vertically.
-# * diagonal - Sorts diagonally. Use with vertical to change the diagonals' orientation.
-# * smooth - "Smoothes" sorted values by grouping identical pixels together.
-# * method - What method to use to sort pixels.
-# * 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 :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"
-	##
-	# Specific options:
-	# * min - Minimum bandwidth.
-	# * max - Maximum bandwidth.
-	def brute(input, output)
-		k={:trusted=>true}
-		for o in options.keys
-			k[o.to_sym]=options[o]
-		end
-		Pxlsrt::Brute.suite(input, output, k)
-	end
-
-	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"
-	##
-	# Specific options:
-	# * threshold - Number used in edge finding. Specifics explained under "absolute".
-	# * absolute - Make edge finding absolute over relative. For example, define a range as a collection of values under the threshold. Relative edge finding is when the contrast of the next pixel is larger than the threshold.
-	def smart(input, output)
-		k={:trusted=>true}
-		for o in options.keys
-			k[o.to_sym]=options[o]
-		end
-		Pxlsrt::Smart.suite(input, output, k)
-	end
-end
-
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'pxlsrt'
+require 'thor'
+
+##
+# The command line. Created using Thor. Universal options:
+# * reverse - Reverses the bands or randomly reverses or doesn't reverse.
+# * vertical - Sorts vertically.
+# * diagonal - Sorts diagonally. Use with vertical to change the diagonals' orientation.
+# * smooth - "Smoothes" sorted values by grouping identical pixels together.
+# * method - What method to use to sort pixels.
+# * 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 :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"
+	##
+	# Specific options:
+	# * min - Minimum bandwidth.
+	# * max - Maximum bandwidth.
+	def brute(input, output)
+		k={:trusted=>true}
+		for o in options.keys
+			k[o.to_sym]=options[o]
+		end
+		Pxlsrt::Brute.suite(input, output, k)
+	end
+
+	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"
+	##
+	# Specific options:
+	# * threshold - Number used in edge finding. Specifics explained under "absolute".
+	# * absolute - Make edge finding absolute over relative. For example, define a range as a collection of values under the threshold. Relative edge finding is when the contrast of the next pixel is larger than the threshold.
+	def smart(input, output)
+		k={:trusted=>true}
+		for o in options.keys
+			k[o.to_sym]=options[o]
+		end
+		Pxlsrt::Smart.suite(input, output, k)
+	end
+end
+
 CLI.start(ARGV)

data/lib/pxlsrt/brute.rb

@@ -1,120 +1,120 @@
-require 'rubygems'
-require 'oily_png'
-
-module Pxlsrt
-	##
-	# Brute sorting creates bands for sorting using a range to determine the bandwidths,
-	# as opposed to smart sorting which uses edge-finding to create bands.
-	class Brute
-		##
-		# Uses Pxlsrt::Brute.brute to input and output from one method.
-		def self.suite(inputFileName, outputFileName, o={})
-			kml=Pxlsrt::Brute.brute(inputFileName, o)
-			if Pxlsrt::Helpers.contented(kml)
-				kml.save(outputFileName)
-			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.
-		def self.brute(input, o={})
-			startTime=Time.now
-			defOptions={
-				:reverse => false,
-				:vertical => false,
-				:diagonal => false,
-				:smooth => false,
-				:method => "sum-rgb",
-				:verbose => false,
-				:min => Float::INFINITY,
-				:max => Float::INFINITY,
-				:trusted => false,
-				:middle => false
-			}
-			defRules={
-				:reverse => :anything,
-				: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"],
-				:verbose => [false, true],
-				:min => [Float::INFINITY, {:class => [Fixnum]}],
-				:max => [Float::INFINITY, {:class => [Fixnum]}],
-				:trusted => [false, true],
-				:middle => :anything
-			}
-			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)
-				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
-				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]
-							return
-						end
-					else
-						Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
-						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]
-					return
-				end
-				Pxlsrt::Helpers.verbose("Brute mode.") if options[:verbose]
-				Pxlsrt::Helpers.verbose("Creating Pxlsrt::Image object") if options[:verbose]
-				png=Pxlsrt::Image.new(input)
-				if !options[:vertical] and !options[:diagonal]
-					Pxlsrt::Helpers.verbose("Retrieving rows") if options[:verbose]
-					lines = png.horizontalLines
-				elsif options[:vertical] and !options[:diagonal]
-					Pxlsrt::Helpers.verbose("Retrieving columns") if options[:verbose]
-					lines = png.verticalLines
-				elsif !options[:vertical] and options[:diagonal]
-					Pxlsrt::Helpers.verbose("Retrieving diagonals") if options[:verbose]
-					lines = png.diagonalLines
-				elsif options[:vertical] and options[:diagonal]
-					Pxlsrt::Helpers.verbose("Retrieving diagonals") if options[:verbose]
-					lines = png.rDiagonalLines
-				end
-				if !options[:diagonal]
-					iterator = 0...(lines.length)
-				else
-					iterator = lines.keys
-				end
-				Pxlsrt::Helpers.verbose("Dividing and pixel sorting lines") if options[:verbose]
-				for k in iterator
-					line = lines[k]
-					divisions = Pxlsrt::Lines.randomSlices(line.length,options[:min],options[:max])
-					newLine = []
-					for division in divisions
-						band = line[division[0]..division[1]]
-						newLine.concat(Pxlsrt::Helpers.handlePixelSort(band, options))
-					end
-					if !options[:diagonal]
-						png.replaceHorizontal(k, newLine) if !options[:vertical]
-						png.replaceVertical(k, newLine) if options[:vertical]
-					else
-						png.replaceDiagonal(k, newLine) if !options[:vertical]
-						png.replaceRDiagonal(k, newLine) if options[:vertical]
-					end
-				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]
-				return
-			end
-		end
-	end
+require 'rubygems'
+require 'oily_png'
+
+module Pxlsrt
+	##
+	# Brute sorting creates bands for sorting using a range to determine the bandwidths,
+	# as opposed to smart sorting which uses edge-finding to create bands.
+	class Brute
+		##
+		# Uses Pxlsrt::Brute.brute to input and output from one method.
+		def self.suite(inputFileName, outputFileName, o={})
+			kml=Pxlsrt::Brute.brute(inputFileName, o)
+			if Pxlsrt::Helpers.contented(kml)
+				kml.save(outputFileName)
+			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.
+		def self.brute(input, o={})
+			startTime=Time.now
+			defOptions={
+				:reverse => false,
+				:vertical => false,
+				:diagonal => false,
+				:smooth => false,
+				:method => "sum-rgb",
+				:verbose => false,
+				:min => Float::INFINITY,
+				:max => Float::INFINITY,
+				:trusted => false,
+				:middle => false
+			}
+			defRules={
+				:reverse => :anything,
+				: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"],
+				:verbose => [false, true],
+				:min => [Float::INFINITY, {:class => [Fixnum]}],
+				:max => [Float::INFINITY, {:class => [Fixnum]}],
+				:trusted => [false, true],
+				:middle => :anything
+			}
+			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)
+				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
+				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]
+							return
+						end
+					else
+						Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
+						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]
+					return
+				end
+				Pxlsrt::Helpers.verbose("Brute mode.") if options[:verbose]
+				Pxlsrt::Helpers.verbose("Creating Pxlsrt::Image object") if options[:verbose]
+				png=Pxlsrt::Image.new(input)
+				if !options[:vertical] and !options[:diagonal]
+					Pxlsrt::Helpers.verbose("Retrieving rows") if options[:verbose]
+					lines = png.horizontalLines
+				elsif options[:vertical] and !options[:diagonal]
+					Pxlsrt::Helpers.verbose("Retrieving columns") if options[:verbose]
+					lines = png.verticalLines
+				elsif !options[:vertical] and options[:diagonal]
+					Pxlsrt::Helpers.verbose("Retrieving diagonals") if options[:verbose]
+					lines = png.diagonalLines
+				elsif options[:vertical] and options[:diagonal]
+					Pxlsrt::Helpers.verbose("Retrieving diagonals") if options[:verbose]
+					lines = png.rDiagonalLines
+				end
+				if !options[:diagonal]
+					iterator = 0...(lines.length)
+				else
+					iterator = lines.keys
+				end
+				Pxlsrt::Helpers.verbose("Dividing and pixel sorting lines") if options[:verbose]
+				for k in iterator
+					line = lines[k]
+					divisions = Pxlsrt::Lines.randomSlices(line.length,options[:min],options[:max])
+					newLine = []
+					for division in divisions
+						band = line[division[0]..division[1]]
+						newLine.concat(Pxlsrt::Helpers.handlePixelSort(band, options))
+					end
+					if !options[:diagonal]
+						png.replaceHorizontal(k, newLine) if !options[:vertical]
+						png.replaceVertical(k, newLine) if options[:vertical]
+					else
+						png.replaceDiagonal(k, newLine) if !options[:vertical]
+						png.replaceRDiagonal(k, newLine) if options[:vertical]
+					end
+				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]
+				return
+			end
+		end
+	end
 end