/
readfile.py
427 lines (358 loc) · 13.1 KB
/
readfile.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
from java.awt import *
from java.awt.event import ActionListener, ActionEvent
from java.lang import Object
from java.lang import Runnable
from java.net import URL
from java.util import Collection,HashSet,LinkedList,List,Set
from javax.swing import *
from javax.swing.table import AbstractTableModel
from javax.swing.table import DefaultTableModel
from org.openstreetmap.josm import Main
from org.openstreetmap.josm.data import Preferences;
Main.pref = Preferences()
from org.openstreetmap.josm.data.osm import *;
from org.openstreetmap.josm.data.validation import *;
from org.openstreetmap.josm.tools import *;
from org.openstreetmap.josm.tools.I18n.tr import *
import org.openstreetmap.josm.Main as Main
import org.openstreetmap.josm.command as Command
import org.openstreetmap.josm.data.coor.LatLon as LatLon
import org.openstreetmap.josm.data.osm.BBox as BBox
import org.openstreetmap.josm.data.osm.DataSet as DataSet
import org.openstreetmap.josm.data.osm.Node as Node
import org.openstreetmap.josm.data.osm.TagCollection as TagCollection
import org.openstreetmap.josm.data.osm.Way as Way
import time
from org.openstreetmap.josm.tools.I18n.tr import *
import java.awt.Component
import java.io.File as File;
import java.io.FileInputStream as FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import org.openstreetmap.josm.data.Preferences as Preferences;
import org.openstreetmap.josm.data.osm.OsmPrimitive as OsmPrimitive;
import org.openstreetmap.josm.data.projection.Projection;
import org.openstreetmap.josm.Main as Main;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
import org.openstreetmap.josm.gui.progress.NullProgressMonitor as NullProgressMonitor;
import org.openstreetmap.josm.gui.progress.ProgressMonitor;
import org.openstreetmap.josm.io.IllegalDataException;
import org.openstreetmap.josm.io.OsmImporter as OsmImporter;
import org.openstreetmap.josm.io.OsmImporter.OsmImporterData;
import org.openstreetmap.josm.gui.preferences.projection.ProjectionChoice;
import org.openstreetmap.josm.gui.preferences.projection.ProjectionPreference as ProjectionPreference;
from java.awt.event import KeyEvent
from javax.swing import ImageIcon
from javax.swing import JMenu
from javax.swing import JMenuBar
from javax.swing import JMenuItem
from java.awt.event import MouseListener
from java.awt.event import KeyListener
class ObjectTableModel(AbstractTableModel):
__columns__ = ()
def __init__(self, delegate, columns):
AbstractTableModel.__init__(self)
self.__columns__ = columns
self.delegate= delegate
self._getters = [None] * len(self.__columns__)
for index, column in enumerate(self.__columns__):
self.__columns__[index] = self._validateColumn(column, index)
def _fireItemsChanged(self, start, end):
self.fireTableRowsUpdated(start, end)
def _fireItemsAdded(self, start, end):
self.fireTableRowsInserted(start, end)
def _fireItemsRemoved(self, start, end):
self.fireTableRowsDeleted(start, end)
def setDelegate(self, value):
self._delegate = value
self.fireTableDataChanged()
def getColumnCount(self):
return len(self.__columns__)
def getRowCount(self):
n= len(self.delegate)
# print "row count %d " % n
return n
def getColumnClass(self, columnIndex):
return basestring
# return self.__columns__[columnIndex][1]
def getColumnName(self, columnIndex):
return self.__columns__[columnIndex][0]
def setValueAt(self, aValue, rowIndex, columnIndex):
self[rowIndex][columnIndex] = aValue
def refresh(self):
if len(self) > 0:
self.fireTableRowsUpdated(0, len(self) - 1)
def _validateColumn(self, column, index):
#column = DelegateTableModel._validateColumn(self, column, index)
self._getters[index] = lambda row: row.get(column[2])
return column
def getValueAt(self, rowIndex, columnIndex):
print "getValueAt " + str(rowIndex) + ":"+ str(columnIndex)
#line = self.delegate[rowIndex]
return self.delegate[rowIndex].get(self.__columns__[columnIndex][1])
#return self._getters[columnIndex](line)
def setValueAt(self, aValue, rowIndex, columnIndex):
attrname = self.__columns__[columnIndex][2]
setattr(self[rowIndex], attrname, aValue)
self.fireTableCellUpdated(rowIndex, columnIndex)
def getObjectIndex(self, obj):
for i, row in enumerate(self):
if row == obj:
return i
return - 1
def getSelectedObject(self, table):
assert table.model is self
if table.selectedRow >= 0:
modelRow = table.convertRowIndexToModel(table.selectedRow)
return self[modelRow]
def getSelectedObjects(self, table):
assert table.model is self
selected = []
for viewRow in table.selectedRows:
modelRow = table.convertRowIndexToModel(viewRow)
selected.append(self[modelRow])
return selected
def getVisibleObjects(self, table):
assert table.model is self
visible = []
for viewRow in xrange(table.rowCount):
modelRow = table.convertRowIndexToModel(viewRow)
visible.append(self[modelRow])
return visible
#def EventListener():
class MyListener (MouseListener,KeyListener ) :
def __init__(self, table):
self.table=table
# def mouseReleased(self, e):
# print("Mouse released; # of clicks: " + str(e.getClickCount()))
# print("button: " + str(e.getButton()))
def keyPressed( self,e) :
print("key pressed; " + str(e.getKeyChar()))
# print self.table
# r = self.table.getSelectedRow ()
# print r
rs= self.table.getSelectedRows()
if (e.getKeyChar() == 'l') :
print("lookup; ")
for r in rs :
print r
obj=self.table.getValueAt(r,0)
print obj
#d = LookupDialog()
# def mouseReleased(self,e) :
# print("Mouse released; # of clicks: " + str(e.getClickCount()))
def mouseClicked(self, e):
# print("Mouse clicked; # of clicks: " + str(e.getClickCount()))
# print("button: " + str(e.getButton()))
if (e.getButton() ==3) :
print "Mouse3 clicked; # of clicks: " + str(e.getClickCount())
else :
if (e.getButton() ==2):
print "Mouse2 clicked; # of clicks: " + str(e.getClickCount())
else:
if (e.getButton() ==1):
print "Mouse1 clicked; # of clicks: " + str(e.getClickCount())
class MyFrame (JFrame ) :
def __init__(self,name):
super(MyFrame, self).__init__(name)
def LookupEvent(self, event) :
print self
print event
def DisplayTable (collection):
columns=list(
(
("Street","addr:street"),
("Num","addr:housenumber")
)
)
tm= ObjectTableModel(collection,columns)
frame = MyFrame("street")
frame.setSize(800, 1200)
frame.setLayout(BorderLayout())
table = JTable(tm)
table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
header = table.getTableHeader()
header.setUpdateTableInRealTime(True)
header.setReorderingAllowed(True);
scrollPane = JScrollPane()
scrollPane.getViewport().setView((table))
frame.add(scrollPane)
frame.pack();
frame.setSize(frame.getPreferredSize());
frame.show()
def DisplayStreetTable (collection):
columns=list(
(
("Name","name"),
)
)
tm= ObjectTableModel(collection,columns)
frame = MyFrame("Street Table")
frame.setSize(800, 1200)
frame.setLayout(BorderLayout())
table = JTable(tm)
table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
header = table.getTableHeader()
header.setUpdateTableInRealTime(True)
header.setReorderingAllowed(True);
scrollPane = JScrollPane()
scrollPane.getViewport().setView((table))
# copyButton = JButton('Merge') #,actionPerformed=self.noAction
# frame.add(copyButton)
listener=MyListener(table)
table.addMouseListener(listener)
table.addKeyListener(listener)
menubar = JMenuBar()
file = JMenu("Edit")
file.setMnemonic(KeyEvent.VK_E)
lookup = JMenuItem("Lookup",actionPerformed=frame.LookupEvent)
lookup.setMnemonic(KeyEvent.VK_L)
file.add(lookup)
menubar.add(file)
frame.setJMenuBar(menubar)
frame.add(scrollPane)
frame.pack();
frame.setSize(frame.getPreferredSize());
frame.show()
def isBuilding(p):
v = p.get("building");
if v is not None and v != "no" and v != "entrance":
return True
else:
return False
class BuildingInBuilding :
BUILDING_INSIDE_BUILDING = 2001;
def __init__ (self):
self.primitivesToCheck = LinkedList();
self.index = QuadBuckets();
print 'building in building'
#super(tr("Building inside building"), tr("Checks for building areas inside of buildings."));
def visitn(self,n) :
# print "visitn:"
# print n
if (n.isUsable() and isBuilding(n)) :
if not self.primitivesToCheck.contains(n):
# print "adding :" n
self.primitivesToCheck.add(n);
else:
print "duplicate p :"
# print n
def visitw(self,w) :
print "visitw:"
# print w
if (w.isUsable() and w.isClosed() and isBuilding(w)) :
self.primitivesToCheck.add(w)
self.index.add(w)
print "added"
def isInPolygon(n, polygon) :
return Geometry.nodeInsidePolygon(n, polygon);
def sameLayers( w1, w2) :
if w1.get("layer") is not None :
l1 = w1.get("layer")
else :
l1 = "0";
if w2.get("layer") is not None :
l2 = w2.get("layer")
else :
l2 ="0";
return l1.equals(l2);
def evaluateNode(self,p,obj):
print "te"
# print p
# print obj
def endTest2(self):
for p in self.primitivesToCheck :
collection = self.index.search(p.getBBox())
for object in collection:
if (not p.equals(object)):
if (isinstance(p,Node)):
self.evaluateNode(p, object)
else :
print p
# else if (p instanceof Way)
# return evaluateWay((Way) p, object);
# else if (p instanceof Relation)
# return evaluateRelation((Relation) p, object);
# return false;
def endTest(self) :
print "end"
# bbox = BBox(-180,-90,180,90)
bbox = BBox(-1000,-900,1800,900)
print self.index
collection = self.index.search(bbox)
# print collection
def projection() :
print "projection"
pc = ProjectionPreference.mercator
id = pc.getId()
pref = None
Main.pref.putCollection("projection.sub."+id, pref)
pc.setPreferences(pref)
proj = pc.getProjection()
Main.setProjection(proj)
def prefs() :
print "prefs"
Main.pref = Preferences()
Main.pref.put("tags.reversed_direction", "false")
class JythonWay():
def __init__(self,x):
self.way=x
self.subobjects=[]
pass
# todo:
def lookup(self) :
# lookup this street name on the internet
print "ToDO"
# todo:
def merge(self) :
# merge these two streets, fix the names
print "ToDO fix the streets"
def get (self,k):
return self.way.get(k)
def name(self):
return self.way.get('name')
def addsubobject(self, other):
return self.subobjects.append(other)
import re
pattern = re.compile(r'\s+')
def streetlist(objs) :
objs2 = []
streets = {}
for p in objs:
if (not isinstance(p,Way)):
continue
s=p.get('name')
hw=p.get('highway')
if (s is None):
continue
if (hw is None):
continue
s = s.lower()
s=re.sub(pattern, '', s) #remove whitespace
if not s in streets :
# print "%s is new" % s
streets[s]=JythonWay(p)
else :
streets[s].addsubobject(p)
# print streets.values()
objs3= sorted(streets.values(),(lambda x, y: (cmp(x.name(), y.name()))))
DisplayStreetTable(objs3)
def main ():
print "main"
prefs();
projection();
importer = OsmImporter()
fileObj= File('/home/mdupont/experiments/josm/topeka/noto.osm')
# fileObj= File('/home/mdupont/experiments/josm/topeka/topeka.osm')
inobj = FileInputStream(fileObj);
data = importer.loadLayer(inobj, fileObj, fileObj.getName(), NullProgressMonitor.INSTANCE)
s = data.toString();
# print s
primitives = data.getLayer().data.allPrimitives();
# print primitives
objs= primitives.toArray()
#DisplayTable(obj)
streetlist(objs)
# make a list of the street objects
main();