def genererlinedroite(self, index=0):
if self.nbchild(self.listwid[index].name) > 0:
maxx = 0
miny = 1000000
minx = 1000000
for i in range(len(self.listwid)):
if self.listwid[i].parent == self.listwid[index].name:
centre = self.listwid[i].wid.windowFrameGeometry().center()
top = self.listwid[i].wid.windowFrameGeometry().topLeft()
if centre.x() < minx:
minx = centre.x()
if centre.x() > maxx:
maxx = centre.x()
if top.y() < miny:
miny = top.y()
posybar = (miny + self.listwid[index].wid.windowFrameGeometry().bottomLeft().y())//2
minbar = QtCore.QPointF(minx, posybar)
maxbar = QtCore.QPointF(maxx, posybar)
self.listline.append(QtGui.QGraphicsLineItem(QtCore.QLineF(self.listwid[index].wid.windowFrameGeometry().center(), QtCore.QPointF(self.listwid[index].wid.windowFrameGeometry().center().x(), posybar))))
self.listline.append(QtGui.QGraphicsLineItem(QtCore.QLineF(minbar, maxbar)))
for i in range(len(self.listwid)):
if self.listwid[i].parent == self.listwid[index].name:
centre = self.listwid[i].wid.windowFrameGeometry().center()
self.listline.append(QtGui.QGraphicsLineItem(QtCore.QLineF(centre, QtCore.QPointF(centre.x(), posybar))))
self.genererlinedroite(i)
def draw_ticks(self):
# Draw the timeline
item_list = []
xform = QtGui.QTransform()
top_line = QtGui.QGraphicsLineItem(0, 20, 1440, 20)
bot_line = QtGui.QGraphicsLineItem(0, 40, 1440, 40)
item_list.append(top_line)
item_list.append(bot_line)
ticks = numpy.arange(0, 1490, 60)
hours = range(0, 25)
for item in ticks:
tick = QtGui.QGraphicsLineItem(item, 20, item, 40)
item_list.append(tick)
hour_x_xform = -19
hour_y_xform = 37
for hour in hours:
hour = str(hour)
hour = hour.zfill(2)
hour = hour + ':' + '00'
hour_label = QtGui.QGraphicsTextItem(hour)
hour_label.setTransform(xform.translate(hour_x_xform,
hour_y_xform))
item_list.append(hour_label)
hour_x_xform = 60
hour_y_xform = 0
# Group all the components
group = self.createItemGroup(item_list)
group.setZValue(1)
# Draw pale blue background for timeline
scale = QtGui.QGraphicsRectItem(0, 20, 1440, 20)
col = QtGui.QColor()
col.setRgb(160, 195, 255)
scale.setBrush(col)
self.addItem(scale)
scale.setZValue(0)
def _custom_add_scale(img, mainRect, parent):
from PyQt4 import QtGui
from ete2.treeview.qt4_render import _EmptyItem
length = fontBig * res / 4
length = img._scale * numpy.ceil(
100 * float(length) / img._scale) / 100 #this is my OCD...
height = length / 3
scaleItem = _EmptyItem()
customPen = QtGui.QPen(QtGui.QColor("black"), res / 72)
line = QtGui.QGraphicsLineItem(scaleItem)
line2 = QtGui.QGraphicsLineItem(scaleItem)
line3 = QtGui.QGraphicsLineItem(scaleItem)
line.setPen(customPen)
line2.setPen(customPen)
line3.setPen(customPen)
line.setLine(0, height / 2, length, height / 2)
line2.setLine(0, 0, 0, height)
line3.setLine(length, 0, length, height)
length_text = float(length) / img._scale
scale_text = "%0.2f" % (length_text)
scale = QtGui.QGraphicsSimpleTextItem(scale_text)
scale.setFont(QtGui.QFont("Arial", fontSize * 0.75))
scale.setParentItem(scaleItem)
scale.setPos(length / 3, -height)
scaleItem.setParentItem(parent)
scaleItem.setPos(mainRect.bottomLeft())
scaleItem.moveBy(img.margin_left, -img.margin_bottom)
mainRect.adjust(0, 0, 0, height)
def set_vert_spacers(self):
"""Sets up dynamic vertical spacers; number and spacing depends on total time configured"""
ms_time = self.dirs.settings.ttl_time
gap_size = 5 + 5 * int(ms_time / 300000)
num_spacers_float = float(ms_time / 1000) / gap_size
num_spacers_int = int(round(num_spacers_float))
pos_raw = 1000.0 / num_spacers_float
# Generate Spacers
for i in range(num_spacers_int):
i += 1
# Generic Object Pointers
tiny_line = qg.QGraphicsLineItem(i * pos_raw, 260, i * pos_raw, 265)
short_line = qg.QGraphicsLineItem(i * pos_raw, 20, i * pos_raw, 260)
long_line = qg.QGraphicsLineItem(I * pos_raw, 20, i * pos_raw, 265)
time_text = qg.QGraphicsTextItem(format_secs(gap_size * i))
# Creation Parameters
odd_spacer = (i % 2 != 0)
even_spacer = (i % 2 == 0)
final_spacer = (i == num_spacers_int)
undershoot = (i * pos_raw < 1000)
at_end_of_bar = (i * pos_raw == 1000)
# Create Spacers based on Creation Parameters
if odd_spacer:
if (not final_spacer) or (final_spacer and undershoot):
self.v_bars.add(short_line, pen=qWhite)
elif final_spacer and at_end_of_bar:
self.v_bars.add(tiny_line, pen=qWhite)
elif even_spacer:
if (not final_spacer) or (final_spacer and undershoot):
self.v_bars.add(long_line, pen=qWhite)
self.bar_times.add(time_text, pos_x=i * pos_raw - 20, pos_y=262, color=qWhite)
elif final_spacer and at_end_of_bar:
self.v_bars.add(tiny_line, pen=qWhite)
self.bar_times.add(time_text, pos_x=i * pos_raw - 20, pos_y=262, color=qWhite)
def __drawLine(self, value, duration, printvalue=True):
''' Draws a line depending on the type of the waveform.
@param value: value to add to wave
@param duration: integer, defines duration(length) of value in wave
@param printvalue: bool, add values to waveform (for value-type waveforms only)
'''
self.width = self.width + duration
tmp = self.curPos
self.curPos = QPointF(self.curPos.x() + duration, self.curPos.y())
if self.type == "bool":
if value:
self.addItem(QtGui.QGraphicsLineItem(QLineF(tmp, self.curPos)))
else:
self.addItem(
QtGui.QGraphicsLineItem(tmp.x(),
tmp.y() + self.vSpace,
self.curPos.x(),
self.curPos.y() + self.vSpace))
elif self.type in self.supportedTypes:
if printvalue:
text = QtGui.QGraphicsTextItem(str(value))
text.setFont(self.valFont)
text.setDefaultTextColor(self.valFontColor)
text.setPos(QPointF(tmp.x() + 4, tmp.y() - 5))
self.addItem(text)
self.addItem(QtGui.QGraphicsLineItem(QLineF(tmp, self.curPos)))
self.addItem(
QtGui.QGraphicsLineItem(tmp.x(),
tmp.y() + self.vSpace, self.curPos.x(),
self.curPos.y() + self.vSpace))
def mouseMoveEvent(self, event):
super(PhotoViewer, self).mouseMoveEvent(event)
for varI in range(len(self.lineItem)):
self._scene.removeItem(self.lineItem[0])
del self.lineItem[0]
if self.boolSetPath:
position = self.mapToScene(event.pos(
)) #QtCore.QPointF(event.pos()) - item.rectF.center()
if self.bbStart:
wh = position - QtCore.QPointF(self.globalItem[-1].rect().x(),
self.globalItem[-1].rect().y())
self.globalItem[-1].setRect(self.globalItem[-1].rect().x(),
self.globalItem[-1].rect().y(),
wh.x(), wh.y())
else:
self.lineItem.append(
QtGui.QGraphicsLineItem(
QtCore.QLineF(
QtCore.QPointF(position.x(), 0),
QtCore.QPointF(
position.x(),
self._photo.pixmap().rect().height()))))
self.lineItem[0].setPen(
QtGui.QPen(QtCore.Qt.cyan, 0.5, QtCore.Qt.DashLine))
self._scene.addItem(self.lineItem[0])
self.lineItem.append(
QtGui.QGraphicsLineItem(
QtCore.QLineF(
QtCore.QPointF(0, position.y()),
QtCore.QPointF(self._photo.pixmap().rect().width(),
position.y()))))
self.lineItem[-1].setPen(
QtGui.QPen(QtCore.Qt.cyan, 0.5, QtCore.Qt.DashLine))
self._scene.addItem(self.lineItem[-1])
self._scene.update()
def refreshLine(self):
Lines = self.items()
Line = [x for x in Lines if isinstance(x, QtGui.QGraphicsLineItem)]
for i in range(len(Line)):
self.scene().removeItem(Line[i])
start = QtCore.QPoint(-self.viewport().width() / 2,
self.viewport().height() / 2)
end = self.breakList[0].rect().center() + self.breakList[0].pos()
self.scene().addItem(QtGui.QGraphicsLineItem(QtCore.QLineF(start,
end)))
for i in range(len(self.breakList) - 1):
start = self.breakList[i].rect().center() + self.breakList[i].pos()
end = self.breakList[i +
1].rect().center() + self.breakList[i +
1].pos()
self.scene().addItem(
QtGui.QGraphicsLineItem(QtCore.QLineF(start, end)))
start = self.breakList[-1].rect().center() + self.breakList[-1].pos()
end = QtCore.QPoint(self.viewport().width() / 2,
-self.viewport().height() / 2)
self.scene().addItem(QtGui.QGraphicsLineItem(QtCore.QLineF(start,
end)))
def get_scale(self):
length = 50
scaleItem = _PartitionItem(None) # Unassociated to nodes
scaleItem.setRect(0, 0, 50, 50)
customPen = QtGui.QPen(QtGui.QColor("black"), 1)
line = QtGui.QGraphicsLineItem(scaleItem)
line2 = QtGui.QGraphicsLineItem(scaleItem)
line3 = QtGui.QGraphicsLineItem(scaleItem)
line.setPen(customPen)
line2.setPen(customPen)
line3.setPen(customPen)
line.setLine(0, 5, length, 5)
line2.setLine(0, 0, 0, 10)
line3.setLine(length, 0, length, 10)
scale_text = "%0.2f" % float(length / self.scale)
scale = QtGui.QGraphicsSimpleTextItem(scale_text)
scale.setParentItem(scaleItem)
scale.setPos(0, 10)
if self.props.force_topology:
wtext = "Force topology is enabled!\nBranch lengths does not represent original values."
warning_text = QtGui.QGraphicsSimpleTextItem(wtext)
warning_text.setFont(QtGui.QFont("Arial", 8))
warning_text.setBrush(QtGui.QBrush(QtGui.QColor("darkred")))
warning_text.setPos(0, 32)
warning_text.setParentItem(scaleItem)
return scaleItem
def add_scale(img, mainRect, parent):
if img.show_scale:
length=50
scaleItem = _EmptyItem()
customPen = QtGui.QPen(QtGui.QColor("black"), 1)
if img.force_topology:
wtext = "Force topology is enabled!\nBranch lengths do not represent real values."
warning_text = QtGui.QGraphicsSimpleTextItem(wtext)
warning_text.setFont(QtGui.QFont("Arial", 8))
warning_text.setBrush( QtGui.QBrush(QtGui.QColor("darkred")))
warning_text.setPos(0, 32)
warning_text.setParentItem(scaleItem)
else:
line = QtGui.QGraphicsLineItem(scaleItem)
line2 = QtGui.QGraphicsLineItem(scaleItem)
line3 = QtGui.QGraphicsLineItem(scaleItem)
line.setPen(customPen)
line2.setPen(customPen)
line3.setPen(customPen)
line.setLine(0, 5, length, 5)
line2.setLine(0, 0, 0, 10)
line3.setLine(length, 0, length, 10)
length_text = float(length) / img._scale if img._scale else 0.0
scale_text = "%0.2f" % (length_text)
scale = QtGui.QGraphicsSimpleTextItem(scale_text)
scale.setParentItem(scaleItem)
scale.setPos(0, 10)
scaleItem.setParentItem(parent)
dw = max(0, length-mainRect.width())
scaleItem.setPos(mainRect.bottomLeft())
scaleItem.moveBy(img.margin_left, 0)
mainRect.adjust(0, 0, dw, length)
def update(self):
# Remove the old axis.
self.removeFromGroup(self.child)
self.scene().removeItem(self.child)
self.child = QtGui.QGraphicsItemGroup()
self.child.setParentItem(self)
line = QtGui.QGraphicsLineItem(QtCore.QLineF(0, 0, self.width, 0))
line.setParentItem(self.child)
# Calculate and draw tics.
timeSpan = float(self.maxTime - self.minTime)
bigTicSpan = float(1e10)
while math.fmod(timeSpan, bigTicSpan) == timeSpan:
bigTicSpan /= 10
if timeSpan / bigTicSpan < 2:
bigTicSpan /= 10
ticSpan = bigTicSpan / 10
ticTime = self.minTime - math.fmod(self.minTime, ticSpan)
if ticTime < self.minTime:
ticTime += ticSpan
bigTicTime = self.minTime + bigTicSpan - math.fmod(
self.minTime, bigTicSpan)
count = 10 - int((bigTicTime - self.minTime) / ticSpan)
time = ticTime
maxValuesHeight = 0
while time < self.maxTime:
ticlen = 10
ticx = ((time - self.minTime) * self.width) / timeSpan
if count % 10 == 0:
# Normalize time
diff = math.fmod(time, ticSpan)
time = time - diff
if diff > ticSpan / 2.0:
time = time + ticSpan
elif -diff > ticSpan / 2.0:
time = time - ticSpan
text = QtGui.QGraphicsTextItem(str(time))
text.setFont(variables.timeAxisValuesFont.value())
text.setPos(ticx - text.boundingRect().width() / 2, 13)
maxValuesHeight = max(maxValuesHeight,
text.boundingRect().height())
text.setParentItem(self.child)
ticlen = 15
tic = QtGui.QGraphicsLineItem(QtCore.QLineF(ticx, 0, ticx, ticlen))
tic.setParentItem(self.child)
time += ticSpan
count += 1
# Sets and displays axis label.
if variables.timeAxisCaptionEnabled.value():
text = QtGui.QGraphicsTextItem(variables.timeAxisCaption.value())
text.setFont(variables.timeAxisCaptionFont.value())
text.setPos(self.width - text.boundingRect().width(),
maxValuesHeight)
text.setParentItem(self.child)
def __init__(self, parentItem, Z=1, umpx=1):
Overlay.__init__(self, parentItem, Z=Z)
self.opt = set(
['profile', 'iA', 'roi', 'angle', 'w', 'h', 'xmass', 'ymass', 'crop'])
# Create base and height lines
self.base = QtGui.QGraphicsLineItem(parent=self)
self.base.setPen(self.pen)
self.height = QtGui.QGraphicsLineItem(parent=self)
self.height.setPen(self.pen)
self.umpx = umpx
def __init__(self, size, parent=None):
QtGui.QGraphicsItemGroup.__init__(self, parent)
self._yawLine = QtGui.QGraphicsLineItem()
self._yawLine.setLine(0, -size, 0, size)
self._yawLine.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._yawLine)
self._pitchLine = QtGui.QGraphicsLineItem()
self._pitchLine.setLine(-size, 0, size, 0)
self._pitchLine.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._pitchLine)
self._circle = QtGui.QGraphicsEllipseItem(-size / 2, -size / 2, size, size)
self._circle.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._circle)
def drawGrid(self):
black_notes = [2, 4, 6, 9, 11]
scale_bar = QtGui.QGraphicsRectItem(0, 0, self.grid_width,
self.note_height, self.piano)
scale_bar.setPos(self.piano_width, 0)
scale_bar.setBrush(QtGui.QColor(100, 100, 100))
clearpen = QtGui.QPen(QtGui.QColor(0, 0, 0, 0))
for i in range(self.end_octave - self.start_octave,
self.start_octave - self.start_octave, -1):
for j in range(self.notes_in_octave, 0, -1):
scale_bar = QtGui.QGraphicsRectItem(0, 0, self.grid_width,
self.note_height,
self.piano)
scale_bar.setPos(
self.piano_width,
self.note_height * j + self.octave_height * (i - 1))
scale_bar.setPen(clearpen)
if j not in black_notes:
scale_bar.setBrush(QtGui.QColor(120, 120, 120))
else:
scale_bar.setBrush(QtGui.QColor(100, 100, 100))
measure_pen = QtGui.QPen(QtGui.QColor(0, 0, 0, 120), 3)
half_measure_pen = QtGui.QPen(QtGui.QColor(0, 0, 0, 40), 2)
line_pen = QtGui.QPen(QtGui.QColor(0, 0, 0, 40))
for i in range(0, int(self.num_measures) + 1):
measure = QtGui.QGraphicsLineItem(
0, 0, 0,
self.piano_height + self.header_height - measure_pen.width(),
self.header)
measure.setPos(self.measure_width * i, 0.5 * measure_pen.width())
measure.setPen(measure_pen)
if i < self.num_measures:
number = QtGui.QGraphicsSimpleTextItem('%d' % (i + 1),
self.header)
number.setPos(self.measure_width * i + 5, 2)
number.setBrush(QtCore.Qt.white)
for j in self.frange(
0, self.time_sig[0] * self.grid_div / self.time_sig[1],
1.):
line = QtGui.QGraphicsLineItem(0, 0, 0, self.piano_height,
self.header)
line.setZValue(1.0)
line.setPos(self.measure_width * i + self.value_width * j,
self.header_height)
if j == self.time_sig[0] * self.grid_div / self.time_sig[
1] / 2.0:
line.setPen(half_measure_pen)
else:
line.setPen(line_pen)
def draw_axes(self, minx, miny, maxx, maxy):
# Draw axes and diagonal
if maxx > 0:
self.scene.addItem(QtGui.QGraphicsLineItem(0, 0, maxx, 0))
if minx < 0:
self.scene.addItem(QtGui.QGraphicsLineItem(minx, 0, 0, 0))
if maxy > 0:
self.scene.addItem(QtGui.QGraphicsLineItem(0, 0, 0, maxy))
if miny < 0:
self.scene.addItem(QtGui.QGraphicsLineItem(0, miny, 0, 0))
self.scene.addItem(
QtGui.QGraphicsLineItem(0, 0, min(maxx, maxy), min(maxx, maxy)))
self.scene.addItem(
QtGui.QGraphicsLineItem(max(minx, miny), max(minx, miny), 0, 0))
# Dashed, gray integer lattice
pen = QtGui.QPen(QtCore.Qt.DashLine)
pen.setColor(QtCore.Qt.gray)
for i in xrange(min(0, int(minx)) + 1, max(0, int(maxx)) + 1):
line = QtGui.QGraphicsLineItem(i, 0, i, maxy)
line.setPen(pen)
self.scene.addItem(line)
for i in xrange(min(0, int(miny)) + 1, max(0, int(maxy)) + 1):
line = QtGui.QGraphicsLineItem(0, i, maxx, i)
line.setPen(pen)
self.scene.addItem(line)
def _custom_add_scale(img, mainRect, parent):
from PyQt4 import QtGui
from ete3.treeview.qt4_render import _EmptyItem
length = arguments['-f'] * arguments['-r'] / 4
length = img._scale * numpy.ceil(
100 * float(length) / img._scale) / 100 #this is my OCD...
length_text = float(length) / img._scale
height = length / 3
scaleItem = _EmptyItem()
customPen = QtGui.QPen(QtGui.QColor("black"), arguments['-r'] / 72)
line = QtGui.QGraphicsLineItem(scaleItem)
line2 = QtGui.QGraphicsLineItem(scaleItem)
line3 = QtGui.QGraphicsLineItem(scaleItem)
line.setPen(customPen)
line2.setPen(customPen)
line3.setPen(customPen)
if arguments['--left']:
length = -length
line.setLine(0, height / 2, length, height / 2)
line2.setLine(0, 0, 0, height)
line3.setLine(length, 0, length, height)
scale_text = "%0.2f" % (length_text)
scale = QtGui.QGraphicsSimpleTextItem(scale_text)
scale.setFont(QtGui.QFont("Arial", fontSize * 0.75))
scale.setParentItem(scaleItem)
scale.setPos(length / 3, -height)
if arguments['--left']:
scale.setPos(2 * length / 3, -height)
scaleItem.setParentItem(parent)
if arguments['--left']:
scaleItem.setPos(mainRect.bottomRight())
if not arguments['--noGuide']:
from ete3.treeview.qt4_render import _FaceGroupItem
scaleItem.moveBy(
-_FaceGroupItem(img.legend, None).get_size()[0] +
arguments['-r'] / 24, -img.margin_bottom)
else:
scaleItem.moveBy(-img.margin_right, -img.margin_bottom)
else:
scaleItem.setPos(mainRect.bottomLeft())
scaleItem.moveBy(img.margin_left, -img.margin_bottom)
mainRect.adjust(0, 0, 0, height)
def build(self):
polygon_width = 10 * len(self.label) # cbb
polygon_height = 20
polygon_arrow_height = 6
ul = QtCore.QPointF(-polygon_width * 0.5, 0.0)
ur = QtCore.QPointF(+polygon_width * 0.5, 0.0)
lr = QtCore.QPointF(+polygon_width * 0.5, polygon_height)
ll = QtCore.QPointF(-polygon_width * 0.5, polygon_height)
arrow = QtCore.QPointF(0.0, polygon_height + polygon_arrow_height)
line_point = QtCore.QPointF(arrow)
line_point.setY(500)
self.rectangle = QtGui.QGraphicsPolygonItem(
QtGui.QPolygonF([ul, ur, lr, arrow, ll]))
self.rectangle.setPen(self.rectangle_pen)
self.rectangle.setBrush(self.rectangle_brush)
self.label_text = QtGui.QGraphicsSimpleTextItem(self.label)
self.label_text.setPos(-len(self.label) * 10.0 / 4,
0.0) # hack for now
self.label_text.setPen(self.label_pen)
self.label_text.setBrush(self.label_brush)
self.line_item = QtGui.QGraphicsLineItem(
QtCore.QLineF(arrow, line_point))
self.line_item.setPen(self.line_item_pen)
for item in (self.rectangle, self.label_text, self.line_item):
self.addToGroup(item)
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() == QtCore.Qt.RightButton):
log.debug("right click mouse Press event")
self.line = QtGui.QGraphicsLineItem(
QtCore.QLineF(mouseEvent.scenePos(), mouseEvent.scenePos()))
start_points = self.items(self.line.line().p1())
if len(start_points) == 0:
log.debug("line skip , not on an attribute")
return
start_mouse_item = self.itemAt(self.line.line().p1())
if not isinstance(start_mouse_item, NodeItem):
log.debug("line skip , %s not an attribute" % start_mouse_item)
return
end_mouse_item = self.itemAt(self.line.line().p2())
if not isinstance(end_mouse_item, NodeItem):
log.debug("line skip , %s not an attribute" % end_mouse_item)
return
self.line.setPen(QtGui.QPen(QtCore.Qt.red, 2))
log.debug(start_mouse_item)
log.debug(end_mouse_item)
self.addItem(self.line)
self.line_mode = True
else:
log.debug("left click mouse Press event")
self.line_mode = False
super(NodeScene, self).mousePressEvent(mouseEvent)
def __init__(self, glue, hierarchyLink=False, *args, **kargs):
""":Parameters:
- `glue`: glue object owning this
pass glue object and let it key nodeItems to leo nodes
"""
self.glue = glue
QtGui.QGraphicsItemGroup.__init__(self)
self.line = QtGui.QGraphicsLineItem(*args)
pen = QtGui.QPen()
self.line.setZValue(0)
if not hierarchyLink:
self.setZValue(1)
pen.setWidth(2)
else:
self.setZValue(0)
pen.setColor(QtGui.QColor(240, 240, 240))
pen.setWidth(0.5)
self.line.setPen(pen)
self.addToGroup(self.line)
self.head = QtGui.QGraphicsPolygonItem()
if hierarchyLink:
self.head.setBrush(QtGui.QBrush(QtGui.QColor(230, 230, 230)))
else:
self.head.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0)))
self.head.setPen(QtGui.QPen(Qt.NoPen))
self.addToGroup(self.head)
def __init__(self, timeAxis, parent):
"""
Parameter text is displayed as a label between the time bars.
Parameter timeAxis points to Time Axis on which the time bars
are placed.
Parameter leftBorder contains the width of free space between
the left side of the scene and Time Axis, in pixels.
Parameter parent is a parent object in scene where time bars
will be displayed.
"""
# QGraphicsLineItem(QGraphicsItem parent=None,
# QGraphicsScene scene=None)
super(TimeBarPair, self).__init__(None, parent)
self.timeAxis = timeAxis
self.height = 0
# Should this really be set? If bars stop to draw, delete this.
self.setFlag(self.ItemHasNoContents, True)
self.bar1 = TimeBar(timeAxis)
self.bar2 = TimeBar(timeAxis)
self.setBarPos(100, 200)
self.bar1.setParentItem(self)
self.bar2.setParentItem(self)
self.bar1.signals.positionChanged.connect(self.onPositionChanged)
self.bar2.signals.positionChanged.connect(self.onPositionChanged)
self.legendLine = QtGui.QGraphicsLineItem()
self.legendLine.setPen(QtGui.QPen(QtCore.Qt.DotLine))
self.legendLine.setParentItem(self)
self.legendText = QtGui.QGraphicsSimpleTextItem()
self.legendTextVisible = True
self.legendText.setParentItem(self)
self.updateAppearance()
def mousePressEvent(self, event):
super(PhotoViewer, self).mousePressEvent(event)
if self.boolSetPath:
self.loopStart = 0
rad = 7
pen = QtGui.QPen(QtCore.Qt.red, 4, QtCore.Qt.SolidLine)
pos = self.mapToScene(event.x(), event.y())
self._save.append((event.x(), event.y()))
self.globalCircleItem.append(
QtGui.QGraphicsEllipseItem(pos.x(), pos.y(), rad, rad))
self.globalItem.append(self.globalCircleItem[-1])
self.globalCircleItem[-1].setPen(pen)
#self._scene.addEllipse(pos.x(), pos.y(), rad, rad, pen)
self._scene.addItem(self.globalCircleItem[-1])
self._pos.append(pos)
if len(self._pos) > 1:
start = self._pos[-2]
end = self._pos[-1]
self.globalConnectItem.append(
QtGui.QGraphicsLineItem(QtCore.QLineF(start, end)))
self.globalItem.append(self.globalConnectItem[-1])
self._scene.addItem(self.globalConnectItem[-1])
else:
QtGui.QMessageBox.information(
self, 'INFO',
"Enter the image and annotation paths to mark the joints!",
QtGui.QMessageBox.Ok)
def redrawLines(self, lineCoordinates):
if len(lineCoordinates) > 0:
for i in range(len(lineCoordinates)):
curCoord=lineCoordinates[i]
x1, y1, x2, y2 = curCoord
#calculate 1'st rectangel
curXleftStart = x1 - 2
curYleftStart = y1 - 2
curXrightStart = curXleftStart+4
curYrightStart = curYleftStart+4
rectCenterStart=QtCore.QPointF(curXleftStart, curYleftStart)
rectSizeStart = QtCore.QPointF(curXrightStart, curYrightStart)
curRect = QtGui.QGraphicsRectItem(QtCore.QRectF(rectCenterStart, rectSizeStart))
curRect.setPen(QtCore.Qt.green)
self.scene.addItem(curRect)
#calculate 2'nd rectangel
curXleftEnd = x2 - 2
curYleftEnd = y2 - 2
curXrightEnd = curXleftEnd+4
curYrightEnd = curYleftEnd+4
rectCenterEnd=QtCore.QPointF(curXleftEnd, curYleftEnd)
rectSizeEnd = QtCore.QPointF(curXrightEnd, curYrightEnd)
curRect = QtGui.QGraphicsRectItem(QtCore.QRectF(rectCenterEnd, rectSizeEnd))
curRect.setPen(QtCore.Qt.green)
self.scene.addItem(curRect)
curLine=QtGui.QGraphicsLineItem(x1, y1, x2, y2)
curLine.setPen(QtCore.Qt.red)
self.scene.addItem(curLine)
self.lines.append(curLine)
def connect_points(self):
if self.lines:
for i in range(len(self.lines)):
self.scene.removeItem(self.lines[i])
if len(global_points) > 1:
self.lines = (len(global_points) - 1) * [None]
global_points.sort(key=lambda point: point.pos().x())
f_line_pen = QtGui.QPen()
f_line_pen.setColor(QtGui.QColor(200, 50, 50))
f_line_pen.setWidth(4)
for i in range(1, len(global_points)):
#f_start_x = global_axes_size
#f_start_y = global_axes_size+(global_viewer_height/2.0)
#f_end_x = global_axes_size+global_viewer_width
#f_end_y = global_axes_size+(global_viewer_height/2.0)
f_start_x = global_points[(i - 1)].pos().x()
f_start_y = global_points[(i - 1)].pos().y()
f_end_x = global_points[i].pos().x()
f_end_y = global_points[i].pos().y()
f_pos_x = f_end_x - f_start_x
f_pos_y = f_end_y - f_start_y
f_line = QtGui.QGraphicsLineItem(0, 0, f_pos_x, f_pos_y)
f_line.setPos(7.5 + f_start_x, 7.5 + f_start_y)
f_line.setPen(f_line_pen)
self.scene.addItem(f_line)
self.lines[i - 1] = f_line
def recreateFromData(self):
# Remove all subitems.
self.removeFromGroup(self.child)
self.scene().removeItem(self.child)
self.child = QtGui.QGraphicsItemGroup()
self.child.setParentItem(self)
# Do nothing if no data are loaded.
if len(self.data.fitdata.values) == 0:
return
timeModifier = self.width / float(self.data.timeSpan)
valueModifier = self.height / float(self.data.valueSpan)
lastTime = None
lastValue = None
for t in range(
0,
self.data.fitTimePointer[1] - self.data.fitTimePointer[0] + 1):
time = (self.data.time[self.data.fitTimePointer[0] + t] -
self.data.minTime) * timeModifier
fit = self.height - (self.data.fitdata.values[t] -
self.data.minValue) * valueModifier
if lastTime is not None:
line = QtGui.QGraphicsLineItem(
QtCore.QLineF(lastTime, lastFit, time, fit))
line.setPen(self.pen)
line.setParentItem(self.child)
lastTime = time
lastFit = fit
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != QtCore.Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QtGui.QGraphicsLineItem(
QtCore.QLineF(mouseEvent.scenePos(), mouseEvent.scenePos()))
self.line.setPen(QtGui.QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def mousePressEvent(self, event):
global rotated
if event.buttons() == QtCore.Qt.MidButton:
self.start = event.pos()
self.start = self.mapToGlobal(event.pos())
self.start = self.CircuitView.mapFromGlobal(self.start)
self.start = self.CircuitView.mapToScene(self.start)
self.clickX = self.start.x()
self.clickY = self.start.y()
self.selectedItem = self.scene.itemAt(self.start)
self.itemX = self.selectedItem.geometry().x()
self.itemY = self.selectedItem.geometry().y()
if (self.clickY > (self.itemY + 88)) & (rotated == True):
self.start = QtCore.QPointF(self.itemX - 49, self.itemY + 176)
elif (self.clickY < (self.itemY + 88)) & (rotated == True):
self.start = QtCore.QPointF(self.itemX - 49, self.itemY)
elif self.clickX < (self.itemX + 88):
self.start = QtCore.QPointF(self.itemX, self.itemY + 49)
elif self.clickX > (self.itemX + 88):
self.start = QtCore.QPointF(self.itemX + 176, self.itemY + 49)
print self.start
if event.buttons() == QtCore.Qt.RightButton:
self.end = event.pos()
self.end = self.mapToGlobal(event.pos())
self.end = self.CircuitView.mapFromGlobal(self.end)
self.end = self.CircuitView.mapToScene(self.end)
self.clickX = self.end.x()
self.clickY = self.end.y()
self.selectedItem = self.scene.itemAt(self.end)
self.itemX = self.selectedItem.geometry().x()
self.itemY = self.selectedItem.geometry().y()
if (self.clickY > (self.itemY + 88)) & (rotated == True):
self.end = QtCore.QPointF(self.itemX - 49, self.itemY + 176)
elif (self.clickY < (self.itemY + 88)) & (rotated == True):
self.end = QtCore.QPointF(self.itemX - 49, self.itemY)
elif self.clickX < (self.itemX + 88):
self.end = QtCore.QPointF(self.itemX, self.itemY + 49)
elif self.clickX > (self.itemX + 88):
self.end = QtCore.QPointF(self.itemX + 176, self.itemY + 49)
self.wire = QtGui.QGraphicsLineItem(QtCore.QLineF(
self.start, self.end))
self.scene.addItem(self.wire)
if self.start == self.end:
self.scene.removeItem(self.wire)
else:
print self.start, self.end
rotated = False
def drawPlayHead(self):
self.play_head = QtGui.QGraphicsLineItem(self.piano_width,
self.header_height,
self.piano_width,
self.total_height)
self.play_head.setPen(QtGui.QPen(QtGui.QColor(255, 255, 255, 50), 2))
self.play_head.setZValue(1.)
self.addItem(self.play_head)
def render(self, nodeLayer, slotLabelLayer, nodeLabelLayer, lineLayer):
data = {'type': 'Link', 'id': self.nodeId}
self.line = line = QtGui.QGraphicsLineItem(self.x, self.y,
self.x + self.width, self.y)
line.setPen(VisCrossLinkNode.getPen(self.node.name))
data['gItem'] = 'Line'
line.setData(0, json.dumps(data))
nodeLayer.add(line)
def mouseMoveEvent(self, event):
if self.curLine:
self.scene.removeItem(self.curLine)
self._movePos = event.pos()
start = QtCore.QPointF(self.mapToScene(self._start))
midle = QtCore.QPointF(self.mapToScene(self._movePos))
self.curLine = QtGui.QGraphicsLineItem(QtCore.QLineF(start, midle))
self.scene.addItem(self.curLine)
def redrawLines(self, coordinates):
if len(coordinates) > 0:
for i in range(len(coordinates)):
curCoord=coordinates[i]
x1, y1, x2, y2 = curCoord
curLine=QtGui.QGraphicsLineItem(x1, y1, x2, y2)
self.scene.addItem(curLine)
self.lines.append(curLine)
def mouseReleaseEvent(self, event):
start = QtCore.QPointF(self.mapToScene(self._start))
end = QtCore.QPointF(self.mapToScene(event.pos()))
curLine = QtGui.QGraphicsLineItem(QtCore.QLineF(start, end))
self.scene.addItem(curLine)
self.lines.append(curLine)
print("Number of lines: "),
print(len(self.lines))
