1: #!/usr/bin/env/rexx
2: /**
3: Just a little program to excercise (some of) the xmlDOM classes.
4:
5: Transforms the XML result of a google maps directions query such as:
6:
7: http://maps.googleapis.com/maps/api/directionsxml?origin=Uithoorn,NL&destination=Nieuw+Vennep,NL&mode=bicycling
8:
9: into a GPX file, that can be downloaded/used on smartphones/tablets with apps such as Viewranger, OSMAnd+ and MyTrails.
10: @param xmlFile - the name of the xml-file to proces
11: @return gpxStream - The GPX file to STDOUT (,which can be redirected to a file of course).
12: */
13: parse arg xmlFile
14: signal on user domException name domException
15: --trace i
16: xmlStream = .stream~new(xmlFile)
17: parser = .xmlParser~new(.dom1Builder~new)
18: dom = parser~parseStream(xmlStream)
19: -- One leg from Google is treated as one GPX track
20: doc = dom~documentElement
21: -- Use the travel mode as content for the tag in GPX and elements
22: travel_mode = doc~getElementsByTagName("travel_mode")~item(0)~firstChild~nodeValue
23: -- Google requires to show the following 2 items
24: copyrights = doc~getElementsByTagName("copyrights")
25: warnings = doc~getElementsByTagName("warning")
26: -- Retrieve from and to address
27: startAddress = doc~getElementsByTagName("start_address")~item(0)~firstChild~nodeValue
28: endAddress = doc~getElementsByTagName("end_address")~item(0)~firstChild~nodeValue
29: -- Get the latitude and longitude boundaries
30: bounds = doc~getElementsByTagName("bounds")~item(0)
31: maxlat = bounds~getElementsByTagName("northeast")~item(0)~childNodes~item(0)~firstChild~nodeValue
32: maxlon = bounds~getElementsByTagName("northeast")~item(0)~childNodes~item(1)~firstChild~nodeValue
33: minlat = bounds~getElementsByTagName("southwest")~item(0)~childNodes~item(0)~firstChild~nodeValue
34: minlon = bounds~getElementsByTagName("southwest")~item(0)~childNodes~item(1)~firstChild~nodeValue
35: -- Now process the route(s) info, assumption is here just 1 leg
36: legs = doc~getElementsByTagName("route")~item(0)~getElementsByTagName("leg")
37: do l=0 to legs~length-1
38: leg = legs~item(l)
39: legData = .directory~new
40: legData~polyLines = .array~new
41: legData~directions = .array~new
42: legData~routePoints = .array~new
43: legData~distances = .array~new
44: legData~durations = .array~new
45: -- get the encoded polyline strings for each step in this leg
46: encodedPolylines = leg~getElementsByTagName("polyline")
47: -- get the driving instructions for each step in this leg
48: stepDirections = leg~getElementsByTagName("html_instructions")
49: -- get the latitude and longitude for each step start location in this leg
50: stepStartLocations = leg~getElementsByTagName("start_location")
51: -- get the distance for each step in this leg
52: stepDistances = leg~getElementsByTagName("distance")
53: -- get the theoretical duration for each step in this leg
54: stepDurations = leg~getElementsByTagName("duration")
55: -- now process each step
56: steps = leg~getElementsByTagName("step")
57: do s=0 to steps~length-1
58: -- decode the Google encoded polylin string
59: encPoly = encodedPolylines~item(s)~firstChild~firstChild~nodeValue
60: polyline = decodePoly(encPoly)
61: -- and add to the polyline array
62: legData~polyLines~append(polyLine)
63: -- add the directions for each step
64: legData~directions~append(stepDirections~item(s)~firstChild~nodeValue)
65: -- add latitude longitude info for each turning point in this leg
66: lat = stepStartLocations~item(s)~childNodes~item(0)~firstChild~nodeValue
67: lon = stepStartLocations~item(s)~childNodes~item(1)~firstChild~nodeValue
68: legData~routePoints~append(lat lon)
69: -- append the distance and duration info for each step
70: legData~distances~append(stepDistances~item(s)~childNodes~item(1)~firstChild~nodeValue)
71: legData~durations~append(stepDurations~item(s)~childNodes~item(0)~firstChild~nodeValue)
72: end
73: end
74: out = .xmlDOMImplementation~new~createDocument
75: -- append the retrieved xml PI as first child
76: out~appendChild(dom~firstChild)
77: -- create the gpx-tag and its attributes
78: out~appendChild(out~createElement("gpx"))
79: gpx = out~childNodes~item(1)
80: attr = out~createAttribute("version", "1.1")
81: attr~ownerElement = gpx
82: gpx~setAttributeNode(attr)
83: attr = out~createAttribute("creator", "rji@xs4all.nl")
84: attr~ownerElement = gpx
85: gpx~setAttributeNode(attr)
86: attr = out~createAttribute("xmlns", "http://www.topografix.com/GPX/1/1")
87: attr~ownerElement = gpx
88: gpx~setAttributeNode(attr)
89: attr = out~createAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
90: attr~ownerElement = gpx
91: gpx~setAttributeNode(attr)
92: attr = out~createAttribute("xsi:schemaLocation","http://www.topografix.com/GPX/1/1/gpx.xsd")
93: attr~ownerElement = gpx
94: gpx~setAttributeNode(attr)
95: -- handle the gpx metadata
96: metadata = gpx~appendChild(out~createElement("metadata"))
97: -- First the copyright notice(s)
98: text = ''
99: do i=0 to copyrights~length-1
100: text ||= copyrights~item(i)~firstChild~nodeValue || .endofline
101: end
102: text = text~substr(1,text~length-2)
103: textNode = out~createTextNode(text)
104: copyright = out~createElement("copyright")
105: copyright~appendChild(textNode)
106: metadata~appendChild(copyright)
107: -- Second the author info
108: author = out~createElement("author")
109: name = out~createElement("name")
110: text = out~createTextNode("Ruurd J. Idenburg")
111: name~appendChild(text)
112: author~appendChild(name)
113: link = out~createElement("link")
114: attr = out~createAttribute("href", "http://www.idenburg.net")
115: attr~ownerElement = link
116: link~setAttributeNode(attr)
117: author~appendChild(link)
118: metadata~appendChild(author)
119: -- Third the description, i.e the warning(s)
120: desc = out~createElement("desc")
121: text = ''
122: do i=0 to warnings~length-1
123: text ||= warnings~item(i)~firstChild~nodeValue || .endofline
124: end
125: text = text~substr(1,text~length-2)
126: textNode = out~createTextNode(text)
127: desc~appendChild(textNode)
128: metadata~appendChild(desc)
129: -- Fourth the name, in this case the input filename
130: name = out~createElement("name")
131: text = out~createTextNode(xmlStream~string)
132: name~appendChild(text)
133: metadata~insertBefore(name,metadata~childNodes~item(0))
134: -- Fifth the keywords, in this case the travel_mode
135: keywords = out~createElement("keywords")
136: text = out~createTextNode(travel_mode)
137: keywords~appendChild(text)
138: metadata~appendChild(keywords)
139: -- Sixth the geographical bounds of the route/track
140: bounds = out~createElement("bounds")
141: attr = out~createAttribute("minlat", minlat)
142: attr~ownerElement = bounds
143: bounds~setAttributeNode(attr)
144: attr = out~createAttribute("minlon", minlon)
145: attr~ownerElement = bounds
146: bounds~setAttributeNode(attr)
147: attr = out~createAttribute("maxlat", maxlat)
148: attr~ownerElement = bounds
149: bounds~setAttributeNode(attr)
150: attr = out~createAttribute("maxlon", maxlon)
151: attr~ownerElement = bounds
152: bounds~setAttributeNode(attr)
153: metadata~appendChild(bounds)
154: -- gpx metadata is handled, now process the route (rte-tag)
155: rte = out~createElement("rte")
156: -- append route as next child to gpx-tag
157: gpx~appendChild(rte)
158: -- the name of the route
159: name = out~createElement("name")
160: rte~appendChild(name)
161: text = out~createTextNode(startAddress"-"endAddress)
162: name~appendChild(text)
163: -- type is travel_mode
164: type = out~createElement("type")
165: rte~appendChild(type)
166: text = out~createTextNode(travel_mode)
167: type~appendChild(text)
168: -- Now do the route points and driving instructions
169: do i=1 to legData~routePoints~items
170: routePoint = legData~routePoints[i]
171: rtept = out~createElement("rtept")
172: -- latitude and longitude are attributes
173: attr = out~createAttribute("lat", routePoint~word(1))
174: attr~ownerElement = rtept
175: rtept~setAttributeNode(attr)
176: attr = out~createAttribute("lon", routePoint~word(2))
177: attr~ownerElement = rtept
178: rtept~setAttributeNode(attr)
179: rte~appendChild(rtept)
180: -- cmt-tag contains driving instructions and distance to next turning point
181: cmt = out~createElement("cmt")
182: text = out~createTextNode(doEntities(legData~directions[i])"; Go" legData~distances[i]"." )
183: cmt~appendChild(text)
184: rtept~appendChild(cmt)
185: end
186: -- Route info handled now do the track(s)
187: -- Create the trk-tag as next child of gpx-tag
188: trk = out~createElement("trk")
189: gpx~appendChild(trk)
190: -- track name
191: name = out~createElement("name")
192: trk~appendChild(name)
193: text = out~createTextNode(startAddress"-"endAddress)
194: name~appendChild(text)
195: -- track type,i.e travel_mode
196: type = out~createElement("type")
197: trk~appendChild(type)
198: text = out~createTextNode(travel_mode)
199: type~appendChild(text)
200: -- a track can have multiple track segments
201: trkseg = out~createElement("trkseg")
202: trk~appendChild(trkseg)
203: -- do the track points
204: do i=1 to legData~polyLines~items
205: -- each polyline is an array of lat lon pairs
206: polyLine = legData~polyLines[i]
207: do j=1 to polyLine~items
208: -- each track point is a lat lon pair
209: trackPoint = polyLine[j]
210: trkpt = out~createElement("trkpt")
211: attr = out~createAttribute("lat", trackPoint~word(1))
212: attr~ownerElement = trkpt
213: trkpt~setAttributeNode(attr)
214: attr = out~createAttribute("lon", trackPoint~word(2))
215: attr~ownerElement = trkpt
216: trkpt~setAttributeNode(attr)
217: trkseg~appendChild(trkpt)
218: end
219: end
220: -- End of GPX DOM build, now create the GPX file
221: call domWriter out~childNodes, .queue~new
222: exit
223:
224: /**
225: Encodes entities for xml text
226: @param text - the text with plain entities
227: @return text - the encoded text
228: */
229: doEntities: Procedure
230: parse arg text
231: text = text~changeStr('&',"&") -- must be first
232: text = text~changeStr('<',"<")
233: text = text~changeStr('>',">")
234: text = text~changeStr("'","'")
235: text = text~changeStr('"',""")
236: return text
237: /**
238: Walks the DOM tree recursively and generates the GPX tags and their contents
239: @param nodes - a xmlNodeList to start the treewalk
240: @param tagStack - a .queue instance to keep track of nested tags
241: @return gpxStream - the gpx contents to STDOUT
242: */
243: ::routine domWriter
244: use strict arg nodes, tagStack
245: indent = tagStack~items*2
246: do n=0 to nodes~length-1
247: node = nodes~item(n)
248: select
249: -- 1 elementNode
250: when node~nodeType=.xmlNode~elementNode then do
251: tag = node~tagName
252: attributes = ''
253: if node~attributes~length>0 then do
254: attrDir = node~attributes~toOorexxDirectory
255: do i over attrDir
256: attrName = attrDir[i]~name
257: attrValue = attrDir[i]~value
258: delimiter = '"'
259: if value~pos('"')>0 then delimiter = "'"
260: if (delimiter='"')
261: then attributes = attributes attrName'="'attrValue'"'
262: else attributes = attributes attrName"='"attrValue"'"
263: end
264: end
265: if attributes~length>0 then attributes = ' 'attributes
266: if node~childNodes~length>0 then do
267: say ' '~copies(indent) || '<'tag || attributes || '>'
268: tagStack~push(tag)
269: call domWriter node~childNodes, tagStack
270: end
271: else do
272: say ' '~copies(indent) || '<'tag || attributes || ">'
273: end
274: end
275: -- 2 attributeNode is handled above in elementNode
276: -- 3 textNode
277: when node~nodeType=.xmlNode~textNode then do
278: say ' '~copies(indent) || node~data
279: end
280: -- 4 CDATASectionNode
281: when node~nodeType=.xmlNode~cdataSectionNode then do
282: say ' '~copies(indent) || ""
283: end
284: -- 5 entityReferenceNode
285: when node~nodeType=.xmlNode~entityReferenceNode then do
286: nop
287: end
288: -- 6 entityNode
289: when node~nodeType=.xmlNode~entityNode then do
290: nop
291: end
292: -- 7 PINode
293: when node~nodeType=.xmlNode~processingInstructionNode then do
294: target = node~target
295: data = node~data
296: say ' '~copies(indent) || ""
297: end
298: -- 8 commentNode
299: when node~nodeType=.xmlNode~commentNode then do
300: data = node~data
301: say ' '~copies(indent) || ""
302: end
303: -- 9 documentNode handled by the caller
304: -- 10 documentTypeNode
305: when node~nodeType=.xmlNode~documentTypeNode then do
306: nop
307: end
308: -- 11 documentFragmentNode
309: when node~nodeType=.xmlNode~documentFragmentNode then do
310: nop
311: end
312: -- 12 notationNode
313: when node~nodeType=.xmlNode~notationNode then do
314: nop
315: end
316: otherwise do
317: --say '====================='node~nodeType
318: nop
319: end
320: end
321: end
322: if tagStack~items>0 then do
323: tag = tagStack~pull
324: indent = tagStack~items*2
325: say ' '~copies(indent) || "'
326: end
327: return
328: /**
329: Exception catcher
330: */
331: domException:
332: say condition('A')
333: say condition('D')
334: exit
335:
336: ::requires 'xmlDOM.cls'
