Give up after reporting that the query found too many nodes.
[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       return
150     end
151
152     if node_ids.length == 0
153       render :text => "<osm version='0.4'></osm>", :content_type => "text/xml"
154       return
155     end
156
157     # grab the segments
158     segments = Array.new
159     if node_ids.length > 0
160       node_ids_sql = "(#{node_ids.join(',')})"
161       # get the referenced segments
162       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})"
163     end
164     # see if we have any missing nodes
165     segments_nodes = segments.collect {|segment| segment.node_a }
166     segments_nodes += segments.collect {|segment| segment.node_b }
167
168     segments_nodes.uniq!
169
170     missing_nodes = segments_nodes - node_ids
171
172     # get missing nodes if there are any
173     nodes += Node.find(missing_nodes) if missing_nodes.length > 0
174
175     doc = OSM::API.new.get_xml_doc
176
177     # get ways
178     # find which ways are needed
179     segment_ids = segments.collect {|segment| segment.id }
180     ways = Array.new
181     if segment_ids.length > 0
182       way_segments = WaySegment.find_all_by_segment_id(segment_ids)
183       way_ids = way_segments.collect {|way_segment| way_segment.id }
184       ways = Way.find(way_ids) # NB: doesn't pick up segments, tags from db until accessed via way.way_segments etc.
185
186       # seg_ids = way_segments.collect {|way_segment| way_segment.segment_id }
187
188       list_of_way_segs = ways.collect {|way| way.way_segments}
189       list_of_way_segs.flatten!
190
191       list_of_way_segments = list_of_way_segs.collect { |way_seg| way_seg.segment_id }
192
193         else
194           list_of_way_segments = Array.new
195     end
196
197     # - [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
198     segments_to_fetch = (list_of_way_segments.uniq - segment_ids) - [0]
199
200     if segments_to_fetch.length > 0
201       segments += Segment.find(segments_to_fetch)
202     end
203
204     # get more nodes
205     #
206
207     segments_nodes = segments.collect {|segment| segment.node_a }
208     segments_nodes += segments.collect {|segment| segment.node_b }
209
210     node_ids_a = nodes.collect {|node| node.id }
211
212     nodes_to_get = segments_nodes - node_ids_a
213     nodes += Node.find(nodes_to_get) if nodes_to_get.length > 0
214
215     visible_nodes = {}
216     user_display_name_cache = {}
217
218     nodes.each do |node|
219       if node.visible?
220         doc.root << node.to_xml_node(user_display_name_cache)
221         visible_nodes[node.id] = node
222       end
223     end
224
225     visible_segments = {}
226
227     segments.each do |segment|
228       if visible_nodes[segment.node_a] and visible_nodes[segment.node_b] and segment.visible?
229         doc.root << segment.to_xml_node(user_display_name_cache) 
230         visible_segments[segment.id] = segment
231       end
232     end
233
234     ways.each do |way|
235       doc.root << way.to_xml_node(visible_segments, user_display_name_cache) if way.visible?
236     end 
237
238     render :text => doc.to_s, :content_type => "text/xml"
239     
240     #exit when we have too many requests
241     if @@count > MAX_COUNT
242       @@count = COUNT
243       
244       exit!
245     end
246
247   end
248 end