pxlsrt 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 656493d31b58b436d501a9211402394cb3527753
-  data.tar.gz: ab1f3e92f84610d992a7bf1295db33e556309ec6
+  metadata.gz: b67067a23830e901ce06d35571c5e5435ce6cb3b
+  data.tar.gz: 93809cf7e8cd9fc620008f1c28bab5b381e70079
 SHA512:
-  metadata.gz: 8acafe9a33025af289c5753f8abb320f87cb16633fefa9b43b2008dfec9193917bc8386d9fec9896901c5229b301a3c5de59222622ef2767050ffec70b2cbb64
-  data.tar.gz: 952ada3617bb2514ff162c466b9f7935aab2e6ff396201a2b1e614739c431652a4dfd36934597da519f6ed1bbb237d2008a27d11f9136050ae3f17e4b041c842
+  metadata.gz: 4b3fa27fd1981baeba1d480b1b6ecea8e8a8f58c75d218310e560e62f03efd4c83764bf1f8bc012f660f3c7ed885df06b6c39daef81ab3923f141691507fb281
+  data.tar.gz: 0c26e6b7c66683d371dd4cb7a1c650c1a46a9050e2bbc90c09cafe6c28278c09a72d3ef0e3dc146680c7d1251b59cf10d4e0e4cd3ec8cf0d7d2caaa060f75b5f

data/bin/pxlsrt

@@ -20,7 +20,7 @@ class CLI < Thor
 	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, :type => :boolean, :default => false, :aliases => "-M"
+	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"

data/lib/pxlsrt/brute.rb

@@ -40,7 +40,7 @@ module Pxlsrt
 				:min => [Float::INFINITY, {:class => [Fixnum]}],
 				:max => [Float::INFINITY, {:class => [Fixnum]}],
 				:trusted => [false, true],
-				:middle => [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)
@@ -93,14 +93,12 @@ module Pxlsrt
 						newInTown=[]
 						if options[:smooth]!=true
 							for ranger in sliceRanges
-								newInTown.concat(Pxlsrt::Lines.middlate(Pxlsrt::Colors.pixelSort(m[ranger[0]..ranger[1]], options[:method].downcase, nre))) if options[:middle]
-								newInTown.concat(Pxlsrt::Colors.pixelSort(m[ranger[0]..ranger[1]], options[:method].downcase, nre)) if !options[:middle]
+								newInTown.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(m[ranger[0]..ranger[1]], options[:method].downcase, nre), options[:middle]))
 							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)
-								g=Pxlsrt::Lines.middlate(g) if options[:middle]
+								g=Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(k.keys, options[:method].downcase, nre), options[:middle])
 								j=g.map { |x| k[x] }.flatten(1)
 								newInTown.concat(j)
 							end
@@ -116,14 +114,12 @@ module Pxlsrt
 						newInTown=[]
 						if options[:smooth]!=true
 							for ranger in sliceRanges
-								newInTown.concat(Pxlsrt::Lines.middlate(Pxlsrt::Colors.pixelSort(dia[m][ranger[0]..ranger[1]], options[:method].downcase, nre))) if options[:middle]
-								newInTown.concat(Pxlsrt::Colors.pixelSort(dia[m][ranger[0]..ranger[1]], options[:method].downcase, nre)) if !options[:middle]
+								newInTown.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(dia[m][ranger[0]..ranger[1]], options[:method].downcase, nre), options[:middle]))
 							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)
-								g=Pxlsrt::Lines.middlate(g) if options[:middle]
+								g=Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(k.keys, options[:method].downcase, nre), options[:middle])
 								j=g.map { |x| k[x] }.flatten(1)
 								newInTown.concat(j)
 							end

data/lib/pxlsrt/colors.rb

@@ -15,11 +15,6 @@ module Pxlsrt
 			return File.read(path).bytes==[137, 80, 78, 71, 10]
 		end
 		##
-		# This is really lame. Adds first three values of an array together.
-		def self.pxldex(pxl)
-			return pxl[0]+pxl[1]+pxl[2]
-		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
@@ -97,9 +92,9 @@ module Pxlsrt
 			mhm=[]
 			case how.downcase
 				when "sum-rgb"
-					mhm= list.sort_by { |c| Pxlsrt::Colors.pxldex(c) }
+					mhm= list.sort_by { |c| c[0]+c[1]+c[2] }
 				when "sum-rgba"
-					mhm=list.sort_by { |c| Pxlsrt::Colors.pxldex(c)+c[3] }
+					mhm=list.sort_by { |c| c[0]+c[1]+c[2]+c[3] }
 				when "red"
 					mhm= list.sort_by { |c| c[0] }
 				when "yellow"
@@ -126,13 +121,13 @@ module Pxlsrt
 					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]) }
+					mhm=list.sort_by { |c| c[0]*0.2126+c[1]*0.7152+c[2]*0.0722 }
 				when "random"
 					mhm=list.shuffle
 				when "alpha"
 					mhm=list.sort_by{ |c| c[3] }
 				else
-					mhm= list.sort_by { |c| Pxlsrt::Colors.pxldex(c) }
+					mhm= list.sort_by { |c| c[0]+c[1]+c[2] }
 			end
 			if reverse == 0
 				return mhm

data/lib/pxlsrt/helpers.rb

@@ -18,6 +18,11 @@ module Pxlsrt
 			return "\e[36m#{what}\e[0m"
 		end
 		##
+		# Determines if a string can be a float or integer.
+		def self.isNumeric?(s)
+			true if Float(s) rescue false
+		end
+		##
 		# Checks if supplied options follow the rules.
 		def self.checkOptions(options, rules)
 			match=true
@@ -41,6 +46,8 @@ module Pxlsrt
 							end
 						end
 					end
+				elsif rules[o] == :anything
+					o_match = true
 				end
 				match=(match and o_match)
 				if match==false

data/lib/pxlsrt/lines.rb

@@ -27,26 +27,65 @@ module Pxlsrt
 		##
 		# Some fancy rearranging.
 		# [a, b, c, d, e] -> [d, b, a, c, e]
+		# [a, b, c, d] -> [c, a, b, d]
 		def self.middlate(arr)
 			a=[]
-			f=(arr.length/2.0).ceil-1
-			for e in 1..arr.length
-				if (arr.length+e)%2==0
-					a[f+(e/2.0).floor]=arr[e-1]
-				elsif (arr.length+e)%2==1
-					a[f-(e/2.0).floor]=arr[e-1]
+			for e in 0...arr.length
+				if (arr.length+e) % 2 == 1
+					a[0.5*(arr.length+e-1)]=arr[e]
+				elsif (arr.length+e) % 2 == 0
+					a[0.5*(arr.length-e)-1]=arr[e]
 				end
 			end
 			return a
 		end
 		##
+		# Some fancy unrearranging.
+		# [d, b, a, c, e] -> [a, b, c, d, e]
+		# [c, a, b, d] -> [a, b, c, d]
+		def self.reverseMiddlate(arr)
+			a=[]
+			for e in 0...arr.length
+				if e == ((arr.length/2.0).ceil - 1)
+					a[0] = arr[e]
+				elsif e < ((arr.length/2.0).ceil - 1)
+					a[arr.length - 2*e - 2] = arr[e]
+				elsif e > ((arr.length/2.0).ceil - 1)
+					a[2*e - arr.length + 1] = arr[e]
+				end
+			end
+			return a
+		end
+		##
+		# Handle middlate requests
+		def self.handleMiddlate(arr, d)
+			n = Pxlsrt::Helpers.isNumeric?(d)
+			if n and d.to_i > 0
+				k = arr
+				for l in 0...(d.to_i)
+					k = Pxlsrt::Lines.middlate(k)
+				end
+				return k
+			elsif n and d.to_i < 0
+				k = arr
+				for l in 0...(d.to_i.abs)
+					k = Pxlsrt::Lines.reverseMiddlate(k)
+				end
+				return k
+			elsif d == "" or d == "middle"
+				return Pxlsrt::Lines.middlate(arr)
+			else
+				return arr
+			end
+		end
+		##
 		# Gets "rows" of an array based on a width
 		def self.imageRGBLines(image, width)
 			return image.each_slice(width).to_a
 		end
 		##
 		# Outputs random slices of an array.
-		# Because of the requirements of pxlsrt, it doesn't actually slice the array, bute returns a range-like array. Example:
+		# Because of the requirements of pxlsrt, it doesn't actually slice the array, but returns a range-like array. Example:
 		# [[0, 5], [6, 7], [8, 10]]
 		def self.randomSlices(arr, minLength, maxLength)
 			len=arr.length-1

data/lib/pxlsrt/smart.rb

@@ -3,9 +3,9 @@ require 'oily_png'
 
 module Pxlsrt
 	##
-	# Smart sorting uses edge-finding algorithms to create bands to sort,
+	# Smart sorting uses sorted-finding algorithms to create bands to sort,
 	# as opposed to brute sorting which doesn't care for the content or 
-	# edges, just a specified range to create bands.
+	# sorteds, just a specified range to create bands.
 	class Smart
 		##
 		# Uses Pxlsrt::Smart.smart to input and output from pne method.
@@ -28,7 +28,7 @@ module Pxlsrt
 				:verbose => false,
 				:absolute => false,
 				:threshold => 20,
-				:edge => 2,
+				:sorted => 2,
 				:trusted => false,
 				:middle => false
 			}
@@ -41,9 +41,9 @@ module Pxlsrt
 				:verbose => [false, true],
 				:absolute => [false, true],
 				:threshold => [{:class => [Float, Fixnum]}],
-				:edge => [{:class => [Fixnum]}],
+				:sorted => [{:class => [Fixnum]}],
 				:trusted => [false, true],
-				:middle => [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)
@@ -151,13 +151,11 @@ module Pxlsrt
 					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)) if !options[:middle]
-							image.concat(Pxlsrt::Lines(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1))) if options[:middle]
+							image.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1), options[:middle]))
 						end
 					else
 						for band in bands
-							image.concat(Pxlsrt::Colors.pixelSort(band, options[:method], nre)) if !options[:middle]
-							image.concat(Pxlsrt::Lines.middlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre))) if options[:middle]
+							image.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre), options[:middle]))
 						end
 					end
 				else
@@ -208,13 +206,11 @@ module Pxlsrt
 						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)) if !options[:middle]
-								ell.concat(Pxlsrt::Lines.middlate(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1))) if options[:middle]
+								ell.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1), options[:middle]))
 							end
 						else
 							for band in dia[j]
-								ell.concat(Pxlsrt::Colors.pixelSort(band, options[:method], nre)) if !options[:middle]
-								ell.concat(Pxlsrt::Lines.middlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre))) if options[:middle]
+								ell.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre), options[:middle]))
 							end
 						end
 						dia[j]=ell

data/lib/pxlsrt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pxlsrt
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - EVA-01
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler