Fix deprecation warning.
[rails.git] / app / controllers / api_controller.rb
1 class ApiController < ApplicationController
2
3   after_filter :compress_output
4
5   #COUNT is the number of map requests to allow before exiting and starting a new process
6   @@count = COUNT
7
8   # The maximum area you're allowed to request, in square degrees
9   MAX_REQUEST_AREA = 0.25
10
11
12   # Number of GPS trace/trackpoints returned per-page
13   TRACEPOINTS_PER_PAGE = 5000
14   
15   def trackpoints
16     @@count+=1
17     #retrieve the page number
18     page = params['page'].to_i
19     unless page
20         page = 0;
21     end
22
23     unless page >= 0
24         report_error("Page number must be greater than or equal to 0")
25         return
26     end
27
28     offset = page * TRACEPOINTS_PER_PAGE
29
30     # Figure out the bbox
31     bbox = params['bbox']
32     unless bbox and bbox.count(',') == 3
33       report_error("The parameter bbox is required, and must be of the form min_lon,min_lat,max_lon,max_lat")
34       return
35     end
36
37     bbox = bbox.split(',')
38
39     min_lon = bbox[0].to_f
40     min_lat = bbox[1].to_f
41     max_lon = bbox[2].to_f
42     max_lat = bbox[3].to_f
43
44     # check the bbox is sane
45     unless min_lon <= max_lon
46       report_error("The minimum longitude must be less than the maximum longitude, but it wasn't")
47       return
48     end
49     unless min_lat <= max_lat
50       report_error("The minimum latitude must be less than the maximum latitude, but it wasn't")
51       return
52     end
53     unless min_lon >= -180 && min_lat >= -90 && max_lon <= 180 && max_lat <= 90
54       report_error("The latitudes must be between -90 and 90, and longitudes between -180 and 180")
55       return
56     end
57
58     # check the bbox isn't too large
59     requested_area = (max_lat-min_lat)*(max_lon-min_lon)
60     if requested_area > MAX_REQUEST_AREA
61       report_error("The maximum bbox size is " + MAX_REQUEST_AREA.to_s + ", and your request was too large. Either request a smaller area, or use planet.osm")
62       return
63     end
64
65     # integerise
66     min_lat = min_lat * 1000000
67     max_lat = max_lat * 1000000
68     min_lon = min_lon * 1000000
69     max_lon = max_lon * 1000000
70     # get all the points
71     points = Tracepoint.find(:all, :conditions => ['latitude BETWEEN ? AND ? AND longitude BETWEEN ? AND ?', min_lat.to_i, max_lat.to_i, min_lon.to_i, max_lon.to_i], :select => "DISTINCT *", :offset => offset, :limit => TRACEPOINTS_PER_PAGE, :order => "timestamp DESC" )
72
73     doc = XML::Document.new
74     doc.encoding = 'UTF-8'
75     root = XML::Node.new 'gpx'
76     root['version'] = '1.0'
77     root['creator'] = 'OpenStreetMap.org'
78     root['xmlns'] = "http://www.topografix.com/GPX/1/0/"
79     
80     doc.root = root
81
82     track = XML::Node.new 'trk'
83     doc.root << track
84
85     trkseg = XML::Node.new 'trkseg'
86     track << trkseg
87
88     points.each do |point|
89       trkseg << point.to_xml_node()
90     end
91
92     #exit when we have too many requests
93     if @@count > MAX_COUNT
94       render :text => doc.to_s, :content_type => "text/xml"
95       @@count = COUNT
96       exit!
97     end
98
99     render :text => doc.to_s, :content_type => "text/xml"
100
101   end
102
103   def map
104     GC.start
105     @@count+=1
106
107     # Figure out the bbox
108     bbox = params['bbox']
109     unless bbox and bbox.count(',') == 3
110       report_error("The parameter bbox is required, and must be of the form min_lon,min_lat,max_lon,max_lat")
111       return
112     end
113
114     bbox = bbox.split(',')
115
116     min_lon = bbox[0].to_f
117     min_lat = bbox[1].to_f
118     max_lon = bbox[2].to_f
119     max_lat = bbox[3].to_f
120
121     # check the bbox is sane
122     unless min_lon <= max_lon
123       report_error("The minimum longitude must be less than the maximum longitude, but it wasn't")
124       return
125     end
126     unless min_lat <= max_lat
127       report_error("The minimum latitude must be less than the maximum latitude, but it wasn't")
128       return
129     end
130     unless min_lon >= -180 && min_lat >= -90 && max_lon <= 180 && max_lat <= 90
131       report_error("The latitudes must be between -90 and 90, and longitudes between -180 and 180")
132       return
133     end
134
135     # check the bbox isn't too large
136     requested_area = (max_lat-min_lat)*(max_lon-min_lon)
137     if requested_area > MAX_REQUEST_AREA
138       report_error("The maximum bbox size is " + MAX_REQUEST_AREA.to_s + ", and your request was too large. Either request a smaller area, or use planet.osm")
139       return
140     end
141
142     # get all the nodes
143     nodes = Node.find(:all, :conditions => ['latitude > ? AND longitude > ? AND latitude < ? AND longitude < ? AND visible = 1', min_lat, min_lon, max_lat, max_lon])
144
145     node_ids = nodes.collect {|node| node.id }
146
147     if node_ids.length > 50_000
148       report_error("You requested too many nodes (limit is 50,000). Either request a smaller area, or use planet.osm")
149     end
150
151     if node_ids.length == 0
152       render :text => "<osm version='0.4'></osm>", :content_type => "text/xml"
153       return
154     end
155
156     # grab the segments
157     segments = Array.new
158     if node_ids.length > 0
159       node_ids_sql = "(#{node_ids.join(',')})"
160       # get the referenced segments
161       segments = Segment.find_by_sql "select * from current_segments where visible = 1 and (node_a in #{node_ids_sql} or node_b in #{node_ids_sql})"
162     end
163     # see if we have any missing nodes
164     segments_nodes = segments.collect {|segment| segment.node_a }
165     segments_nodes += segments.collect {|segment| segment.node_b }
166
167     segments_nodes.uniq!
168
169     missing_nodes = segments_nodes - node_ids
170
171     # get missing nodes if there are any
172     nodes += Node.find(missing_nodes) if missing_nodes.length > 0
173
174     doc = OSM::API.new.get_xml_doc
175
176     # get ways
177     # find which ways are needed
178     segment_ids = segments.collect {|segment| segment.id }
179     ways = Array.new
180     if segment_ids.length > 0
181       way_segments = WaySegment.find_all_by_segment_id(segment_ids)
182       way_ids = way_segments.collect {|way_segment| way_segment.id }
183       ways = Way.find(way_ids) # NB: doesn't pick up segments, tags from db until accessed via way.way_segments etc.
184
185       # seg_ids = way_segments.collect {|way_segment| way_segment.segment_id }
186
187       list_of_way_segs = ways.collect {|way| way.way_segments}
188       list_of_way_segs.flatten!
189
190       list_of_way_segments = list_of_way_segs.collect { |way_seg| way_seg.segment_id }
191
192         else
193           list_of_way_segments = Array.new
194     end
195
196     # - [0] in case some thing links to segment 0 which doesn't exist. Shouldn't actually ever happen but it does. FIXME: file a ticket for this
197     segments_to_fetch = (list_of_way_segments.uniq - segment_ids) - [0]
198
199     if segments_to_fetch.length > 0
200       segments += Segment.find(segments_to_fetch)
201     end
202
203     # get more nodes
204     #
205
206     segments_nodes = segments.collect {|segment| segment.node_a }
207     segments_nodes += segments.collect {|segment| segment.node_b }
208
209     node_ids_a = nodes.collect {|node| node.id }
210
211     nodes_to_get = segments_nodes - node_ids_a
212     nodes += Node.find(nodes_to_get) if nodes_to_get.length > 0
213
214     visible_nodes = {}
215     user_display_name_cache = {}
216
217     nodes.each do |node|
218       if node.visible?
219         doc.root << node.to_xml_node(user_display_name_cache)
220         visible_nodes[node.id] = node
221       end
222     end
223
224     visible_segments = {}
225
226     segments.each do |segment|
227       if visible_nodes[segment.node_a] and visible_nodes[segment.node_b] and segment.visible?
228         doc.root << segment.to_xml_node(user_display_name_cache) 
229         visible_segments[segment.id] = segment
230       end
231     end
232
233     ways.each do |way|
234       doc.root << way.to_xml_node(visible_segments, user_display_name_cache) if way.visible?
235     end 
236
237     render :text => doc.to_s, :content_type => "text/xml"
238     
239     #exit when we have too many requests
240     if @@count > MAX_COUNT
241       @@count = COUNT
242       
243       exit!
244     end
245
246   end
247 end