def paint(self, painter, option, widget=None):
"""QGraphicsRectItem virtual
"""
# TODO LH Is there a way to clip to overlapping
# QAbstractGraphicsItems with a larger zorder
# TODO LH Get pixmap without tight coupling to scene
if not self.has_mouse():
painter.drawPixmap(self.boundingRect(),
self.scene().pixmap,
self.sceneBoundingRect())
with painter_state(painter):
outline_colour, fill_colour = self.colours
# Cosmetic pens "...draw strokes that have a constant width
# regardless of any transformations applied to the QPainter they are
# used with."
pen = QPen(outline_colour, self.BOX_WIDTH, Qt.SolidLine)
pen.setCosmetic(True)
painter.setPen(pen)
r = self.boundingRect()
painter.drawRect(r)
if fill_colour:
painter.fillRect(r, fill_colour)
def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
if (tileWidth <= 0 or tileHeight <= 0):
return
startX = max(0, int(rect.x() / tileWidth) * tileWidth)
startY = max(0, int(rect.y() / tileHeight) * tileHeight)
endX = min(math.ceil(rect.right()), self.map().width() * tileWidth + 1)
endY = min(math.ceil(rect.bottom()),
self.map().height() * tileHeight + 1)
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
if (startY < endY):
gridPen.setDashOffset(startY)
painter.setPen(gridPen)
for x in range(startX, endX, tileWidth):
painter.drawLine(x, startY, x, endY - 1)
if (startX < endX):
gridPen.setDashOffset(startX)
painter.setPen(gridPen)
for y in range(startY, endY, tileHeight):
painter.drawLine(startX, y, endX - 1, y)
def paintEvent(self, event):
_size = self.size() - QSize(2, 2)
if (_size.isEmpty()):
return
origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5
origY = (_size.height() -
self.mNewSize.height() * self.mScale) / 2 + 0.5
oldRect = QRect(self.mOffset, self.mOldSize)
painter = QPainter(self)
painter.translate(origX, origY)
painter.scale(self.mScale, self.mScale)
pen = QPen(Qt.black)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(QRect(QPoint(0, 0), self.mNewSize))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.setBrush(Qt.white)
painter.setOpacity(0.5)
painter.drawRect(oldRect)
pen.setColor(Qt.black)
pen.setStyle(Qt.DashLine)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
painter.setPen(pen)
painter.drawRect(oldRect)
painter.end()
def drawRuler(self, annotations):
# warging! this might move the pick points to the centroids of the blobs, redraw!
measure = self.computeMeasure(annotations)
tmp = self.pick_points.points.copy()
self.pick_points.reset()
self.pick_points.addPoint(tmp[0][0], tmp[0][1], self.pick_style)
self.pick_points.addPoint(tmp[1][0], tmp[1][1], self.pick_style)
# pick points number is now 2
pen = QPen(Qt.blue)
pen.setWidth(2)
pen.setCosmetic(True)
start = self.pick_points.points[0]
end = self.pick_points.points[1]
line = self.scene.addLine(start[0], start[1], end[0], end[1], pen)
line.setZValue(5)
self.pick_points.markers.append(line)
middle_x = (start[0] + end[0]) / 2.0
middle_y = (start[1] + end[1]) / 2.0
middle = self.scene.addEllipse(middle_x, middle_y, 0, 0)
middle.setZValue(5)
ruler_text = self.scene.addText('%.1f cm' % measure)
ruler_text.setFont(QFont("Calibri", 12, QFont.Bold))
ruler_text.setDefaultTextColor(Qt.white)
ruler_text.setPos(middle_x, middle_y)
ruler_text.setParentItem(middle)
ruler_text.setFlag(QGraphicsItem.ItemIgnoresTransformations)
ruler_text.setZValue(5)
self.pick_points.markers.append(ruler_text)
self.pick_points.markers.append(middle)
self.log.emit("[TOOL][RULER] Measure taken.")
def __init__(
self,
strand_item: PathStrandItemT,
cap_type: str, # low, high, dual
is_drawn5to3: bool):
"""The parent should be a StrandItem."""
super(EndpointItem, self).__init__(strand_item.virtualHelixItem())
self._strand_item = strand_item
self._getActiveTool = strand_item._getActiveTool
self.cap_type = cap_type
self._low_drag_bound = None
self._high_drag_bound = None
self._mod_item = None
self._isdrawn5to3 = is_drawn5to3
self._initCapSpecificState(is_drawn5to3)
p = QPen()
p.setCosmetic(True)
self.setPen(p)
# for easier mouseclick
self._click_area = cA = QGraphicsRectItem(_DEFAULT_RECT, self)
self._click_area.setAcceptHoverEvents(True)
cA.hoverMoveEvent = self.hoverMoveEvent
cA.mousePressEvent = self.mousePressEvent
cA.mouseMoveEvent = self.mouseMoveEvent
cA.setPen(_NO_PEN)
self.setFlag(QGraphicsItem.ItemIsSelectable)
def initPainter(self):
pen = QPen()
pen.setWidth(1)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
pen.setCosmetic(True)
self.setPen(pen)
def paint (self, painter, style, widget):
if widget is not self.treeview.viewport():
pen = QPen(FlPalette.light)
pen.setCosmetic(True)
painter.setPen(pen)
painter.setBrush(QBrush())
painter.drawRect(self.boundingRect())
def paintEvent(self, ev: QtGui.QPaintEvent):
painter = QPainter(self)
pen = QPen(Qt.blue)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawPath(self.path)
def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
r = rect.toAlignedRect()
r.adjust(-tileWidth / 2, -tileHeight / 2, tileWidth / 2,
tileHeight / 2)
startX = int(max(0.0, self.screenToTileCoords_(r.topLeft()).x()))
startY = int(max(0.0, self.screenToTileCoords_(r.topRight()).y()))
endX = int(
min(self.map().width(),
self.screenToTileCoords_(r.bottomRight()).x()))
endY = int(
min(self.map().height(),
self.screenToTileCoords_(r.bottomLeft()).y()))
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
painter.setPen(gridPen)
for y in range(startY, endY + 1):
start = self.tileToScreenCoords(startX, y)
end = self.tileToScreenCoords(endX, y)
painter.drawLine(start, end)
for x in range(startX, endX + 1):
start = self.tileToScreenCoords(x, startY)
end = self.tileToScreenCoords(x, endY)
painter.drawLine(start, end)
def draw(self, p: QPainter, scale: float):
p.save()
if self.selected:
pen = QPen(QColor("red"))
pen.setWidthF(2)
else:
pen = QPen(QColor("black"))
pen.setWidthF(1)
pen.setCosmetic(True)
p.setPen(pen)
brush = QBrush(QColor("black"))
brush.setStyle(Qt.Dense7Pattern)
brush.setTransform(QTransform().scale(1 / scale, 1 / scale))
p.setBrush(brush)
if self.v_support and self.h_support:
p.drawRect(
QRectF(self.x - self.radius, self.y - self.radius,
self.radius * 2, self.radius * 2))
elif self.h_support:
self.drawSupport(p, 3)
elif self.v_support:
self.drawSupport(p, 2)
else:
p.drawEllipse(
QRectF(self.x - self.radius, self.y - self.radius,
self.radius * 2, self.radius * 2))
p.drawLine(QPointF(self.x - 0.125, self.y),
QPointF(self.x + 0.125, self.y))
p.drawLine(QPointF(self.x, self.y - 0.125),
QPointF(self.x, self.y + 0.125))
p.restore()
def __init__(self, part_item, model_virtual_helix, viewroot):
super(VirtualHelixItem, self).__init__(part_item.proxy())
self._part_item = part_item
self._model_virtual_helix = model_virtual_helix
self._viewroot = viewroot
self._getActiveTool = part_item._getActiveTool
self._controller = VirtualHelixItemController(self, model_virtual_helix)
self._handle = VirtualHelixHandleItem(model_virtual_helix, part_item, viewroot)
self._last_strand_set = None
self._last_idx = None
self._scaffoldBackground = None
self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption)
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.setBrush(QBrush(Qt.NoBrush))
view = viewroot.scene().views()[0]
view.levelOfDetailChangedSignal.connect(self.levelOfDetailChangedSlot)
shouldShowDetails = view.shouldShowDetails()
pen = QPen(styles.MINOR_GRID_STROKE, styles.MINOR_GRID_STROKE_WIDTH)
pen.setCosmetic(shouldShowDetails)
self.setPen(pen)
self.refreshPath()
self.setAcceptHoverEvents(True) # for pathtools
self.setZValue(styles.ZPATHHELIX)
def __init__(self, strand_item: PathStrandItemT,
cap_type: str, # low, high, dual
is_drawn5to3: bool):
"""The parent should be a StrandItem."""
super(EndpointItem, self).__init__(strand_item.virtualHelixItem())
self._strand_item = strand_item
self._getActiveTool = strand_item._getActiveTool
self.cap_type = cap_type
self._low_drag_bound = None
self._high_drag_bound = None
self._mod_item = None
self._isdrawn5to3 = is_drawn5to3
self._initCapSpecificState(is_drawn5to3)
p = QPen()
p.setCosmetic(True)
self.setPen(p)
# for easier mouseclick
self._click_area = cA = QGraphicsRectItem(_DEFAULT_RECT, self)
self._click_area.setAcceptHoverEvents(True)
cA.hoverMoveEvent = self.hoverMoveEvent
cA.mousePressEvent = self.mousePressEvent
cA.mouseMoveEvent = self.mouseMoveEvent
cA.setPen(_NO_PEN)
self.setFlag(QGraphicsItem.ItemIsSelectable)
class EditPoints(QObject):
log = pyqtSignal(str)
def __init__(self, scene):
super(EditPoints, self).__init__()
self.scene = scene
self.points = []
self.border_pen = QPen(Qt.black, 3)
# pen.setJoinStyle(Qt.MiterJoin)
# pen.setCapStyle(Qt.RoundCap)
self.border_pen.setCosmetic(True)
self.qpath_gitem = self.scene.addPath(QPainterPath(), self.border_pen)
self.qpath_gitem.setZValue(5)
self.last_editborder_points = []
self.last_blob = None
def reset(self):
self.qpath_gitem.setPath(QPainterPath())
self.points = []
#return true if the first points for a tool
def startDrawing(self, x, y):
first_start = False
if len(self.points) == 0: # first point, initialize
self.qpath_gitem.setPath(QPainterPath())
first_start = True
message = "[TOOL] DRAWING starts.."
self.log.emit(message)
self.points.append(np.array([[x, y]]))
path = self.qpath_gitem.path()
path.moveTo(QPointF(x, y))
self.qpath_gitem.setPath(path)
self.scene.invalidate()
return first_start
def move(self, x, y):
if len(self.points) == 0:
return
# check that a move didn't happen before a press
last_line = self.points[-1]
last_point = self.points[-1][-1]
if x != last_point[0] or y != last_point[1]:
self.points[-1] = np.append(last_line, [[x, y]], axis=0)
path = self.qpath_gitem.path()
path.lineTo(QPointF(x, y))
self.qpath_gitem.setPath(path)
self.scene.invalidate()
def paint(self, painter, option, widget=None):
"""Draw a Bezier curve connecting selected Nodes"""
qp = painter
qp.setRenderHint(QPainter.HighQualityAntialiasing)
from_point = self.start.get_pos()
posn1 = self.handle1.scenePos()
posn2 = self.handle2.scenePos()
path = QPainterPath(from_point)
if self.end_term:
self.end_point = self.end_term.get_pos()
# Draw path
path.cubicTo(posn1, posn2, self.end_point)
wire_pen = QPen(QColor('#aa00ff'), 2)
wire_pen.setCosmetic(True)
qp.setPen(wire_pen)
qp.drawPath(path)
if self.parent.vis:
#if self.isSelected():
# Draw helper lines (https://gist.github.com/Alquimista/1274149)
control_points = ((from_point.x(), from_point.y()),
(posn1.x(), posn1.y()), (posn2.x(), posn2.y()),
(self.end_point.x(), self.end_point.y()))
old_point = control_points[0]
helper_pen = QPen(Qt.darkGreen, 1, Qt.DashLine)
for i, point in enumerate(control_points[1:]):
i += 2
qp.setPen(helper_pen)
qp.drawLine(old_point[0], old_point[1], point[0], point[1])
old_point = point
def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
r = rect.toAlignedRect()
r.adjust(-tileWidth / 2, -tileHeight / 2, tileWidth / 2, tileHeight / 2)
startX = int(max(0.0, self.screenToTileCoords_(r.topLeft()).x()))
startY = int(max(0.0, self.screenToTileCoords_(r.topRight()).y()))
endX = int(min(self.map().width(), self.screenToTileCoords_(r.bottomRight()).x()))
endY = int(min(self.map().height(), self.screenToTileCoords_(r.bottomLeft()).y()))
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
painter.setPen(gridPen)
for y in range(startY, endY+1):
start = self.tileToScreenCoords(startX, y)
end = self.tileToScreenCoords(endX, y)
painter.drawLine(start, end)
for x in range(startX, endX+1):
start = self.tileToScreenCoords(x, startY)
end = self.tileToScreenCoords(x, endY)
painter.drawLine(start, end)
def drawGrid(self, painter, rect, gridColor):
tileWidth = self.map().tileWidth()
tileHeight = self.map().tileHeight()
if (tileWidth <= 0 or tileHeight <= 0):
return
startX = max(0, int(rect.x() / tileWidth) * tileWidth)
startY = max(0, int(rect.y() / tileHeight) * tileHeight)
endX = min(math.ceil(rect.right()), self.map().width() * tileWidth + 1)
endY = min(math.ceil(rect.bottom()), self.map().height() * tileHeight + 1)
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
if (startY < endY):
gridPen.setDashOffset(startY)
painter.setPen(gridPen)
for x in range(startX, endX, tileWidth):
painter.drawLine(x, startY, x, endY - 1)
if (startX < endX):
gridPen.setDashOffset(startX)
painter.setPen(gridPen)
for y in range(startY, endY, tileHeight):
painter.drawLine(startX, y, endX - 1, y)
def paint(self, painter, option, widget=None):
"""QGraphicsRectItem virtual
"""
# TODO LH Is there a way to clip to overlapping
# QAbstractGraphicsItems with a larger zorder
# TODO LH Get pixmap without tight coupling to scene
if not self.has_mouse():
painter.drawPixmap(self.boundingRect(),
self.scene().pixmap, self.sceneBoundingRect())
with painter_state(painter):
outline_colour, fill_colour = self.colours
# Cosmetic pens "...draw strokes that have a constant width
# regardless of any transformations applied to the QPainter they are
# used with."
pen = QPen(outline_colour, self.BOX_WIDTH, Qt.SolidLine)
pen.setCosmetic(True)
painter.setPen(pen)
r = self.boundingRect()
painter.drawRect(r)
if fill_colour:
painter.fillRect(r, fill_colour)
def paintEvent(self, event):
_size = self.size() - QSize(2, 2)
if (_size.isEmpty()):
return
origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5
origY = (_size.height() - self.mNewSize.height() * self.mScale) / 2 + 0.5
oldRect = QRect(self.mOffset, self.mOldSize)
painter = QPainter(self)
painter.translate(origX, origY)
painter.scale(self.mScale, self.mScale)
pen = QPen(Qt.black)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(QRect(QPoint(0, 0), self.mNewSize))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.setBrush(Qt.white)
painter.setOpacity(0.5)
painter.drawRect(oldRect)
pen.setColor(Qt.black)
pen.setStyle(Qt.DashLine)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
painter.setPen(pen)
painter.drawRect(oldRect)
painter.end()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
pen = QPen(Qt.red)
pen.setWidth(3)
pen.setCapStyle(Qt.RoundCap)
scene = QtWidgets.QGraphicsScene()
pen.setCosmetic(True)
scene.addPixmap(QPixmap('back.png'))
self.item = scene.addLine(60, 170, 97, 97, pen)
pen = QtGui.QPen(QtGui.QColor(QtCore.Qt.gray))
brush = QtGui.QBrush(pen.color().darker(100))
scene.addEllipse(87, 87, 20, 20, pen, brush)
self.item.setTransformOriginPoint(97, 97)
self.Grafik.setScene(scene)
self.stop_flag_time = Event()
self.stop_flag_RS232 = Event()
self.getController = Controller(self.stop_flag_time)
self.getController.start()
self.getController.newTime.connect(self.updateTime)
self.getArduino = ControlArduino(self.stop_flag_RS232)
self.getArduino.newValue.connect(self.updatePoti)
self.getArduino.testRS232.connect(self.updateInfoRS232)
self.getArduino.start()
def paint(self,
painter: QtGui.QPainter,
option: QStyleOptionGraphicsItem,
widget: typing.Optional[QWidget] = ...):
# Set level of detail
# print(option.levelOfDetailFromTransform(painter.worldTransform()))
# draw plus line
painter.save()
pen = QPen()
pen.setColor(QColor("#496856"))
pen.setCosmetic(True)
painter.setPen(pen)
# painter.setRenderHint(painter.Antialiasing)
self.print_cache_path(painter.drawPath, 'plus_line_path', 1000)
# draw minus line
pen.setColor(QColor("#6F3541"))
painter.setPen(pen)
self.print_cache_path(painter.drawPath, 'minus_line_path', 1000)
# draw plus bar
self.print_cache_path(painter.fillPath, 'plus_bar_path', 1000,
QColor('#7BB888'))
# draw minus bar
self.print_cache_path(painter.fillPath, 'minus_bar_path', 1000,
QColor('#CC4E5C'))
painter.restore()
def paint(self,
painter: QtGui.QPainter,
option: 'QStyleOptionGraphicsItem',
widget: QWidget = ...):
close = self.data['close'].reset_index()['close']
close = close - close.min()
close_max = close.max()
close_min = close.min()
if not self.cached:
for i in range(close.size - 1):
self.path.moveTo(i, close[i])
self.path.lineTo(i + 1, close[i + 1])
self.cached = True
pen = QPen(Qt.white)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(0, 0, close.size, close_max - close_min)
pen.setColor(Qt.yellow)
painter.setPen(pen)
painter.drawPath(self.path)
if not self.printed:
rec_item = self.scene().addPath(self.path, QPen(Qt.red))
rec_item.setZValue(-10)
self.printed = True
def drawRaster(self, renderContext):
painter = renderContext.painter()
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.map2pixel = renderContext.mapToPixel()
scaleX = self.xScale / self.map2pixel.mapUnitsPerPixel()
scaleY = self.yScale / self.map2pixel.mapUnitsPerPixel()
rect = QRectF(
QPointF(-self.image.width() / 2.0, -self.image.height() / 2.0),
QPointF(self.image.width() / 2.0, self.image.height() / 2.0),
)
mapCenter = self.map2pixel.transform(self.center)
# draw the image on the map canvas
painter.translate(QPointF(mapCenter.x(), mapCenter.y()))
painter.rotate(self.rotation)
painter.scale(scaleX, scaleY)
painter.drawImage(rect, self.image)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
pen = QPen()
pen.setColor(QColor(0, 0, 0))
pen.setWidth(3)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(rect)
def _default_pen():
pen = QPen(QColor('white'))
pen.setStyle(Qt.SolidLine)
pen.setWidth(3)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
return pen
def drawForeground(self, painter, rect):
if self.showCrossair:
painter.setClipRect(rect)
pen = QPen(Qt.white, 1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawLine(self.mouseCoords.x(), rect.top(), self.mouseCoords.x(), rect.bottom())
painter.drawLine(rect.left(), self.mouseCoords.y(), rect.right(), self.mouseCoords.y())
def getEraserEllipse(self):
brush = QBrush(QColor(0, 0, 0, alpha=64), Qt.SolidPattern)
pen = QPen(brush, 2, Qt.DashDotLine, Qt.RoundCap, Qt.RoundJoin)
pen.setCosmetic(True)
ellipse = QGraphicsEllipseItem(0, 0, self._eraserSize,
self._eraserSize)
ellipse.setPen(pen)
return ellipse
def paint(self,
painter: QtGui.QPainter,
option: 'QStyleOptionGraphicsItem',
widget: QWidget = ...):
pen = QPen()
pen.setCosmetic(True)
pen.setColor(Qt.green)
painter.setPen(pen)
painter.drawPath(self.path)
def set_pen(self, width: int = 3, color: str or QColor = 'white'):
if isinstance(color, str):
color = QColor(color)
pen = QPen(color)
pen.setStyle(Qt.SolidLine)
pen.setWidth(width)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
self.plot.setPen(pen)
def _plot_baseline(self):
if not self.baseline_plot:
self.baseline_plot = self.parent.image_view.plot_item.plot()
pen = QPen(QColor('red'))
pen.setStyle(Qt.DashDotLine)
pen.setWidth(4)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
self.baseline_plot.setData(self._x_axis, self._baseline, pen=pen)
def paintEvent(self, ev: QtGui.QPaintEvent):
painter = QPainter(self)
pen = QPen(Qt.blue)
pen.setCosmetic(True)
painter.setPen(pen)
for i in range(data_range):
painter.fillRect(
QRectF(i / data_range * width, i / data_range * height,
(i + 10) / width, (i + 10) / height), Qt.green)
def paint_poly_points(self, painter):
dot_pen = QPen()
dot_pen.setWidth(4)
dot_pen.setCosmetic(True)
dot_pen.setColor(QColor(255, 0, 255))
painter.setPen(dot_pen)
for i in range(0,
self.polygon().size() -
3): # Don't paint dots on the arrow head
p = self.polygon().value(i)
def __init__(self, lastpos):
super(My_lineitem, self).__init__()
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
pen = QPen(Qt.green)
pen.setWidth(2)
pen.setCosmetic(True)
self.setPen(pen)
self.lastpos = lastpos
self.pos = None
def __init__(self, opt_model, field_num, start_offset):
super().__init__()
fld, wvl, foc = opt_model.optical_spec.lookup_fld_wvl_focus(field_num)
self.rb = layout.RayBundle(opt_model, fld, wvl, start_offset)
self.update_shape()
self.setBrush(QColor(254, 197, 254, 64)) # magenta, 25%
pen = QPen()
pen.setCosmetic(True)
self.setPen(pen)
def new_pen(colour, width=0, style=Qt.SolidLine):
'''
Returns a cosmetic (unaffected by zoom) pen with given colour, width and style.
Default is thin solid line.
'''
pen = QPen(style)
pen.setColor(colour)
pen.setWidth(width)
pen.setCosmetic(True)
return pen
def paint(self, painter, option, widget=None):
painter.save()
palette = self.palette()
border = palette.brush(QPalette.Mid)
pen = QPen(border, 1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.setBrush(palette.brush(QPalette.Window))
brect = self.boundingRect()
painter.drawRoundedRect(brect, 4, 4)
painter.restore()
def initPainter(self):
pen_component_edge = QPen()
pen_component_edge.setWidth(2)
pen_component_edge.setJoinStyle(Qt.RoundJoin)
pen_component_edge.setCosmetic(True)
pen_component_edge.setColor(QColor(192, 192, 192))
brush_component_fill = QBrush()
brush_component_fill.setColor(QColor(0, 0, 64))
brush_component_fill.setStyle(Qt.SolidPattern)
self.setPen(pen_component_edge)
self.setBrush(brush_component_fill)
def __init__(self, element):
super().__init__()
self.oe = layout.OpticalElement(element)
self.update_shape()
color = self.oe.render_color()
self.setBrush(QColor(*color))
pen = QPen()
pen.setCosmetic(True)
self.setPen(pen)
def _updateColor(self, strand):
oligo = strand.oligo()
color = self.pen().color() if self.isSelected() else QColor(oligo.color())
# print "update xover color", color.value(), self.isSelected(), self.group(), self.parentItem()
if oligo.shouldHighlight():
pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH
color.setAlpha(128)
else:
pen_width = styles.PATH_STRAND_STROKE_WIDTH
pen = QPen(color, pen_width)
pen.setCosmetic(False)
pen.setCapStyle(Qt.FlatCap)
self.setPen(pen)
def __init__(self, id_pair, painter_path, initial_pen=None):
super(SingleEdgeItem, self).__init__()
self.parent = None # Should be initialized with set_parent()
self.id_pair = id_pair
if not initial_pen:
initial_pen = QPen()
initial_pen.setCosmetic(True)
initial_pen.setCapStyle(Qt.RoundCap)
initial_pen.setColor(Qt.white)
initial_pen.setWidth(3)
self.setPen(initial_pen)
self.setPath(painter_path)
def __init__(self, parent, child):
''' Create a new connection between a parent and a child item '''
super(Connection, self).__init__(parent)
self.parent = parent
self.child = child
self._start_point = None
self._end_point = None
self._middle_points = []
pen = QPen()
pen.setColor(Qt.blue)
pen.setCosmetic(False)
self.setPen(pen)
self.parent_rect = parent.sceneBoundingRect()
self.childRect = child.sceneBoundingRect()
# Activate cache mode to boost rendering by calling paint less often
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
def paint(self, painter, option, widget = None):
if (self.mRectangle.isNull()):
return
# Draw a shadow
black = QColor(Qt.black)
black.setAlpha(128)
pen = QPen(black, 2, Qt.DotLine)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(self.mRectangle.translated(1, 1))
# Draw a rectangle in the highlight color
highlight = QApplication.palette().highlight().color()
pen.setColor(highlight)
highlight.setAlpha(32)
painter.setPen(pen)
painter.setBrush(highlight)
painter.drawRect(self.mRectangle)
def paint(self, painter, arg2, arg3):
horizontal = [
QLineF(self.mBoundingRect.topRight(), self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.bottomLeft())]
vertical = [
QLineF(self.mBoundingRect.bottomLeft(), self.mBoundingRect.topLeft()),
QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.topRight())]
dashPen = QPen(Qt.DashLine)
dashPen.setCosmetic(True)
dashPen.setDashOffset(max(0.0, self.x()))
painter.setPen(dashPen)
painter.drawLines(horizontal)
dashPen.setDashOffset(max(0.0, self.y()))
painter.setPen(dashPen)
painter.drawLines(vertical)
def openFile(self, svg_file):
if not svg_file.exists():
return
s = self.scene()
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = False
if self.outlineItem:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
s.clear()
self.resetTransform()
self.svgItem = QGraphicsSvgItem(svg_file.fileName())
self.svgItem.setFlags(QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
self.backgroundItem = QGraphicsRectItem(self.svgItem.boundingRect())
self.backgroundItem.setBrush(Qt.white)
self.backgroundItem.setPen(QPen(Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
self.outlineItem = QGraphicsRectItem(self.svgItem.boundingRect())
outline = QPen(Qt.black, 2, Qt.DashLine)
outline.setCosmetic(True)
self.outlineItem.setPen(outline)
self.outlineItem.setBrush(QBrush(Qt.NoBrush))
self.outlineItem.setVisible(drawOutline)
self.outlineItem.setZValue(1)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
s.addItem(self.outlineItem)
s.setSceneRect(self.outlineItem.boundingRect().adjusted(-10, -10, 10, 10))
def createPen(style=Qt.SolidLine, color='black', width=1):
"""
Use this function to conveniently create a cosmetic pen with specified
width. Integer widths create cosmetic pens (default) and float widths
create scaling pens (this way you can set the figure style by changing a
number).
This is particularly important on PyQt5 where the default pen blacks out
large areas of the figure if not being careful.
"""
pen = QPen(style)
pen.setColor(QColor(color))
if isinstance(width, int):
pen.setWidth(width)
pen.setCosmetic(True)
else:
pen.setWidthF(width)
pen.setCosmetic(False)
return pen
def paint(self, painter, option, widget=None):
"""
Paint a single line of the slice intersection marker.
"""
width = self._parent._width
height = self._parent._height
thickness = self._parent.PEN_THICKNESS
# Our pen thickness is consistent across zoom levels because the pen is "cosmetic"
# However, that doesn't ensure a consistent-size dash pattern.
# Determine the inverse scaling factor from scene to view to set a consistent dash pattern at all scales.
view = self.scene().views()[0]
inverted_transform, has_inverse = view.transform().inverted()
dash_length = old_div(4, inverted_transform.m11())
dash_length = max(0.5, dash_length)
# Draw the line with two pens to get a black-and-white dashed line.
# pen_white = QPen( Qt.white, thickness )
pen_white = QPen(self._parent._cropColor, thickness)
pen_white.setDashPattern([dash_length, dash_length])
pen_white.setCosmetic(True)
pen_black = QPen(Qt.black, thickness)
pen_black.setDashPattern([dash_length, dash_length])
pen_black.setCosmetic(True)
pen_black.setDashOffset(dash_length)
with painter_context(painter):
t = painter.transform()
painter.setTransform(self.scene().data2scene * t)
# Draw the line with two pens to get a black-and-white dashed line.
for pen in [pen_white, pen_black]:
painter.setPen(pen)
if self._direction == "horizontal":
painter.drawLine(QPointF(0.0, self.position), QPointF(width, self.position))
else:
painter.drawLine(QPointF(self.position, 0.0), QPointF(self.position, height))
def _updateHighlight(self, color):
"""
"""
#TODO: called when oligo is highlighted
oligo = self._model_strand.oligo()
pen_width = styles.PATH_STRAND_STROKE_WIDTH
if oligo.shouldHighlight():
color.setAlpha(128)
pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH
pen = QPen(color, pen_width)
pen.setCosmetic(False)
brush = QBrush(color)
pen.setCapStyle(QtCore.Qt.FlatCap)
self.setPen(pen)
self._low_cap.updateHighlight(brush)
self._high_cap.updateHighlight(brush)
self._dual_cap.updateHighlight(brush)
self._tick.updateHighlight(brush)
self.toeholdCap3p().updateHighlight(brush)
self.toeholdCap5p().updateHighlight(brush)
def __init__ (self, source):
super().__init__()
self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.childpos = []
self.source = source
self.sourceright = 0
source.setedge(self)
self.style = FlGlob.mainwindow.style
self.arrowsize = self.style.arrowsize
self.pensize = self.style.pensize
pen = QPen(FlPalette.light, self.pensize, cap = Qt.FlatCap, join=Qt.MiterJoin)
pen.setCosmetic(False)
brush = QBrush(FlPalette.light)
pen2 = QPen(pen)
pen2.setColor(FlPalette.dark)
brush2 = QBrush(FlPalette.dark)
visuals = dict()
visuals[True] = (pen, brush)
visuals[False] = (pen2, brush2)
self.visuals = visuals
def draw(self, painter, height, factor):
painter.save()
painter.translate(0, -CURVE_Y_OFFSET_COMPENSATION)
painter.scale(1, -factor)
painter.translate(0, -self.value_min)
pen = QPen()
pen.setCosmetic(True)
pen.setWidth(0)
pen.setColor(Qt.black)
painter.setPen(pen)
if DEBUG:
painter.fillRect(QRectF(0, self.value_min,
-self.axis_line_thickness - self.tick_mark_size_large, self.value_max - self.value_min),
Qt.cyan)
# axis line
painter.drawLine(QLineF(-self.axis_line_thickness, self.value_min,
-self.axis_line_thickness, self.value_max))
# ticks
tick_text_values = []
value = self.value_min
while fuzzy_leq(value, self.value_max):
tick_text_values.append(value)
painter.drawLine(QLineF(-self.axis_line_thickness, value,
-self.axis_line_thickness - self.tick_mark_size_large, value))
for i in range(1, self.step_subdivision_count):
subvalue = value + (self.step_size * i / self.step_subdivision_count)
if not fuzzy_leq(subvalue, self.value_max):
break
if i % 2 == 0 and self.step_subdivision_count % 2 == 0:
tick_mark_size = self.tick_mark_size_medium
else:
tick_mark_size = self.tick_mark_size_small
painter.drawLine(QLineF(-self.axis_line_thickness, subvalue,
-self.axis_line_thickness - tick_mark_size, subvalue))
value += self.step_size
painter.restore()
painter.setFont(self.tick_text_font)
tick_text_x = -self.axis_line_thickness - \
self.tick_mark_size_large - \
self.tick_mark_to_tick_text - \
self.tick_text_max_width
tick_text_width = self.tick_text_max_width
tick_text_height = self.tick_text_height_half * 2
transform = QTransform()
transform.translate(0, -CURVE_Y_OFFSET_COMPENSATION)
transform.scale(1, -factor)
transform.translate(0, -self.value_min)
for value in tick_text_values:
tick_text_point = transform.map(QPointF(tick_text_x, value))
tick_text_x = tick_text_point.x()
tick_text_y = tick_text_point.y() - self.tick_text_height_half
if DEBUG:
painter.fillRect(tick_text_x, tick_text_y,
tick_text_width, tick_text_height,
Qt.yellow)
painter.drawText(tick_text_x, tick_text_y, tick_text_width, tick_text_height,
Qt.TextDontClip | Qt.AlignRight | Qt.AlignVCenter,
self.tick_value_to_str(value))
# title
title_width = height
title_height = self.title_text_height
if self.title_text_pixmap == None or self.title_text_pixmap.size() != QSize(title_width, title_height):
self.title_text_pixmap = QPixmap(title_width + 100, title_height + 100)
self.title_text_pixmap.fill(QColor(0, 0, 0, 0))
title_painter = QPainter(self.title_text_pixmap)
if DEBUG:
title_painter.fillRect(50, 50, title_width, title_height, Qt.yellow)
title_painter.setFont(self.title_text_font)
title_painter.drawText(50, 50, title_width, title_height,
Qt.TextWordWrap | Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignTop,
self.title_text)
title_painter = None
painter.save()
painter.rotate(-90)
painter.translate(-50, -50)
title_x = -1
title_y = -self.axis_line_thickness - \
self.tick_mark_size_large - \
self.tick_mark_to_tick_text - \
self.tick_text_max_width - \
self.tick_text_to_title_text - \
max(self.title_text_padding, 0) - \
title_height
painter.drawPixmap(title_x, title_y, self.title_text_pixmap)
painter.restore()
class CrossHairCursor(QGraphicsItem):
"""
A 2D cross-hair cursor centered around a point (x,y) on the scene.
A cross hair cursor usually follows the mouse cursor and has a color
and marks the size of the current brush.
"""
modeYPosition = 0
modeXPosition = 1
modeXYPosition = 2
def boundingRect(self):
return self.scene().data2scene.mapRect(QRectF(0, 0, self._width, self._height))
def __init__(self):
QGraphicsItem.__init__(self)
self._width = 0
self._height = 0
self.penDotted = QPen(Qt.red, 2, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin)
self.penDotted.setCosmetic(True)
self.penSolid = QPen(Qt.red, 2)
self.penSolid.setCosmetic(True)
self.x = 0
self.y = 0
self.brushSize = 0
self.mode = self.modeXYPosition
self._enabled = True
@property
def enabled(self):
return self._enabled
@enabled.setter
def enabled(self, v):
if not v:
self.setVisible(False)
self._enabled = v
def setVisible(self, visible):
# TODO: though the crosshair is hidden, its position is still
# updated. instead of just hiding it, we should
# not instantiate it in the first place.
if self._enabled:
super(CrossHairCursor, self).setVisible(visible)
# be careful: QGraphicsItem has a shape() method, which
# we cannot override, therefore we choose this name
@property
def dataShape(self):
return (self._width, self._height)
@dataShape.setter
def dataShape(self, shape2D):
self._width = shape2D[0]
self._height = shape2D[1]
def setColor(self, color):
self.penDotted = QPen(color, 2, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin)
self.penDotted.setCosmetic(True)
self.penSolid = QPen(color, 2)
self.penSolid.setCosmetic(True)
self.update()
def showXPosition(self, x, y):
"""only mark the x position by displaying a line f(y) = x"""
self.setVisible(True)
self.mode = self.modeXPosition
self.setPos(x, y - int(y))
def showYPosition(self, y, x):
"""only mark the y position by displaying a line f(x) = y"""
self.setVisible(True)
self.mode = self.modeYPosition
self.setPos(x - int(x), y)
def showXYPosition(self, x, y):
"""mark the (x,y) position by displaying a cross hair cursor
including a circle indicating the current brush size"""
self.setVisible(True)
self.mode = self.modeXYPosition
self.setPos(x, y)
def paint(self, painter, option, widget=None):
painter.save()
painter.setTransform(self.scene().data2scene * painter.transform())
painter.setPen(self.penDotted)
if self.mode == self.modeXPosition:
painter.drawLine(QPointF(self.x + 0.5, 0), QPointF(self.x + 0.5, self._height))
elif self.mode == self.modeYPosition:
painter.drawLine(QPointF(0, self.y), QPointF(self.width, self.y))
else:
painter.drawLine(
QPointF(self.x - 0.5 * self.brushSize - 3, self.y), QPointF(self.x - 0.5 * self.brushSize, self.y)
)
painter.drawLine(
QPointF(self.x + 0.5 * self.brushSize, self.y), QPointF(self.x + 0.5 * self.brushSize + 3, self.y)
)
painter.drawLine(
QPointF(self.x, self.y - 0.5 * self.brushSize - 3), QPointF(self.x, self.y - 0.5 * self.brushSize)
)
painter.drawLine(
QPointF(self.x, self.y + 0.5 * self.brushSize), QPointF(self.x, self.y + 0.5 * self.brushSize + 3)
)
painter.setPen(self.penSolid)
painter.drawEllipse(QPointF(self.x, self.y), 0.5 * self.brushSize, 0.5 * self.brushSize)
painter.restore()
def setPos(self, x, y):
self.x = x
self.y = y
self.update()
def setBrushSize(self, size):
self.brushSize = size
self.update()
if __name__ == "__main__":
import time
import numpy as np
from PyQt5.QtGui import QTransform
from PyQt5.QtWidgets import QApplication, QGraphicsView, QGraphicsScene
app = QApplication([])
import h5py
with h5py.File("/magnetic/data/multicut-testdata/2d/256/Superpixels.h5", "r") as superpixels_f:
labels_img = superpixels_f["data"][:]
labels_img = labels_img[..., 0] # drop channel
default_pen = QPen()
default_pen.setCosmetic(True)
default_pen.setCapStyle(Qt.RoundCap)
default_pen.setColor(Qt.blue)
default_pen.setWidth(3)
# Changes to this pen table will be detected automatically in the QGraphicsItem
pen_table = SignalingDict(None)
start = time.time()
path_items = generate_path_items_for_labels(pen_table, default_pen, labels_img, None)
print("generate took {}".format(time.time() - start)) # 52 ms
edges_item = SegmentationEdgesItem(path_items, pen_table, default_pen)
def assign_random_color(id_pair, buttons):
print("handling click: {}".format(id_pair))
class Arrow(QGraphicsLineItem):
def __init__(self, startp=Point(), endp=None,
length=60.0, angle=50.0,
color=QtCore.Qt.red, pencolor=QtCore.Qt.green,
startarrow=True):
"""
Initialisation of the class.
"""
self.sc = None
super(Arrow, self).__init__()
self.startp = QtCore.QPointF(startp.x, -startp.y)
self.endp = endp
self.length = length
self.angle = angle
self.startarrow = startarrow
self.allwaysshow = False
self.arrowHead = QPolygonF()
self.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.myColor = color
self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine)
self.pen.setCosmetic(True)
self.arrowSize = 8.0
def contains_point(self, point):
"""
Arrows cannot be selected. Return maximal distance
"""
return float(0x7fffffff)
def setSelected(self, flag=True, blockSignals=True):
"""
Override inherited function to turn off selection of Arrows.
@param flag: The flag to enable or disable Selection
"""
if self.allwaysshow:
pass
elif flag is True:
self.show()
else:
self.hide()
def setallwaysshow(self, flag=False):
"""
If the directions shall be allwaysshown the parameter
will be set and all paths will be shown.
@param flag: The flag to enable or disable Selection
"""
self.allwaysshow = flag
if flag is True:
self.show()
elif flag is True and self.isSelected():
self.show()
else:
self.hide()
def paint(self, painter, option, widget=None):
"""
Method for painting the arrow.
"""
demat = painter.deviceTransform()
self.sc = demat.m11()
if self.endp is None:
dx = cos(self.angle) * self.length / self.sc
dy = sin(self.angle) * self.length / self.sc
endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy)
else:
endp = QtCore.QPointF(self.endp.x, -self.endp.y)
arrowSize = self.arrowSize / self.sc
painter.setPen(self.pen)
painter.setBrush(self.myColor)
self.setLine(QtCore.QLineF(endp, self.startp))
line = self.line()
if line.length() != 0:
angle = acos(line.dx() / line.length())
if line.dy() >= 0:
angle = (pi * 2.0) - angle
if self.startarrow:
arrowP1 = line.p2() - QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize,
cos(angle + pi / 3.0) * arrowSize)
arrowP2 = line.p2() - QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize,
cos(angle + pi - pi / 3.0) * arrowSize)
self.arrowHead.clear()
for Point in [line.p2(), arrowP1, arrowP2]:
self.arrowHead.append(Point)
else:
arrowP1 = line.p1() + QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize,
cos(angle + pi / 3.0) * arrowSize)
arrowP2 = line.p1() + QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize,
cos(angle + pi - pi / 3.0) * arrowSize)
self.arrowHead.clear()
for Point in [line.p1(), arrowP1, arrowP2]:
self.arrowHead.append(Point)
painter.drawLine(line)
painter.drawPolygon(self.arrowHead)
def boundingRect(self):
"""
Override inherited function to enlarge selection of Arrow to include all
@param flag: The flag to enable or disable Selection
"""
if not self.sc: # since this function is called before paint; and scale is unknown
return QtCore.QRectF(self.startp.x(), self.startp.y(), 1e-9, 1e-9)
arrowSize = self.arrowSize / self.sc
extra = arrowSize # self.pen.width() +
if self.endp is None:
dx = cos(self.angle) * self.length / self.sc
dy = sin(self.angle) * self.length / self.sc
endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy)
else:
endp = QtCore.QPointF(self.endp.x, -self.endp.y)
brect = QtCore.QRectF(self.startp,
QtCore.QSizeF(endp.x()-self.startp.x(),
endp.y()-self.startp.y())).normalized().adjusted(-extra, -extra, extra, extra)
return brect
class WpZero(QGraphicsItem):
"""
class WpZero
"""
def __init__(self, center, color=QtCore.Qt.gray):
self.sc = None
super(WpZero, self).__init__()
self.center = center
self.allwaysshow = False
self.color = color
self.pen = QPen(QtCore.Qt.darkGray, 1, QtCore.Qt.SolidLine)
self.pen.setCosmetic(True)
self.diameter = 23.0
def contains_point(self, point):
"""
WpZero cannot be selected. Return maximal distance
"""
return float(0x7fffffff)
def setSelected(self, *args):
"""
Override inherited function - with possibility to be called with multiple arguments
"""
pass
def paint(self, painter, option, widget=None):
"""
paint()
"""
painter.setPen(self.pen)
demat = painter.deviceTransform()
self.sc = demat.m11()
diameter1 = self.diameter / self.sc
diameter2 = (self.diameter - 4) / self.sc
rectangle1 = QtCore.QRectF(-diameter1 / 2, -diameter1 / 2, diameter1, diameter1)
rectangle2 = QtCore.QRectF(-diameter2 / 2, -diameter2 / 2, diameter2, diameter2)
startAngle1 = 90 * 16
spanAngle = 90 * 16
startAngle2 = 270 * 16
painter.drawEllipse(rectangle1)
painter.drawEllipse(rectangle2)
painter.drawPie(rectangle2, startAngle1, spanAngle)
painter.setBrush(self.color)
painter.drawPie(rectangle2, startAngle2, spanAngle)
def boundingRect(self):
"""
Override inherited function to enlarge selection of Arrow to include all
@param flag: The flag to enable or disable Selection
"""
if not self.sc: # since this function is called before paint; and scale is unknown
return QtCore.QRectF(0, 0, 1e-9, 1e-9)
diameter = self.diameter / self.sc
return QtCore.QRectF(-diameter / 2, -diameter / 2, diameter, diameter)
def drawMapObject(self, painter, object, color):
painter.save()
pen = QPen(Qt.black)
pen.setCosmetic(True)
cell = object.cell()
if (not cell.isEmpty()):
tile = cell.tile
imgSize = tile.size()
pos = self.pixelToScreenCoords_(object.position())
tileOffset = tile.offset()
CellRenderer(painter).render(cell, pos, object.size(), CellRenderer.BottomCenter)
if (self.testFlag(RenderFlag.ShowTileObjectOutlines)):
rect = QRectF(QPointF(pos.x() - imgSize.width() / 2 + tileOffset.x(),
pos.y() - imgSize.height() + tileOffset.y()),
QSizeF(imgSize))
pen.setStyle(Qt.SolidLine)
painter.setPen(pen)
painter.drawRect(rect)
pen.setStyle(Qt.DotLine)
pen.setColor(color)
painter.setPen(pen)
painter.drawRect(rect)
else:
lineWidth = self.objectLineWidth()
scale = self.painterScale()
x = 1
if lineWidth != 0:
x = lineWidth
shadowOffset = x / scale
brushColor = QColor(color)
brushColor.setAlpha(50)
brush = QBrush(brushColor)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
pen.setWidth(lineWidth)
colorPen = QPen(pen)
colorPen.setColor(color)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
# TODO: Do something sensible to make null-sized objects usable
x = object.shape()
if x==MapObject.Ellipse:
polygon = self.pixelRectToScreenPolygon(object.bounds())
tw = self.map().tileWidth()
th = self.map().tileHeight()
transformScale = QPointF(1, 1)
if (tw > th):
transformScale = QPointF(1, th/tw)
else:
transformScale = QPointF(tw/th, 1)
l1 = polygon.at(1) - polygon.at(0)
l2 = polygon.at(3) - polygon.at(0)
trans = QTransform()
trans.scale(transformScale.x(), transformScale.y())
trans.rotate(45)
iTrans, ok = trans.inverted()
l1x = iTrans.map(l1)
l2x = iTrans.map(l2)
ellipseSize = QSizeF(l1x.manhattanLength(), l2x.manhattanLength())
if (ellipseSize.width() > 0 and ellipseSize.height() > 0):
painter.save()
painter.setPen(pen)
painter.translate(polygon.at(0))
painter.scale(transformScale.x(), transformScale.y())
painter.rotate(45)
painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize))
painter.restore()
painter.setBrush(Qt.NoBrush)
painter.drawPolygon(polygon)
painter.setPen(colorPen)
painter.setBrush(Qt.NoBrush)
painter.translate(QPointF(0, -shadowOffset))
painter.drawPolygon(polygon)
painter.setBrush(brush)
if (ellipseSize.width() > 0 and ellipseSize.height() > 0):
painter.save()
painter.translate(polygon.at(0))
painter.scale(transformScale.x(), transformScale.y())
painter.rotate(45)
painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize))
painter.restore()
elif x==MapObject.Rectangle:
polygon = self.pixelRectToScreenPolygon(object.bounds())
painter.drawPolygon(polygon)
painter.setPen(colorPen)
painter.setBrush(brush)
polygon.translate(0, -shadowOffset)
painter.drawPolygon(polygon)
elif x==MapObject.Polygon:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
thickPen = QPen(pen)
thickColorPen = QPen(colorPen)
thickPen.setWidthF(thickPen.widthF() * 4)
thickColorPen.setWidthF(thickColorPen.widthF() * 4)
painter.drawPolygon(screenPolygon)
painter.setPen(thickPen)
painter.drawPoint(screenPolygon.first())
painter.setPen(colorPen)
painter.setBrush(brush)
screenPolygon.translate(0, -shadowOffset)
painter.drawPolygon(screenPolygon)
painter.setPen(thickColorPen)
painter.drawPoint(screenPolygon.first())
elif x==MapObject.Polyline:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
thickPen = QPen(pen)
thickColorPen = QPen(colorPen)
thickPen.setWidthF(thickPen.widthF() * 4)
thickColorPen.setWidthF(thickColorPen.widthF() * 4)
painter.drawPolyline(screenPolygon)
painter.setPen(thickPen)
painter.drawPoint(screenPolygon.first())
painter.setPen(colorPen)
screenPolygon.translate(0, -shadowOffset)
painter.drawPolyline(screenPolygon)
painter.setPen(thickColorPen)
painter.drawPoint(screenPolygon.first())
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
width = self.width()
height = self.height()
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.blue)
else:
painter.fillRect(event.rect(), self.plot.canvas_color)
y_min_scale = self.plot.y_scale.value_min
y_max_scale = self.plot.y_scale.value_max
factor_x = width / self.plot.x_diff
factor_y = (height - CURVE_HEIGHT_COMPENSATION) / max(y_max_scale - y_min_scale, EPSILON)
if self.plot.x_min != None and self.plot.x_max != None:
x_min = self.plot.x_min
x_max = self.plot.x_max
if self.plot.curve_start == 'left':
curve_x_offset = 0
else:
curve_x_offset = round((self.plot.x_diff - (x_max - x_min)) * factor_x)
transform = QTransform()
transform.translate(curve_x_offset, height - CURVE_Y_OFFSET_COMPENSATION)
transform.scale(factor_x, -factor_y)
transform.translate(-x_min, -y_min_scale)
self.plot.partial_update_width = math.ceil(transform.map(QLineF(0, 0, 1.5, 0)).length())
inverted_event_rect = transform.inverted()[0].mapRect(QRectF(event.rect()))
painter.save()
painter.setTransform(transform)
pen = QPen()
pen.setCosmetic(True)
pen.setWidth(0)
painter.setPen(pen)
if False and self.plot.curves_visible[0]:
# Currently unused support for bar graphs.
# If we need this later on we should add an option to the
# PlotWidget for it.
# I tested this for the Sound Pressure Level Bricklet and it works,
# but it didnt't look good.
curve_x = self.plot.curves_x[0]
curve_y = self.plot.curves_y[0]
t = time.time()
if self.max_points == None:
self.max_points = []
for y in curve_y:
self.max_points.append((t, y))
else:
for i in range(len(curve_y)):
if (curve_y[i] > self.max_points[i][1]) or ((t - self.max_points[i][0]) > 5):
self.max_points[i] = (t, curve_y[i])
for i in range(len(self.plot.curves_x[0])):
pen.setColor(self.plot.curve_configs[0].color)
painter.setPen(pen)
painter.drawLine(QPoint(curve_x[i], 0), QPoint(curve_x[i], curve_y[i]))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.drawLine(QPoint(curve_x[i], curve_y[i]), QPoint(curve_x[i], y_max_scale))
pen.setColor(Qt.darkGreen)
painter.setPen(pen)
painter.drawPoint(QPoint(curve_x[i], self.max_points[i][1]))
else:
for c in range(len(self.plot.curves_x)):
if not self.plot.curves_visible[c]:
continue
curve_x = self.plot.curves_x[c]
curve_y = self.plot.curves_y[c]
curve_jump = self.plot.curves_jump[c]
path = QPainterPath()
lineTo = path.lineTo
moveTo = path.moveTo
start = max(min(bisect.bisect_left(curve_x, inverted_event_rect.left()), len(curve_x) - 1) - 1, 0)
if start >= len(curve_x):
continue
moveTo(curve_x[start], curve_y[start])
for i in range(start + 1, len(curve_x)):
if curve_jump[i]:
curve_x_diff_half = (curve_x[i] - curve_x[i - 1]) / 2
lineTo(curve_x[i - 1] + curve_x_diff_half, curve_y[i - 1])
moveTo(curve_x[i] - curve_x_diff_half, curve_y[i])
lineTo(curve_x[i], curve_y[i])
pen.setColor(self.plot.curve_configs[c].color)
painter.setPen(pen)
painter.drawPath(path)
painter.restore()
def drawMapObject(self, painter, object, color):
painter.save()
bounds = object.bounds()
rect = QRectF(bounds)
painter.translate(rect.topLeft())
rect.moveTopLeft(QPointF(0, 0))
cell = object.cell()
if (not cell.isEmpty()):
CellRenderer(painter).render(cell, QPointF(), object.size(), CellRenderer.BottomLeft)
if (self.testFlag(RenderFlag.ShowTileObjectOutlines)):
tile = cell.tile
imgSize = tile.size()
tileOffset = tile.offset()
rect = QRectF(QPointF(tileOffset.x(), tileOffset.y() - imgSize.height()), QSizeF(imgSize))
pen = QPen(Qt.SolidLine)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(rect)
pen.setStyle(Qt.DotLine)
pen.setColor(color)
painter.setPen(pen)
painter.drawRect(rect)
else:
lineWidth = self.objectLineWidth()
scale = self.painterScale()
if lineWidth == 0:
x = 1
else:
x = lineWidth
shadowDist = x / scale
shadowOffset = QPointF(shadowDist * 0.5, shadowDist * 0.5)
linePen = QPen(color, lineWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
#linePen.setCosmetic(True)
shadowPen = QPen(linePen)
shadowPen.setColor(Qt.black)
brushColor = QColor(color)
fillBrush = QBrush(brushColor)
painter.setRenderHint(QPainter.Antialiasing)
# Trying to draw an ellipse with 0-width is causing a hang in
# CoreGraphics when drawing the path requested by the
# QCoreGraphicsPaintEngine. Draw them as rectangle instead.
shape = object.shape()
if (shape == MapObject.Ellipse and ((rect.width() == 0.0) ^ (rect.height() == 0.0))):
shape = MapObject.Rectangle
x = shape
if x==MapObject.Rectangle:
if (rect.isNull()):
rect = QRectF(QPointF(-10, -10), QSizeF(20, 20))
# Draw the shadow
painter.setPen(shadowPen)
painter.drawRect(rect.translated(shadowOffset))
painter.setPen(linePen)
painter.setBrush(fillBrush)
painter.drawRect(rect)
elif x==MapObject.Polyline:
screenPolygon = self.pixelToScreenCoords_(object.polygon())
thickShadowPen = QPen(shadowPen)
thickLinePen = QPen(linePen)
thickShadowPen.setWidthF(thickShadowPen.widthF() * 4)
thickLinePen.setWidthF(thickLinePen.widthF() * 4)
painter.setPen(shadowPen)
painter.drawPolyline(screenPolygon.translated(shadowOffset))
painter.setPen(thickShadowPen)
painter.drawPoint(screenPolygon.first() + shadowOffset)
painter.setPen(linePen)
painter.setBrush(fillBrush)
painter.drawPolyline(screenPolygon)
painter.setPen(thickLinePen)
painter.drawPoint(screenPolygon.first())
elif x==MapObject.Polygon:
screenPolygon = self.pixelToScreenCoords_(object.polygon())
thickShadowPen = QPen(shadowPen)
thickLinePen = QPen(linePen)
thickShadowPen.setWidthF(thickShadowPen.widthF() * 4)
thickLinePen.setWidthF(thickLinePen.widthF() * 4)
painter.setPen(shadowPen)
painter.drawPolygon(screenPolygon.translated(shadowOffset))
painter.setPen(thickShadowPen)
painter.drawPoint(screenPolygon.first() + shadowOffset)
painter.setPen(linePen)
painter.setBrush(fillBrush)
painter.drawPolygon(screenPolygon)
painter.setPen(thickLinePen)
painter.drawPoint(screenPolygon.first())
elif x==MapObject.Ellipse:
if (rect.isNull()):
rect = QRectF(QPointF(-10, -10), QSizeF(20, 20))
# Draw the shadow
painter.setPen(shadowPen)
painter.drawEllipse(rect.translated(shadowOffset))
painter.setPen(linePen)
painter.setBrush(fillBrush)
painter.drawEllipse(rect)
painter.restore()
def drawGrid(self, painter, exposed, gridColor):
rect = exposed.toAlignedRect()
if (rect.isNull()):
return
p = RenderParams(self.map())
# Determine the tile and pixel coordinates to start at
startTile = self.screenToTileCoords_(rect.topLeft()).toPoint()
startPos = self.tileToScreenCoords_(startTile).toPoint()
## Determine in which half of the tile the top-left corner of the area we
# need to draw is. If we're in the upper half, we need to start one row
# up due to those tiles being visible as well. How we go up one row
# depends on whether we're in the left or right half of the tile.
##
inUpperHalf = rect.y() - startPos.y() < p.sideOffsetY
inLeftHalf = rect.x() - startPos.x() < p.sideOffsetX
if (inUpperHalf):
startTile.setY(startTile.y() - 1)
if (inLeftHalf):
startTile.setX(startTile.x() - 1)
startTile.setX(max(0, startTile.x()))
startTile.setY(max(0, startTile.y()))
startPos = self.tileToScreenCoords_(startTile).toPoint()
oct = [
QPoint(0, p.tileHeight - p.sideOffsetY),
QPoint(0, p.sideOffsetY),
QPoint(p.sideOffsetX, 0),
QPoint(p.tileWidth - p.sideOffsetX, 0),
QPoint(p.tileWidth, p.sideOffsetY),
QPoint(p.tileWidth, p.tileHeight - p.sideOffsetY),
QPoint(p.tileWidth - p.sideOffsetX, p.tileHeight),
QPoint(p.sideOffsetX, p.tileHeight)]
lines = QVector()
#lines.reserve(8)
gridColor.setAlpha(128)
gridPen = QPen(gridColor)
gridPen.setCosmetic(True)
_x = QVector()
_x.append(2)
_x.append(2)
gridPen.setDashPattern(_x)
painter.setPen(gridPen)
if (p.staggerX):
# Odd row shifting is applied in the rendering loop, so un-apply it here
if (p.doStaggerX(startTile.x())):
startPos.setY(startPos.y() - p.rowHeight)
while(startPos.x() <= rect.right() and startTile.x() < self.map().width()):
rowTile = QPoint(startTile)
rowPos = QPoint(startPos)
if (p.doStaggerX(startTile.x())):
rowPos.setY(rowPos.y() + p.rowHeight)
while(rowPos.y() <= rect.bottom() and rowTile.y() < self.map().height()):
lines.append(QLineF(rowPos + oct[1], rowPos + oct[2]))
lines.append(QLineF(rowPos + oct[2], rowPos + oct[3]))
lines.append(QLineF(rowPos + oct[3], rowPos + oct[4]))
isStaggered = p.doStaggerX(startTile.x())
lastRow = rowTile.y() == self.map().height() - 1
lastColumn = rowTile.x() == self.map().width() - 1
bottomLeft = rowTile.x() == 0 or (lastRow and isStaggered)
bottomRight = lastColumn or (lastRow and isStaggered)
if (bottomRight):
lines.append(QLineF(rowPos + oct[5], rowPos + oct[6]))
if (lastRow):
lines.append(QLineF(rowPos + oct[6], rowPos + oct[7]))
if (bottomLeft):
lines.append(QLineF(rowPos + oct[7], rowPos + oct[0]))
painter.drawLines(lines)
lines.resize(0)
rowPos.setY(rowPos.y() + p.tileHeight + p.sideLengthY)
rowTile.setY(rowTile.y() + 1)
startPos.setX(startPos.x() + p.columnWidth)
startTile.setX(startTile.x() + 1)
else:
# Odd row shifting is applied in the rendering loop, so un-apply it here
if (p.doStaggerY(startTile.y())):
startPos.setX(startPos.x() - p.columnWidth)
while(startPos.y() <= rect.bottom() and startTile.y() < self.map().height()):
rowTile = QPoint(startTile)
rowPos = QPoint(startPos)
if (p.doStaggerY(startTile.y())):
rowPos.setX(rowPos.x() + p.columnWidth)
while(rowPos.x() <= rect.right() and rowTile.x() < self.map().width()):
lines.append(QLineF(rowPos + oct[0], rowPos + oct[1]))
lines.append(QLineF(rowPos + oct[1], rowPos + oct[2]))
lines.append(QLineF(rowPos + oct[3], rowPos + oct[4]))
isStaggered = p.doStaggerY(startTile.y())
lastRow = rowTile.y() == self.map().height() - 1
lastColumn = rowTile.x() == self.map().width() - 1
bottomLeft = lastRow or (rowTile.x() == 0 and not isStaggered)
bottomRight = lastRow or (lastColumn and isStaggered)
if (lastColumn):
lines.append(QLineF(rowPos + oct[4], rowPos + oct[5]))
if (bottomRight):
lines.append(QLineF(rowPos + oct[5], rowPos + oct[6]))
if (bottomLeft):
lines.append(QLineF(rowPos + oct[7], rowPos + oct[0]))
painter.drawLines(lines)
lines.resize(0)
rowPos.setX(rowPos.x() + p.tileWidth + p.sideLengthX)
rowTile.setX(rowTile.x() + 1)
startPos.setY(startPos.y() + p.rowHeight)
startTile.setY(startTile.y() + 1)
class StMoveGUI(QGraphicsLineItem, StMove):
def __init__(self, shape):
QGraphicsLineItem.__init__(self)
StMove.__init__(self, shape)
self.allwaysshow = False
self.path = QPainterPath()
self.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.pen = QPen(QColor(50, 100, 255), 1, QtCore.Qt.SolidLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
self.pen.setCosmetic(True)
self.make_papath()
def contains_point(self, point):
"""
StMove cannot be selected. Return maximal distance
"""
return float(0x7fffffff)
def make_papath(self):
"""
To be called if a Shape shall be printed to the canvas
@param canvas: The canvas to be printed in
@param pospro: The color of the shape
"""
start = self.geos.abs_el(0).get_start_end_points(True)
self.path = QPainterPath()
self.path.moveTo(start.x, -start.y)
drawHorLine = lambda caller, start, end: self.path.lineTo(end.x, -end.y)
drawVerLine = lambda caller, start: None # Not used in 2D mode
self.make_path(drawHorLine, drawVerLine)
def setSelected(self, flag=True):
"""
Override inherited function to turn off selection of Arrows.
@param flag: The flag to enable or disable Selection
"""
if self.allwaysshow:
pass
elif flag is True:
self.show()
else:
self.hide()
def setallwaysshow(self, flag=False):
"""
If the directions shall be allwaysshown the parameter will be set and
all paths will be shown.
@param flag: The flag to enable or disable Selection
"""
self.allwaysshow = flag
if flag is True:
self.show()
elif flag is True and self.isSelected():
self.show()
else:
self.hide()
def paint(self, painter, option, widget=None):
"""
Method will be triggered with each paint event. Possible to give options
@param painter: Reference to std. painter
@param option: Possible options here
@param widget: The widget which is painted on.
"""
painter.setPen(self.pen)
painter.drawPath(self.path)
def boundingRect(self):
"""
Required method for painting. Inherited by Painterpath
@return: Gives the Bounding Box
"""
return self.path.boundingRect()
class RouteText(QGraphicsItem):
def __init__(self, text='S', startp=Point(x=0.0, y=0.0),):
"""
Initialisation of the class.
"""
QGraphicsItem.__init__(self)
self.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.text = text
self.sc = 1.0
self.startp = QtCore.QPointF(startp.x, -startp.y)
pencolor = QColor(0, 200, 255)
self.brush = QColor(0, 100, 255)
self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine)
self.pen.setCosmetic(True)
self.path = QPainterPath()
self.path.addText(QtCore.QPointF(0, 0),
QFont("Arial", 10/self.sc),
self.text)
def contains_point(self, point):
"""
Text cannot be selected. Return maximal distance
"""
return float(0x7fffffff)
def setSelected(self, *args):
"""
Override inherited function - with possibility to be called with multiple arguments
"""
def paint(self, painter, option, widget=None):
"""
Method for painting the arrow.
"""
demat = painter.deviceTransform()
self.sc = demat.m11()
# painter.setClipRect(self.boundingRect())
painter.setPen(self.pen)
painter.setBrush(self.brush)
painter.scale(1/self.sc, 1/self.sc)
painter.translate(self.startp.x() * self.sc,
self.startp.y() * self.sc)
painter.drawPath(self.path)
def shape(self):
"""
Reimplemented function to select outline only.
@return: Returns the Outline only
"""
logger.debug("Hier sollte ich nicht sein")
return super(RouteText, self).shape()
def boundingRect(self):
"""
Required method for painting. Inherited by Painterpath
@return: Gives the Bounding Box
"""
rect = self.path.boundingRect().getRect()
newrect = QtCore.QRectF(self.startp.x()+rect[0]/self.sc,
self.startp.y()+rect[1]/self.sc,
rect[2]/self.sc,
rect[3]/self.sc)
return newrect
