Class: Pxlsrt::Smart

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

Overview

Smart sorting uses sorted-finding algorithms to create bands to sort, as opposed to brute sorting which doesn’t care for the content or sorteds, just a specified range to create bands.

Class Method Summary collapse

Class Method Details

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

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



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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/pxlsrt/smart.rb', line 19

def self.smart(input, o={})
  startTime=Time.now
  defOptions={
    :reverse => false,
    :vertical => false,
    :diagonal => false,
    :smooth => false,
    :method => "sum-rgb",
    :verbose => false,
    :absolute => false,
    :threshold => 20,
    :trusted => false,
    :middle => false
  }
  defRules={
    :reverse => :anything,
    :vertical => [false, true],
    :diagonal => [false, true],
    :smooth => [false, true],
    :method => Pxlsrt::Colors::METHODS,
    :verbose => [false, true],
    :absolute => [false, true],
    :threshold => [{:class => [Float, 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 exist"
      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("Smart mode.") 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
    Pxlsrt::Helpers.verbose("Retrieving edges") if options[:verbose]
    png.getSobels
    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 = []
      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
          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
          if pixel == line.length - 1
            divisions.push(division)
            division = []
          end
        end
      end
      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
      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.round(4)!=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::Smart.smart to input and output from pne method.



11
12
13
14
15
16
 
# File 'lib/pxlsrt/smart.rb', line 11

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