pxlsrt 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7566105f4c2c7515705d43a31ab5e8013a484b0a
-  data.tar.gz: 2130b0bd776aa27fe9baf3e8f770e7219f6499ec
+  metadata.gz: b9904ad442d8b272d6aa9e196085efc13e9e6c0e
+  data.tar.gz: 145c0cae2d397312d85a4c3627581eb2076a95a8
 SHA512:
-  metadata.gz: b6dc7505dc8e83de9cb37f2a99db63268f15cd041f14e740c6401862fe87614cda01cf8b2ed9760f3c91d4024eb22b329f4caafea96f6dc50c1aaae8dcf12e91
-  data.tar.gz: de29855fa6fb47ef7a61408d842aeba64dc8c2dfc9da3b773e390dbe4abda2e62bca4813227647db426f290aa14a8112b5722d7a31a51c76b1a58629e8d4bd7d
+  metadata.gz: 2fc1fd26d049302824076066ec5a495ba27f76402263e20aba2a02dd673357a6b46d4b5685bea5a1c6935ad51512ba566ded3ee43b0f786f0e1baf1dd80aa25d
+  data.tar.gz: 204629fbe1687469b21fea3f1bf2a94350fa2ad1b657625cbd753cf11a9ddba06a683542bc470678cab1116720263ba491ca3190368b6d058ce8d4ed7e3e3dd9

data/lib/pxlsrt/brute.rb

@@ -80,14 +80,14 @@ module Pxlsrt
 				end
 				if options[:vertical]==true
 					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
-					kml=Pxlsrt::Colors.rotateImage(kml, w, h, 3)
+					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::Colors.imageRGBLines(kml, w)
-						sliceRanges=Pxlsrt::Colors.randomSlices(m, options[:min], options[:max])
+					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
@@ -105,10 +105,10 @@ module Pxlsrt
 					end
 				else
 					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
-					dia=Pxlsrt::Colors.getDiagonals(kml,w,h)
+					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::Colors.randomSlices(dia[m], options[:min], options[:max])
+						sliceRanges=Pxlsrt::Lines.randomSlices(dia[m], options[:min], options[:max])
 						newInTown=[]
 						if options[:smooth]!=true
 							for ranger in sliceRanges
@@ -125,11 +125,11 @@ module Pxlsrt
 						dia[m]=newInTown
 					end
 					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
-					toImage=Pxlsrt::Colors.fromDiagonals(dia,w)
+					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::Colors.rotateImage(toImage, w,h,1)
+					toImage=Pxlsrt::Lines.rotateImage(toImage, w,h,1)
 					w,h=h,w
 				end
 				Pxlsrt::Helpers.verbose("Giving pixels new RGB values...") if options[:verbose]

data/lib/pxlsrt/colors.rb

@@ -2,7 +2,7 @@ require "oily_png"
 
 module Pxlsrt
 	##
-	# Includes color and image operations.
+	# Includes color operations.
 	class Colors
 		##
 		# Converts a ChunkyPNG pixel into an array of the red, green, blue, and alpha values
@@ -15,65 +15,6 @@ module Pxlsrt
 			return File.read(path).bytes==[137, 80, 78, 71, 10]
 		end
 		##
-		# ChunkyPNG's rotation was a little slow and doubled runtime.
-		# This "rotates" an array, based on the width and height.
-		# It uses math and it's really cool, trust me.
-		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
-		##
-		# 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:
-		# [[0, 5], [6, 7], [8, 10]]
-		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
-		##
 		# This is really lame. Adds first three values of an array together.
 		def self.pxldex(pxl)
 			return pxl[0]+pxl[1]+pxl[2]
@@ -202,52 +143,9 @@ module Pxlsrt
 			end
 		end
 		##
-		# Uses math to turn an array into an array of diagonals.
-		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
-		##
-		# Uses math to turn an array of diagonals into a linear array.
-		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
-		##
 		# Turns an RGB-like array into ChunkyPNG's color
 		def self.arrayToRGBA(a)
 			return ChunkyPNG::Color.rgba(a[0], a[1], a[2], a[3])
 		end
-		##
-		# Used in determining Sobel values.
-		def self.sobelate(i, x,y)
-			return ChunkyPNG::Color.to_grayscale_bytes(i[x,y]).first
-		end
 	end
 end

data/lib/pxlsrt/lines.rb

@@ -0,0 +1,103 @@
+module Pxlsrt
+	##
+	# "Line" operations used on arrays f colors.
+	class Lines
+		##
+		# ChunkyPNG's rotation was a little slow and doubled runtime.
+		# This "rotates" an array, based on the width and height.
+		# It uses math and it's really cool, trust me.
+		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
+		##
+		# 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:
+		# [[0, 5], [6, 7], [8, 10]]
+		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
+		##
+		# Uses math to turn an array into an array of diagonals.
+		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
+		##
+		# Uses math to turn an array of diagonals into a linear array.
+		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
+	end
+end

data/lib/pxlsrt/smart.rb

@@ -80,12 +80,22 @@ module Pxlsrt
 				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)
-						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))
+						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
@@ -94,11 +104,11 @@ module Pxlsrt
 				end
 				if options[:vertical]==true
 					Pxlsrt::Helpers.verbose("Rotating image for vertical mode...") if options[:verbose]
-					k=Pxlsrt::Colors.rotateImage(k,w,h,3)
+					k=Pxlsrt::Lines.rotateImage(k,w,h,3)
 					w,h=h,w
 				end
 				if !options[:diagonal]
-					lines=Pxlsrt::Colors.imageRGBLines(k, w)
+					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
@@ -148,7 +158,7 @@ module Pxlsrt
 					end
 				else
 					Pxlsrt::Helpers.verbose("Determining diagonals...") if options[:verbose]
-					dia=Pxlsrt::Colors.getDiagonals(k,w,h)
+					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=[]
@@ -204,11 +214,11 @@ module Pxlsrt
 						dia[j]=ell
 					end
 					Pxlsrt::Helpers.verbose("Setting diagonals back to standard lines...") if options[:verbose]
-					image=Pxlsrt::Colors.fromDiagonals(dia,w)
+					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::Colors.rotateImage(image,w,h,1)
+					image=Pxlsrt::Lines.rotateImage(image,w,h,1)
 					w,h=h,w
 				end
 				Pxlsrt::Helpers.verbose("Giving pixels new RGB values...") if options[:verbose]

data/lib/pxlsrt/version.rb

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

data/lib/pxlsrt.rb

@@ -1,5 +1,6 @@
 require "pxlsrt/version"
-require "pxlsrt/colors"
 require "pxlsrt/helpers"
+require "pxlsrt/lines"
+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.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - EVA-01
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-07-06 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/lines.rb
 - lib/pxlsrt/smart.rb
 - lib/pxlsrt/version.rb
 homepage: https://github.com/EVA-01/pxlsrt