pxlsrt 1.5.1 → 1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b67067a23830e901ce06d35571c5e5435ce6cb3b
-  data.tar.gz: 93809cf7e8cd9fc620008f1c28bab5b381e70079
+  metadata.gz: eddc063a560a8420871b095ee6e56c96d1b3b66b
+  data.tar.gz: dcfb8606b9c47d43402e6030a80d274b83d3a4e0
 SHA512:
-  metadata.gz: 4b3fa27fd1981baeba1d480b1b6ecea8e8a8f58c75d218310e560e62f03efd4c83764bf1f8bc012f660f3c7ed885df06b6c39daef81ab3923f141691507fb281
-  data.tar.gz: 0c26e6b7c66683d371dd4cb7a1c650c1a46a9050e2bbc90c09cafe6c28278c09a72d3ef0e3dc146680c7d1251b59cf10d4e0e4cd3ec8cf0d7d2caaa060f75b5f
+  metadata.gz: e4b768476d0bda214468c888b1357396d4c62bc5d60aa45546c8d283f73b1957a3e11112589ae689c6a67a2ec0ca37609b94c55b77d70f118949894fb976655c
+  data.tar.gz: 9afbf4b2e3515a51d95143d7d30e031788f7de39ade4870e98f17938b4026b5c9a687a840c493c58641669db04b7ff6dad3b0f045ed5f07fbe3baf513b593111

data/bin/pxlsrt

@@ -39,13 +39,11 @@ class CLI < Thor
 
 	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"
 	##
 	# 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.
-	# * edge - Buffers edge.
 	def smart(input, output)
 		k={:trusted=>true}
 		for o in options.keys

data/lib/pxlsrt/brute.rb

@@ -63,80 +63,42 @@ module Pxlsrt
 					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.getRGBA(png[xy % w,(xy/w).floor]))
+				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[:vertical]==true
-					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
-					kml=Pxlsrt::Lines.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::Lines.imageRGBLines(kml, w)
-						sliceRanges=Pxlsrt::Lines.randomSlices(m, options[:min], options[:max])
-						newInTown=[]
-						if options[:smooth]!=true
-							for ranger in sliceRanges
-								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::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
-						end
-						toImage.concat(newInTown)
-					end
+					iterator = 0...(lines.length)
 				else
-					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
-					dia=Pxlsrt::Lines.getDiagonals(kml,w,h)
-					Pxlsrt::Helpers.verbose("Pixel sorting using method '#{options[:method]}'...") if options[:verbose]
-					for m in dia.keys
-						sliceRanges=Pxlsrt::Lines.randomSlices(dia[m], options[:min], options[:max])
-						newInTown=[]
-						if options[:smooth]!=true
-							for ranger in sliceRanges
-								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::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
-						end
-						dia[m]=newInTown
-					end
-					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
-					toImage=Pxlsrt::Lines.fromDiagonals(dia,w)
-				end
-				if options[:vertical]==true
-					Pxlsrt::Helpers.verbose("Rotating back (because of vertical mode).") if options[:verbose]
-					toImage=Pxlsrt::Lines.rotateImage(toImage, w,h,1)
-					w,h=h,w
+					iterator = lines.keys
 				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.arrayToRGBA(toImage[xy])
+				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
@@ -148,7 +110,7 @@ module Pxlsrt
 					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
+				return png.returnModified
 			else
 				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
 				return

data/lib/pxlsrt/colors.rb

@@ -48,25 +48,37 @@ module Pxlsrt
 		end
 		##
 		# Averages an array of RGB-like arrays.
-		def self.colorAverage(ca)
+		def self.colorAverage(ca, chunky = false)
 			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
-			a=((ca.collect { |c| c[3] }).inject{ |sum, el| sum+el }).to_f / ca.size
-			return [r,g,b,a]
+			if !chunky
+				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
+				a=((ca.collect { |c| c[3] }).inject{ |sum, el| sum+el }).to_f / ca.size
+				return [r,g,b,a]
+			else
+				r=((ca.collect { |c| ChunkyPNG::Color.r(c) }).inject{ |sum, el| sum+el }).to_f / ca.size
+				g=((ca.collect { |c| ChunkyPNG::Color.g(c) }).inject{ |sum, el| sum+el }).to_f / ca.size
+				b=((ca.collect { |c| ChunkyPNG::Color.b(c) }).inject{ |sum, el| sum+el }).to_f / ca.size
+				a=((ca.collect { |c| ChunkyPNG::Color.a(c) }).inject{ |sum, el| sum+el }).to_f / ca.size
+				return ChunkyPNG::Color.rgba(r,g,b,a)
+			end
 		end
 		##
 		# Determines color distance from each other using the Pythagorean theorem.
-		def self.colorDistance(c1,c2)
-			return Math.sqrt((c1[0]-c2[0])**2+(c1[1]-c2[1])**2+(c1[2]-c2[2])**2+(c1[3]-c2[3])**2)
+		def self.colorDistance(c1,c2,chunky = false)
+			if !chunky
+				return Math.sqrt((c1[0]-c2[0])**2+(c1[1]-c2[1])**2+(c1[2]-c2[2])**2+(c1[3]-c2[3])**2)
+			else
+				return Math.sqrt((ChunkyPNG::Color.r(c1)-ChunkyPNG::Color.r(c2))**2+(ChunkyPNG::Color.g(c1)-ChunkyPNG::Color.g(c2))**2+(ChunkyPNG::Color.b(c1)-ChunkyPNG::Color.b(c2))**2+(ChunkyPNG::Color.a(c1)-ChunkyPNG::Color.a(c2))**2)
+			end
 		end
 		##
 		# Uses a combination of color averaging and color distance to find how "unique" a color is.
-		def self.colorUniqueness(c, ca)
-			return Pxlsrt::Colors.colorDistance(c, Pxlsrt::Colors.colorAverage(ca))
+		def self.colorUniqueness(c, ca, chunky = false)
+			return Pxlsrt::Colors.colorDistance(c, Pxlsrt::Colors.colorAverage(ca, chunky), chunky)
 		end
 		##
 		# Sorts an array of colors based on a method.
@@ -92,42 +104,42 @@ module Pxlsrt
 			mhm=[]
 			case how.downcase
 				when "sum-rgb"
-					mhm= list.sort_by { |c| c[0]+c[1]+c[2] }
+					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| c[0]+c[1]+c[2]+c[3] }
+					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| c[0] }
+					mhm= list.sort_by { |c| ChunkyPNG::Color.r(c) }
 				when "yellow"
-					mhm=list.sort_by { |c| c[0]+c[1] }
+					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c) }
 				when "green"
-					mhm= list.sort_by { |c| c[1] }
+					mhm= list.sort_by { |c| ChunkyPNG::Color.g(c) }
 				when "cyan"
-					mhm=list.sort_by { |c| c[1]+c[2] }
+					mhm=list.sort_by { |c| ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
 				when "blue"
-					mhm= list.sort_by { |c| c[2] }
+					mhm= list.sort_by { |c| ChunkyPNG::Color.b(c) }
 				when "magenta"
-					mhm=list.sort_by { |c| c[0]+c[2] }
+					mhm=list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.b(c) }
 				when "hue"
-					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[0] }
+					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[0] }
 				when "saturation"
-					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[1] }
+					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[1] }
 				when "brightness"
-					mhm= list.sort_by { |c| Pxlsrt::Colors.rgb2hsb(c)[2] }
+					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); Pxlsrt::Colors.rgb2hsb(d)[2] }
 				when "sum-hsb"
-					mhm= list.sort_by { |c| k=Pxlsrt::Colors.rgb2hsb(c); k[0]*100.0/360+k[1]+k[2] }
+					mhm= list.sort_by { |c| d = Pxlsrt::Colors.getRGBA(c); k=Pxlsrt::Colors.rgb2hsb(d); k[0]*100.0/360+k[1]+k[2] }
 				when "sum-hsba"
-					mhm= list.sort_by { |c| k=Pxlsrt::Colors.rgb2hsb(c); k[0]*100.0/360+k[1]+k[2]+c[3]*100.0/255 }
+					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 }
 				when "uniqueness"
-					avg=Pxlsrt::Colors.colorAverage(list)
-					mhm=list.sort_by { |c| Pxlsrt::Colors.colorUniqueness(c, [avg]) }
+					avg=Pxlsrt::Colors.colorAverage(list, true)
+					mhm=list.sort_by { |c| Pxlsrt::Colors.colorUniqueness(c, [avg], true) }
 				when "luma"
-					mhm=list.sort_by { |c| c[0]*0.2126+c[1]*0.7152+c[2]*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 }
 				when "random"
 					mhm=list.shuffle
 				when "alpha"
-					mhm=list.sort_by{ |c| c[3] }
+					mhm=list.sort_by{ |c| ChunkyPNG::Color.a(c) }
 				else
-					mhm= list.sort_by { |c| c[0]+c[1]+c[2] }
+					mhm= list.sort_by { |c| ChunkyPNG::Color.r(c)+ChunkyPNG::Color.g(c)+ChunkyPNG::Color.b(c) }
 			end
 			if reverse == 0
 				return mhm

data/lib/pxlsrt/helpers.rb

@@ -57,6 +57,30 @@ module Pxlsrt
 			return match
 		end
 		##
+		# Pixel sorting helper to eliminate repetition.
+		def self.handlePixelSort(band, o)
+			if o[:reverse].downcase == "reverse"
+				reverse = 1
+			elsif o[:reverse].downcase == "either"
+				reverse = -1
+			else
+				reverse = 0
+			end
+			if o[:smooth]
+				u = band.group_by { |x| x }
+				k = u.keys
+			else
+				k = band
+			end
+			sortedBand = Pxlsrt::Colors.pixelSort(
+				k,
+				o[:method],
+				reverse
+			)
+			sortedBand = sortedBand.map { |x| u[x] }.flatten(1) if o[:smooth]
+			return Pxlsrt::Lines.handleMiddlate(sortedBand, o[:middle])
+		end
+		##
 		# Prints an error message.
 		def self.error(what)
 			puts "#{Pxlsrt::Helpers.red("pxlsrt")} #{what}"

data/lib/pxlsrt/image.rb

@@ -0,0 +1,172 @@
+module Pxlsrt
+	##
+	# Image class for handling ChunkyPNG images.
+	class Image
+		def initialize(png)
+			@original = png
+			@width = png.width
+			@height = png.height
+			@modified = png
+		end
+		##
+		# Retrieve a multidimensional array consisting of the horizontal lines (row) of the image.
+		def horizontalLines
+			return (0...@height).inject([]) { | arr, row | arr << @modified.row(row) }
+		end
+		##
+		# Replace a horizontal line (row) of the image.
+		def replaceHorizontal(y, arr)
+			@modified.replace_row!(y, arr)
+			return @modified
+		end
+		##
+		# Retrieve the x and y coordinates of a pixel based on the multidimensional array created using the horizontalLines method.
+		def horizontalXY(horizontal, index)
+			return {
+				"x" => index.to_i,
+				"y" => horizontal.to_i
+			}
+		end
+		##
+		# Retrieve a multidimensional array consisting of the vertical lines of the image.
+		def verticalLines
+			return (0...@width).inject([]) { | arr, column | arr << @modified.column(column) }
+		end
+		##
+		# Replace a vertical line (column) of the image.
+		def replaceVertical(y, arr)
+			@modified.replace_column!(y, arr)
+			return @modified
+		end
+		##
+		# Retrieve the x and y coordinates of a pixel based on the multidimensional array created using the verticalLines method.
+		def verticalXY(vertical, index)
+			return {
+				"x" => vertical.to_i,
+				"y" => index.to_i
+			}
+		end
+		##
+		# Retrieve a hash consisting of the diagonal lines (top left to bottom right) of the image.
+		def diagonalLines
+			return Pxlsrt::Lines.getDiagonals(self.horizontalLines.flatten(1), @width, @height)
+		end
+		##
+		# Retrieve a hash consisting of the diagonal lines (bottom left to top right) of the image.
+		def rDiagonalLines
+			return Pxlsrt::Lines.getDiagonals(self.horizontalLines.reverse.flatten(1).reverse, @width, @height)
+		end
+		##
+		# Get the column and row based on the diagonal hash created using diagonalLines.
+		def diagonalColumnRow(d, i)
+			return {
+				"column" => ((d.to_i < 0) ? i : d.to_i + i).to_i,
+				"row" => ((d.to_i < 0) ? d.to_i.abs + i : i).to_i
+			}
+		end
+		##
+		# Replace a diagonal line (top left to bottom right) of the image.
+		def replaceDiagonal(d, arr)
+			d = d.to_i
+			for i in 0...arr.length
+				xy = self.diagonalXY(d, i)
+				self[xy["x"], xy["y"]] = arr[i]
+			end
+		end
+		##
+		# Replace a diagonal line (bottom left to top right) of the image.
+		def replaceRDiagonal(d, arr)
+			d = d.to_i
+			for i in 0...arr.length
+				xy = self.rDiagonalXY(d, i)
+				self[xy["x"], xy["y"]] = arr[i]
+			end
+		end
+		##
+		# Retrieve the x and y coordinates of a pixel based on the hash created using the diagonalLines method and the column and row of the diagonalColumnRow method.
+		def diagonalXY(d, i)
+			cr = self.diagonalColumnRow(d, i)
+			return {
+				"x" => cr["column"],
+				"y" => cr["row"]
+			}
+		end
+		##
+		# Retrieve the x and y coordinates of a pixel based on the hash created using the rDiagonalLines method and the column and row of the diagonalColumnRow method.
+		def rDiagonalXY(d, i)
+			cr = self.diagonalColumnRow(d, i)
+			return {
+				"x" => @width - 1 - cr["column"],
+				"y" => cr["row"]
+			}
+		end
+		##
+		# Retrieve Sobel value for a given pixel.
+		def getSobel(x, y)
+			if !defined?(@sobels)
+				@grey ||= @original.grayscale
+				@sobel_x ||= [[-1,0,1], [-2,0,2], [-1,0,1]]
+				@sobel_y ||= [[-1,-2,-1], [ 0, 0, 0], [ 1, 2, 1]]
+				if x != 0 and x != (@width-1) and y != 0 and y != (@height-1)
+					t1=ChunkyPNG::Color.r(@grey[x-1,y-1])
+					t2=ChunkyPNG::Color.r(@grey[x,y-1])
+					t3=ChunkyPNG::Color.r(@grey[x+1,y-1])
+					t4=ChunkyPNG::Color.r(@grey[x-1,y])
+					t5=ChunkyPNG::Color.r(@grey[x,y])
+					t6=ChunkyPNG::Color.r(@grey[x+1,y])
+					t7=ChunkyPNG::Color.r(@grey[x-1,y+1])
+					t8=ChunkyPNG::Color.r(@grey[x,y+1])
+					t9=ChunkyPNG::Color.r(@grey[x+1,y+1])
+					pixel_x=(@sobel_x[0][0]*t1)+(@sobel_x[0][1]*t2)+(@sobel_x[0][2]*t3)+(@sobel_x[1][0]*t4)+(@sobel_x[1][1]*t5)+(@sobel_x[1][2]*t6)+(@sobel_x[2][0]*t7)+(@sobel_x[2][1]*t8)+(@sobel_x[2][2]*t9)
+					pixel_y=(@sobel_y[0][0]*t1)+(@sobel_y[0][1]*t2)+(@sobel_y[0][2]*t3)+(@sobel_y[1][0]*t4)+(@sobel_y[1][1]*t5)+(@sobel_y[1][2]*t6)+(@sobel_y[2][0]*t7)+(@sobel_y[2][1]*t8)+(@sobel_y[2][2]*t9)
+					return Math.sqrt(pixel_x * pixel_x + pixel_y * pixel_y).ceil
+				else
+					return 0
+				end
+			else
+				return @sobels[y * @width + x]
+			end
+		end
+		##
+		# Retrieve the Sobel values for every pixel and set it as @sobel.
+		def getSobels
+			if !defined?(@sobels)
+				l = []
+				for xy in 0...(@width * @height)
+					s = self.getSobel(xy % @width, (xy/@width).floor)
+					l.push(s)
+				end
+				@sobels = l
+			end
+			return @sobels
+		end
+		##
+		# Retrieve the Sobel value and color of a pixel.
+		def getSobelAndColor(x, y)
+			return {
+				"sobel" => self.getSobel(x, y),
+				"color" => self[x, y]
+			}
+		end
+		##
+		# Retrieve the color of a pixel.
+		def [](x, y)
+			return @modified[x, y]
+		end
+		##
+		# Set the color of a pixel.
+		def []=(x, y, color)
+			@modified[x, y] = color
+		end
+		##
+		# Return the original, unmodified image.
+		def returnOriginal
+			return @original
+		end
+		##
+		# Return the modified image.
+		def returnModified
+			return @modified
+		end
+	end
+end

data/lib/pxlsrt/lines.rb

@@ -87,8 +87,8 @@ module Pxlsrt
 		# Outputs random slices of an array.
 		# 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
+		def self.randomSlices(mainLength, minLength, maxLength)
+			len=mainLength-1
 			if len!=0
 				min=[minLength, maxLength].min
 				max=[maxLength, minLength].max

data/lib/pxlsrt/smart.rb

@@ -28,7 +28,6 @@ module Pxlsrt
 				:verbose => false,
 				:absolute => false,
 				:threshold => 20,
-				:sorted => 2,
 				:trusted => false,
 				:middle => false
 			}
@@ -41,7 +40,6 @@ module Pxlsrt
 				:verbose => [false, true],
 				:absolute => [false, true],
 				:threshold => [{:class => [Float, Fixnum]}],
-				:sorted => [{:class => [Fixnum]}],
 				:trusted => [false, true],
 				:middle => :anything
 			}
@@ -66,166 +64,72 @@ module Pxlsrt
 					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]
-				grey=img.grayscale
-				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)
-						t1=ChunkyPNG::Color.r(grey[x-1,y-1])
-						t2=ChunkyPNG::Color.r(grey[x,y-1])
-						t3=ChunkyPNG::Color.r(grey[x+1,y-1])
-						t4=ChunkyPNG::Color.r(grey[x-1,y])
-						t5=ChunkyPNG::Color.r(grey[x,y])
-						t6=ChunkyPNG::Color.r(grey[x+1,y])
-						t7=ChunkyPNG::Color.r(grey[x-1,y+1])
-						t8=ChunkyPNG::Color.r(grey[x,y+1])
-						t9=ChunkyPNG::Color.r(grey[x+1,y+1])
-						pixel_x=(sobel_x[0][0]*t1)+(sobel_x[0][1]*t2)+(sobel_x[0][2]*t3)+(sobel_x[1][0]*t4)+(sobel_x[1][1]*t5)+(sobel_x[1][2]*t6)+(sobel_x[2][0]*t7)+(sobel_x[2][1]*t8)+(sobel_x[2][2]*t9)
-						pixel_y=(sobel_y[0][0]*t1)+(sobel_y[0][1]*t2)+(sobel_y[0][2]*t3)+(sobel_y[1][0]*t4)+(sobel_y[1][1]*t5)+(sobel_y[1][2]*t6)+(sobel_y[2][0]*t7)+(sobel_y[2][1]*t8)+(sobel_y[2][2]*t9)
-						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.getRGBA(img[x, y]) })
-				end
-				if options[:vertical]==true
-					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
-					k=Pxlsrt::Lines.rotateImage(k,w,h,3)
-					w,h=h,w
+				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
+				Pxlsrt::Helpers.verbose("Retrieving edges") if options[:verbose]
+				png.getSobels
 				if !options[:diagonal]
-					lines=Pxlsrt::Lines.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::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::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre), options[:middle]))
-						end
-					end
+					iterator = 0...(lines.length)
 				else
-					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
-					dia=Pxlsrt::Lines.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)
+					iterator = lines.keys
+				end
+				Pxlsrt::Helpers.verbose("Dividing and pixel sorting lines") if options[:verbose]
+				for k in iterator
+					line = lines[k]
+					divisions = []
+					division = []
+					if line.length > 1
+						for pixel in 0...(line.length)
+							if !options[:vertical] and !options[:diagonal]
+								xy = png.horizontalXY(k, pixel)
+							elsif options[:vertical] and !options[:diagonal]
+								xy = png.verticalXY(k, pixel)
+							elsif !options[:vertical] and options[:diagonal]
+								xy = png.diagonalXY(k, pixel)
+							elsif options[:vertical] and options[:diagonal]
+								xy = png.rDiagonalXY(k, pixel)
 							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::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(u.keys, options[:method], nre).map { |x| u[x] }.flatten(1), options[:middle]))
+							pxlSobel = png.getSobelAndColor(xy["x"], xy["y"])
+							if division.length == 0 or (options[:absolute] ? pxlSobel["sobel"] : pxlSobel["sobel"] - division.last["sobel"]) <= options[:threshold]
+								division.push(pxlSobel)
+							else
+								divisions.push(division)
+								division = [pxlSobel]
 							end
-						else
-							for band in dia[j]
-								ell.concat(Pxlsrt::Lines.handleMiddlate(Pxlsrt::Colors.pixelSort(band, options[:method], nre), options[:middle]))
+							if pixel == line.length - 1
+								divisions.push(division)
+								division = []
 							end
 						end
-						dia[j]=ell
 					end
-					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
-					image=Pxlsrt::Lines.fromDiagonals(dia,w)
-				end
-				if options[:vertical]==true
-					Pxlsrt::Helpers.verbose("Rotating back (because of vertical mode).") if options[:verbose]
-					image=Pxlsrt::Lines.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.arrayToRGBA(image[px])
+					newLine = []
+					for band in divisions
+						newLine.concat(
+							Pxlsrt::Helpers.handlePixelSort(
+								band.map { |sobelAndColor| sobelAndColor["color"] },
+								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
@@ -237,7 +141,7 @@ module Pxlsrt
 					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
+				return png.returnModified
 			else
 				Pxlsrt::Helpers.error("Options specified do not follow the correct format.") if options[:verbose]
 				return

data/lib/pxlsrt/version.rb

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

data/lib/pxlsrt.rb

@@ -1,6 +1,7 @@
-require "pxlsrt/version"
-require "pxlsrt/helpers"
-require "pxlsrt/lines"
-require "pxlsrt/colors"
-require "pxlsrt/brute"
+require "pxlsrt/version"
+require "pxlsrt/helpers"
+require "pxlsrt/lines"
+require "pxlsrt/image"
+require "pxlsrt/colors"
+require "pxlsrt/brute"
 require "pxlsrt/smart"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pxlsrt
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: '1.6'
 platform: ruby
 authors:
 - EVA-01
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-06 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,6 +79,7 @@ files:
 - lib/pxlsrt/brute.rb
 - lib/pxlsrt/colors.rb
 - lib/pxlsrt/helpers.rb
+- lib/pxlsrt/image.rb
 - lib/pxlsrt/lines.rb
 - lib/pxlsrt/smart.rb
 - lib/pxlsrt/version.rb