-
Notifications
You must be signed in to change notification settings - Fork 1
/
NLPCanvas.py
275 lines (230 loc) · 7.99 KB
/
NLPCanvas.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
#!/usr/bin/env python3
# -*- coding: utf-8, vim: expandtab:ts=4 -*-
from PyQt4 import QtGui, QtCore, QtSvg
from SVGWriter import *
from SingleSentenceRenderer import SingleSentenceRenderer
from NLPInstance import NLPInstance
from AligmentRenderer import AligmentRenderer
from NLPInstanceFilter import *
"""
* An NLPCanvas is responsible for drawing the tokens and edges of an NLPInstance using different edge and token
* layouts. In order to draw an NLPInstance clients have to first set the instance to draw by calling {@link
* com.googlecode.whatswrong.NLPCanvas#setNLPInstance(NLPInstance)} and then update the graphical representation by
* calling {@link NLPCanvas#updateNLPGraphics()}. The latter method should also be called whenever changes are made to
* the layout configuration (curved edges vs straight edges, antialiasing etc.).
*
* @author Sebastian Riedel
* @see com.googlecode.whatswrong.EdgeLayout
* @see com.googlecode.whatswrong.TokenLayout
"""
class NLPCanvas:
"""
* Renderers for different render types.
"""
@property
def renderers(self):
return self._renderers
@renderers.setter
def renderers(self, value):
self._renderers = value
"""
* All tokens.
"""
@property
def tokens(self):
return self._tokens
@tokens.setter
def tokens(self, value):
self._tokens = value
"""
* All edges.
"""
@property
def dependencies(self):
return self._dependencies
@dependencies.setter
def dependencies(self, value):
self._dependencies = value
"""
* A collection of all edge types used in the current nlp instance.
"""
@property
def usedTypes(self):
return self._usedTypes
@usedTypes.setter
def usedTypes(self, value):
self._usedTypes = value
"""
* A collection of all token properties used in the current nlp instance.
"""
@property
def usedProperties(self):
return self._usedProperties
@usedProperties.setter
def usedProperties(self, value):
self._usedProperties = value
"""
* The filter that processes the current instance before it is drawn.
"""
@property
def filter(self):
return self._filter
@filter.setter
def filter(self, value=NLPInstanceFilter):
self._filter = value
"""
* Adds a new listener.
*
* @param listener the listener to add.
"""
def addListener(self, listener):
self._listeners.append(listener)
"""
* The renderer that draws the filtered NLPInstance to the canvas.
"""
@property
def renderer(self):
return self._renderer
@renderer.setter
def renderer(self, value):
self._renderer = value
"""
* Creates a new canvas with default size.
"""
def __init__(self, ui):
self._renderer = SingleSentenceRenderer()
self._renderers = {NLPInstance.RenderType.single: self._renderer,
NLPInstance.RenderType.alignment: AligmentRenderer()}
self._tokens = []
self._dependencies = []
self._usedTypes = set()
self._usedProperties = set()
self._filter = None
self._ui = ui
self._scene = QtGui.QGraphicsScene()
self._SVGScene = None
self._nlpInstance = None
self._listeners = []
self._changeListeners =[]
def addChangeListener(self, changeListener):
self._changeListeners.append(changeListener)
"""
* Fired whenever this canvas is changed.
"""
def fireChanged(self):
for changeListener in self._changeListeners:
changeListener.stateChanged()
"""
* Notifies all listeners about an instance change event.
"""
def fireInstanceChanged(self):
for l in self._listeners:
l.instanceChanged()
# XXX TO BE DELETED?
def updateCanvas(self):
# self._ui.graphicsView.setScene(self._scene)
# br = QtSvg.QGraphicsSvgItem("/Users/Regina/Documents/Pázmány/Onallo_labor/Project/Python/What'sWrong_SVG/test.svg")
# text = QtSvg.QGraphicsSvgItem("/Users/Regina/Documents/Pázmány/Onallo_labor/Project/Python/What'sWrong_SVG/szoveg.svg")
# self._scene.addItem(br)
# self._ui.graphicsView.show()
pass
"""
* Return the renderer that draws the NLPInstance onto this canvas.
*
* @return the renderer that draws the NLPInstance onto this canvas.
"""
# See the getter above...
"""
* Sets the current NLP instance to draw. Note that this does not cause to canvas to be immediately updated.
* For this {@link NLPCanvas#updateNLPGraphics()} needs to be called.
*
* @param nlpInstance the new NLP instance.
"""
def setNLPInstance(self, nlpIntance):
self._nlpInstance = nlpIntance
self._dependencies = []
self._dependencies.extend(self._nlpInstance.getEdges())
self._usedTypes.clear()
for edge in self._dependencies:
self._usedTypes.add(edge.type) # Union
self._tokens = []
self._tokens.extend(self._nlpInstance.tokens)
self._usedProperties.clear()
for token in self._tokens:
self._usedProperties = self._usedProperties.union(token.getPropertyTypes()) # XXX Tuple and set!
self.fireInstanceChanged()
"""
* Returns the set of all token properties in the current nlp instance.
*
* @return the set of all token properties in the current nlp instance.
"""
# See the getter above...
"""
* Returns the set of all edge types in the current nlp instance.
*
* @return the set of all edge types in the current nlp instance.
"""
# See the getter above...
"""
* Returns the filter this canvas is applying to the nlp instance before it is drawn.
*
* @return the filter of this canvas.
"""
# See the getter above...
"""
* Sets the filter this canvas should apply to the nlp instance before it is drawn.
*
* @param filter the filter to use.
"""
# See the setter above...
"""
* Just calls the filter on the current instance.
*
* @return the filtered instance.
"""
def filterInstance(self):
return self._filter.filter(NLPInstance(tokens=self._tokens, edges=self._dependencies,
renderType=self._nlpInstance.renderType,
splitPoints=self._nlpInstance.splitPoints))
"""
* Updates the current graph. This takes into account all changes to the filter,
NLP instance and drawing parameters.
"""
def updateNLPGraphics(self):
filtered = self.filterInstance()
self._SVGScene = Scene(width=800)
renderer = self._renderers[filtered.renderType]
dim = renderer.render(filtered, self._SVGScene)
self._SVGScene = Scene(width=dim[0], height=dim[1])
renderer.render(filtered, self._SVGScene)
self._SVGScene.write_svg("tmp.svg")
path = os.path.abspath("tmp.svg")
scene = QtGui.QGraphicsScene()
self._ui.graphicsView.setScene(scene)
br = QtSvg.QGraphicsSvgItem(path)
scene.addItem(br)
self._ui.graphicsView.show()
self.fireChanged()
def exportNLPGraphics(self, filepath):
filtered = self.filterInstance()
self._SVGScene = Scene(width=800)
renderer = self._renderers[filtered.renderType]
dim = renderer.render(filtered, self._SVGScene)
self._SVGScene = Scene(width=dim[0], height=dim[1])
renderer.render(filtered, self._SVGScene)
self._SVGScene.write_svg(filepath)
"""
* Clears the current instance.
"""
def clear(self):
self._tokens.clear()
self._dependencies.clear()
self._usedTypes.clear()
self._usedProperties.clear()
"""
* Exports the current graph to EPS.
*
* @param file the eps file to export to.
* @throws IOException if IO goes wrong.
"""
# Will be implemented in the far future...