pxlsrt 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c2b3280ae7ad02daa4da266d7da0754a3d7723b
-  data.tar.gz: 626ec7cf24c9c746e2cdc39f65acd300e2485330
+  metadata.gz: 09e1b556ac3be235df077e4ad203c8bf39074ba2
+  data.tar.gz: 51cc893e04a3e59da9a58e942b850c37aed51b6f
 SHA512:
-  metadata.gz: 0e813eab6fb0931f8448cdc4c389c44fdc0cf958b32304ac8da870be94b5dd5422a925f1d72327b9c629b825eb41d31b6b88aa8d4f09e55c4d45d1a545880127
-  data.tar.gz: 77cb11792128cd2dfd458f76fa8f7adc0dbf1f0fed6bddd679a56bdfa5d8a81e93bb207e3f74a316c8b838052ee07c83d530d04a0bd89270dbc282a6de337cb7
+  metadata.gz: dd2733444b7330897b0ae12211e413c723b7c17558aa5c5bccad62330a492d8fd907d9cce52e61240789e967a89d0b740e6b6d96561c0836829d3b8a727b1607
+  data.tar.gz: 585c68c42645e7dfda6e0ea51d83fb1f3ca73f1f34c4bb0822124b22c5cde7d2ace4f5a828c1ea6c15302664f04a3ce6cd4bbed9a923a7f7e72b1bbeb1a0d726

data/bin/pxlsrt

@@ -4,18 +4,30 @@ require 'rubygems'
 require 'pxlsrt'
 require 'thor'
 
-class PXLSRT < 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, :type => :string, :default => "no", :banner => "[no | reverse | either]", :aliases => "-r", :enum => ["no", "reverse", "either"]
 	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]", :aliases => "-m", :enum => ["sum-rgb", "red", "green", "blue", "sum-hsb", "hue", "saturation", "brightness", "uniqueness", "luma", "random"]
-	class_option :diagonal, :type => :boolean, :default => false, :aliases => "-d"
 	class_option :verbose, :type => :boolean, :default => false, :aliases => "-V"
 
 	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={}
 		for o in options.keys
@@ -28,6 +40,11 @@ class PXLSRT < Thor
 	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={}
 		for o in options.keys
@@ -37,4 +54,4 @@ class PXLSRT < Thor
 	end
 end
 
-PXLSRT.start(ARGV)
+CLI.start(ARGV)

data/lib/pxlsrt/brute.rb

@@ -2,13 +2,20 @@ 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, trusted, o={})
 			kml=Pxlsrt::Brute.brute(inputFileName, trusted, 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, trusted, o={})
 			startTime=Time.now
 			defOptions={
@@ -36,7 +43,17 @@ module Pxlsrt
 				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
 				if input.class==String
 					Pxlsrt::Helpers.verbose("Getting image from file...") if options[:verbose]
-					input=ChunkyPNG::Image.from_file(input)
+					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

data/lib/pxlsrt/colors.rb

@@ -1,10 +1,23 @@
 require "oily_png"
 
 module Pxlsrt
+	##
+	# Includes color and image operations.
 	class Colors
+		##
+		# Converts a ChunkyPNG pixel into an array of the reg, green, and blue values
 		def self.getRGB(pxl)
 			return [ChunkyPNG::Color.r(pxl), ChunkyPNG::Color.g(pxl), ChunkyPNG::Color.b(pxl)]
 		end
+		##
+		# Check if file is a PNG image. ChunkyPNG only works with PNG images. Eventually, I might use conversion tools to add support, but not right now.
+		def self.isPNG?(path)
+			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
@@ -23,9 +36,15 @@ module Pxlsrt
 			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
@@ -54,9 +73,13 @@ module Pxlsrt
 			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]
 		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
@@ -87,6 +110,8 @@ module Pxlsrt
 			end
 			return [h,s,v]
 		end
+		##
+		# Averages an array of RGB-like arrays.
 		def self.colorAverage(ca)
 			if ca.length==1
 				return ca.first
@@ -96,12 +121,18 @@ module Pxlsrt
 			b=((ca.collect { |c| c[2] }).inject{ |sum, el| sum+el }).to_f / ca.size
 			return [r,g,b]
 		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)
 		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))
 		end
+		##
+		# Sorts an array of colors based on a method.
 		def self.pixelSort(list, how, reverse)
 			mhm=[]
 			case how.downcase
@@ -139,6 +170,8 @@ module Pxlsrt
 				return rand(0..1)==0 ? mhm : mhm.reverse
 			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)
@@ -152,6 +185,8 @@ module Pxlsrt
 			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
@@ -173,9 +208,13 @@ module Pxlsrt
 			end
 			return ell
 		end
+		##
+		# Turns an RGB-like array into ChunkyPNG's color
 		def self.arrayToRGB(a)
 			return ChunkyPNG::Color.rgb(a[0], a[1], a[2])
 		end
+		##
+		# Used in determining Sobel values.
 		def self.sobelate(i, x,y)
 			return ChunkyPNG::Color.to_grayscale_bytes(i[x,y]).first
 		end

data/lib/pxlsrt/helpers.rb

@@ -1,14 +1,24 @@
 module Pxlsrt
+	##
+	# Methods not having to do with image or color manipulation.
 	class Helpers
+		##
+		# Determines if a value has content.
 		def self.contented(c)
 			return (c.class!=NilClass and ((defined? c)!="nil") and ((/(\S)/.match("#{c}"))!=nil))
 		end
+		##
+		# Used to output a red string to the terminal.
 		def self.red(what)
 			return "\e[31m#{what}\e[0m"
 		end
+		##
+		# Used to output a cyan string to the terminal.
 		def self.cyan(what)
 			return "\e[36m#{what}\e[0m"
 		end
+		##
+		# Checks if supplied options follow the rules.
 		def self.checkOptions(options, rules)
 			match=true
 			for o in options.keys
@@ -39,9 +49,13 @@ module Pxlsrt
 			end
 			return match
 		end
+		##
+		# Prints an error message.
 		def self.error(what)
 			puts "#{Pxlsrt::Helpers.red("pxlsrt")} #{what}"
 		end
+		##
+		# Prints something.
 		def self.verbose(what)
 			puts "#{Pxlsrt::Helpers.cyan("pxlsrt")} #{what}"
 		end

data/lib/pxlsrt/smart.rb

@@ -1,18 +1,22 @@
 require 'rubygems'
 require 'oily_png'
-require 'json'
-require 'pathname'
-require 'fileutils'
-require 'base64'
 
 module Pxlsrt
+	##
+	# Smart sorting uses edge-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.
 	class Smart
+		##
+		# Uses Pxlsrt::Smart.smart to input and output from pne method.
 		def self.suite(inputFileName, outputFileName, trusted, o={})
 			kml=Pxlsrt::Smart.smart(inputFileName, trusted, o)
 			if Pxlsrt::Helpers.contented(kml)
 				kml.save(outputFileName)
 			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.
 		def self.smart(input, trusted, o={})
 			startTime=Time.now
 			defOptions={
@@ -42,7 +46,17 @@ module Pxlsrt
 				Pxlsrt::Helpers.verbose("Options are all good.") if options[:verbose]
 				if input.class==String
 					Pxlsrt::Helpers.verbose("Getting image from file...") if options[:verbose]
-					input=ChunkyPNG::Image.from_file(input)
+					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

data/lib/pxlsrt/version.rb

@@ -1,3 +1,5 @@
+##
+# The main module, your best friend.
 module Pxlsrt
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pxlsrt
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - EVA-01
@@ -101,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
 summary: Pixel sort PNG files.