-
Notifications
You must be signed in to change notification settings - Fork 1
/
AligmentRenderer.py
212 lines (184 loc) · 6.57 KB
/
AligmentRenderer.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
#!/usr/bin/env python3
# -*- coding: utf-8, vim: expandtab:ts=4 -*-
from TokenLayout import TokenLayout
from Edge import Edge
# from PyQt4 import QtGui, QtCore
# from Bounds1D import Bounds1D
from SVGWriter import *
"""
* A SingleSentenceRenderer renders an NLPInstance as a single sentence with spans drawn below the tokens, and
* dependencies above the tokens.
*
* @author Sebastian Riedel
"""
class AligmentRenderer:
"""
* The layout object for tokens.
"""
@property
def tokenLayout1(self):
return self._tokenLayout1
@tokenLayout1.setter
def tokenLayout1(self, value):
self._tokenLayout1 = value
"""
* The layout object for tokens.
"""
@property
def tokenLayout2(self):
return self._tokenLayout2
@tokenLayout2.setter
def tokenLayout2(self, value):
self._tokenLayout2 = value
"""
* Should lines be drawn using antialiasing.
"""
@property
def antiAliasing(self):
return self._antiAliasing
@antiAliasing.setter
def antiAliasing(self, value):
self._antiAliasing = value
def __init__(self):
self._tokenLayout1 = TokenLayout()
self._tokenLayout2 = TokenLayout()
self._heightFactor = 100
self._isCurved = True
self._antiAliasing = True
self._tokenLayout2.toSplitPoint = 0
self._tokenLayout2.fromSplitPoint = 0
"""
* Renders the given instance as a single sentence with spans drawn below tokens, and dependencies above tokens.
*
* @param instance the instance to render
* @param graphics2D the graphics object to draw upon
* @return the width and height of the drawn object.
* @see com.googlecode.whatswrong.NLPCanvasRenderer#render(com.googlecode.whatswrong.NLPInstance,
* java.awt.Graphics2D)
"""
def render(self, instance, scene):
tokenXBounds1 = self._tokenLayout1.estimateTokenBounds(instance, {}, scene)
tokenXBounds2 = self._tokenLayout2.estimateTokenBounds(instance, {}, scene)
"""
if self._antiAliasing:
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
"""
width = 0
height = 0
# place dependencies on top
dim = self._tokenLayout1.layout(instance, {}, scene)
height += dim[1]
if dim[0] > width:
width = dim[0]
for edge in instance.getEdges(Edge.RenderType.dependency):
if edge.getTypePostfix() == "FP":
# painter.setBrush(QtGui.QColor(255,0,0))
scene.color = (255, 0, 0) # Color.RED
elif edge.getTypePostfix() == "FN":
# painter.setBrush(QtGui.QColor(0,0,255))
scene.color = (0, 0, 255) # Color.BLUE
else:
# painter.setBrush(QtGui.QColor(0,0,0))
scene.color = (0, 0, 0) # Color.BLACK
bound1 = tokenXBounds1[edge.From]
bound2 = tokenXBounds2[edge.To]
if self._isCurved: # XXX IS THIS OK?
start = (bound1.getMiddle(), height)
x1 = (bound1.getMiddle(), height + self._heightFactor // 2) # INTEGER DIVISION!!!
x2 = (bound2.getMiddle(), height + self._heightFactor // 2) # INTEGER DIVISION!!!
end = (bound2.getMiddle(), height + self._heightFactor)
scene.add(QuadraticBezierCurve(scene, start, x1, x2, end, scene.color))
else:
x1 = (bound1.getMiddle(), height)
x2 = (bound2.getMiddle(), height + self._heightFactor)
scene.add(Line(scene, x1, x2, scene.color))
# add spans
scene.translate(0, dim.height + self._heightFactor)
dim = self._tokenLayout2.layout(instance, {}, scene)
height += dim[0] + self._heightFactor
if dim[1] > width:
width = dim[1]
return width, height + 1
"""
* Should anti-aliasing be used when drawing the graph.
*
* @param antiAliasing rue iff anti-aliasing should be used when drawing the graph.
"""
# See the setter above...
"""
* Returns the margin between tokens.
*
* @return the margin between tokens.
"""
@property
def margin(self):
return self._tokenLayout1.margin()
"""
* Sets the margin between tokens.
*
* @param margin the margin between tokens.
"""
@margin.setter
def margin(self, value):
self._tokenLayout1.margin = value
self._tokenLayout2.margin = value
@staticmethod
def getEdgeAt(*_): # self, p, radius
return None
"""
* Returns an integer that reflects the height of the graph.
*
* @return an integer that reflects the height of the graph. The higher this value, the higher the graph.
"""
@property
def heightFactor(self):
return self._heightFactor / 4
"""
* Controls the height of the graph.
*
* @param heightFactor an integer that indicates how high the graph should be.
"""
@heightFactor.setter
def heightFactor(self, value):
self._heightFactor = value * 4
"""
* Returns whether the renderer draws a more curved graph or not.
*
* @return true iff the renderer draws a more curved graph.
"""
@property
def isCurved(self):
return self._isCurved
"""
* Controls whether the graph should be curved or rectangular. If curved the dependencies are drawn as curves
* instead of rectangular lines, and spans are drawn as rounded rectangles.
*
* @param isCurved should the graph be more curved.
* @see com.googlecode.whatswrong.NLPCanvasRenderer#setCurved(boolean)
"""
@isCurved.setter
def isCurved(self, value):
self._isCurved = value
"""
* Set the color for edges of a certain type.
*
* @param edgeType the type of the edges we want to change the color for.
* @param color the color of the edges of the given type.
"""
def setEdgeTypeColor(self, edgeType, color):
pass
"""
* Sets the order/vertical layer in which the area of a certain type should be drawn.
*
* @param edgeType the type we want to change the order for.
* @param order the order/vertical layer in which the area of the given type should be drawn.
"""
def setEdgeTypeOrder(self, edgeType, order):
pass
"""
* Should anti-aliasing be used when drawing the graph.
*
* @return true iff anti-aliasing should be used when drawing the graph.
"""
def isAntiAliasing(self):
return self._antiAliasing