2 class GraphController < ApplicationController
6 def initialize(options)
8 @graph = options[:graph_type].new(size)
10 @graph.theme = { :colors => ['#000000', '#00FFFF', '#FFCC00', '#990033'],
11 :background_colors => ['#74ce00', '#ffffff'] }
12 @graph.font = File.expand_path('/usr/X11R6/lib/X11/fonts/TTF/Vera.ttf',
15 # fill in the data with the optional data name
16 #Check to see if multiple datasets, if so, fill them all!
17 if options[:data].is_a?(Hash)
18 options[:data].each_pair do |name, array|
19 @graph.data( name, array)
21 #if each dataset nameless, will have only multiple arrays
22 elsif options[:data].size > 1 && options[:data].all? {|i| i.is_a?(Array)}
23 options[:data].each do |array|
24 @graph.data( options.fetch(:data_name, "Data"), array)
26 else #one dimensional array, just pass it in
27 @graph.data( options.fetch(:data_name, "Data"), options[:data] )
30 # set the labels or create an empty hash
31 @graph.labels = options[:interval_labels] \
32 if options.has_key?(:interval_labels) and \
33 options[:interval_labels].class == Hash
34 @graph.x_axis_label = options[:x_axis_label] \
35 if options.has_key?(:x_axis_label)
36 @graph.y_axis_label = options[:y_axis_label] \
37 if options.has_key?(:y_axis_label)
38 @graph.title = options[:title] if options.has_key?(:title)
40 @graph.minimum_value = 0.0
45 return([@graph.to_blob, {:disposition => 'inline', :type => 'image/png'}])
50 # produce a graph of votes per day during an election
52 @election = Election.find(params[:id])
53 data, labels = get_votes_per_day_data(@election)
55 graph = GruffGraff.new( :graph_type => Gruff::Line,
56 :data_name => @election.name,
58 :interval_labels => labels,
59 :title => "Voters Per Day",
60 :x_axis_label => "Data",
61 :y_axis_label =>"Number of Votes")
62 send_data(*graph.output)
65 #will place votes in a fixed number of intervals, and shows votes over time
66 def votes_per_interval
67 @election = Election.find(params[:id])
68 data, labels, scale = get_votes_per_interval_data(@election)
70 graph = GruffGraff.new( :graph_type => Gruff::Line,
71 :data_name => @election.name,
73 :interval_labels => labels,
74 :title => "Voters Over Time",
75 :x_axis_label => scale,
76 :y_axis_label => "Number of Votes")
77 send_data(*graph.output)
81 @election = Election.find(params[:id])
82 #pref_tally = make_preference_tally(@election)
84 #@borda_result = BordaVote.new(pref_tally).result
85 @election.results unless @election.borda_result
86 data, labels = get_borda_points(@election.borda_result)
88 graph = GruffGraff.new( :graph_type => Gruff::Bar,
89 :data_name => @election.name,
91 :interval_labels => labels,
92 :title => "Points Per Candidate",
93 :y_axis_label => "Points",
94 :x_axis_label => "Candidate")
95 send_data(*graph.output)
97 #Acording to Tufte, small, concomparitive, highly labeled data sets usually
98 # belong in tables. The following is a bar graph...but would it be better
100 def choices_positions
101 @election = Election.find(params[:id])
102 pref_tally = make_preference_tally(@election)
104 fulldata, labels = get_positions_info(@election)
107 @election.candidates.each_with_index do |candidate, index|
108 legend[candidate.name] = fulldata[index]
111 graph = GruffGraff.new( :graph_type => Gruff::Bar,
113 :interval_labels => labels,
114 :title => "Times Voted in Each Position",
115 :y_axis_label => "Number of Times Ranked",
116 :x_axis_label => "Rank")
117 send_data(*graph.output)
122 def get_positions_info(election)
125 rank_labels = Hash.new
127 election.candidates.each do |candidate|
128 buckets[candidate.id] = []
129 buckets2[candidate.id] = []
132 election.votes.each do |vote|
133 vote.rankings.each do |ranking|
134 buckets[ranking.candidate_id] << ranking.rank
138 buckets.each_pair do |id, array|
139 (1..election.candidates.size).each do |i|
140 buckets2[id] << (array.find_all {|rank| rank == i}).size
144 election.votes.each do |vote|
145 vote.rankings.size.times do |i|
146 rank_labels[i] = (i+1).to_s
150 return buckets2.values, rank_labels
154 # generate the data and labels for each graph
155 def get_votes_per_day_data(election)
156 voter_days = Array.new
157 unique_days = Array.new
158 total_per_day = Array.new
159 election_days = Hash.new
161 #turn election startdate into date object, and create the range of election
162 startdate = Date.parse(election.startdate.to_s)
163 election_range = startdate..Date.today
165 # create a hash with all the dates of the election in String format
166 # referenced by their order in the election
167 election_range.each_with_index do |day, index|
168 election_days[index] = day.to_s
171 # Now I need to create an array with all the times votes were made
172 election.votes.each do |vote|
173 next unless vote.time
174 voter_days << Date.parse(vote.time.to_s)
178 # Now I need to count how many times each each date appears in voter_days,
179 # and put that number into a votes_per_day array, the 'data' for the graph
180 #Create an array of unique days from voter_days
181 voter_days.each do |day|
182 unless unique_days.any? {|date| date.eql?(day)}
188 #find all dates where those days = date at current index, put size of returned
189 #array into total_per_day
190 unique_days.each_with_index do |date, index|
191 total_per_day << (voter_days.select {|day| day.eql?(date)}).size
194 # return the data and the labels
195 return total_per_day, election_days
199 def get_votes_per_interval_data(election)
200 labels_hash = Hash.new
202 total_per_interval = Array.new
205 starttime = election.startdate
206 timedelta = Time.now - starttime
208 interval_length = timedelta/numcols
210 # Make a hash, buckets, indexed by time intervals and containing empty arrays
211 # The time object must come first in addition!
212 # i would start at 0, i+1 goes from 1 up till numcols
213 numcols.times {|i| buckets[starttime + ((i+1)*interval_length)] = []}
215 # Put votes into bucket according to the time interval to which they belong,
216 # referenced by their key
217 # Will build a graph over time, as each successive interval will have more
219 election.votes.each do |vote|
220 next unless vote.time
221 buckets.keys.sort.each do |inter|
223 buckets[inter] << vote
228 total_per_interval = buckets.keys.sort.collect {|key| buckets[key].size}
230 # Create the hash for the labels. Each graph has ten columns, and three
232 if timedelta < 2.hours #under two hours use minutes for labels
233 labels_hash[0] = starttime.min.to_s
234 labels_hash[(numcols/2)-1] = (starttime + (timedelta/2)).min.to_s
235 labels_hash[numcols-1] = Time.now.min.to_s
236 interval_type = "Minute of the Hour"
237 elsif timedelta < 2.days #more than 2 hours means use hours for labels
238 labels_hash[0] = starttime.hour.to_s
239 labels_hash[(numcols/2)-1] = (starttime + (timedelta/2)).hour.to_s
240 labels_hash[numcols-1] = Time.now.hour.to_s
241 interval_type = "Hour of the Day on 24 hour scale"
242 else #more than 2 days means use dates for labels
243 labels_hash[0] = (Date.parse(starttime.to_s)).to_s
244 labels_hash[(numcols/2)-1] = (Date.parse((starttime + (timedelta/2)).to_s)).to_s
245 labels_hash[numcols-1] = (Date.today).to_s
246 interval_type = "The Date"
249 # Make sure to return an array for data and hash for labels
250 return total_per_interval, labels_hash, interval_type
253 def get_borda_points(result)
257 #Populate points with an sorted array from election.votes hash
258 #biggest to smallest will go from left to right
259 points = result.election.votes.sort do |a, b|
261 end.collect {|i| i[1]}
264 result.ranked_candidates.each_with_index do |candidate, index|
265 labels[index] = Candidate.find(candidate).name
268 return points, labels
271 #most vote result objects require an array of vote arrays, which this will make
272 def make_preference_tally(election)
273 preference_tally = Array.new
274 @election.voters.each do |voter|
275 next unless voter.voted?
276 preference_tally << voter.vote.rankings.sort.collect \
277 { |ranking| ranking.candidate.id }
279 return preference_tally