Class: Pxlsrt::Brute

Inherits:
Object
  • Object
show all
Defined in:
lib/pxlsrt/brute.rb

Overview

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 Method Summary collapse

Class Method Details

.brute(input, o = {}) ⇒ Object

The main attraction of the Brute class. Returns a ChunkyPNG::Image that is sorted according to the options provided. Will raise any error that occurs.



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/pxlsrt/brute.rb', line 18

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 => Pxlsrt::Colors::METHODS,
		: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]
					raise "Invalid PNG"
				end
			else
				Pxlsrt::Helpers.error("File #{input} doesn't exist!") if options[:verbose]
				raise "File doesn't exit"
			end
		elsif input.class!=String and input.class!=ChunkyPNG::Image
			Pxlsrt::Helpers.error("Input is not a filename or ChunkyPNG::Image") if options[:verbose]
			raise "Invalid input (must be filename or ChunkyPNG::Image)"
		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
		prr = 0
		len = iterator.to_a.length
		Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) 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
			prr += 1
			Pxlsrt::Helpers.progress("Dividing and pixel sorting lines", prr, len) if options[:verbose]
		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]
		raise "Bad options"
	end
end

.suite(inputFileName, outputFileName, o = {}) ⇒ Object

Uses Pxlsrt::Brute.brute to input and output from one method.



10
11
12
13
14
15
 
# File 'lib/pxlsrt/brute.rb', line 10

def self.suite(inputFileName, outputFileName, o={})
	kml=Pxlsrt::Brute.brute(inputFileName, o)
	if Pxlsrt::Helpers.contented(kml)
		kml.save(outputFileName)
	end
end