def boundingRect(self):
# For now, do not take the highlight pen into account
#pw = self.pen().widthF()/2
pw = 0
children = self.childrenBoundingRect()
m = self.margin
return QRectF(
children.topLeft() - QPointF(pw + m, pw + m),
QSizeF(children.width() + pw + m + m,
children.height() + pw + m + m))
def beginDrawing(self, pos, sliceRect):
'''
pos -- QPointF-like
'''
self.sliceRect = sliceRect
self.scene.clear()
self.bb = QRect()
self.pos = QPointF(pos.x(), pos.y())
self._hasMoved = False
def _addAlgorithm(self, alg, pos=None):
dlg = alg.getCustomModelerParametersDialog(self.alg)
if not dlg:
dlg = ModelerParametersDialog(alg, self.alg)
dlg.exec_()
if dlg.alg is not None:
if pos is None:
dlg.alg.pos = self.getPositionForAlgorithmItem()
else:
dlg.alg.pos = pos
if isinstance(dlg.alg.pos, QPoint):
dlg.alg.pos = QPointF(pos)
from processing.modeler.ModelerGraphicItem import ModelerGraphicItem
for i, out in enumerate(dlg.alg.outputs):
dlg.alg.outputs[out].pos = dlg.alg.pos + QPointF(ModelerGraphicItem.BOX_WIDTH, (i + 1.5)
* ModelerGraphicItem.BOX_HEIGHT)
self.alg.addAlgorithm(dlg.alg)
self.repaintModel()
self.hasChanged = True
def __init__(self, sourceNode, destNode, state=1, text=""):
super(Edge, self).__init__()
self.arrowSize = 15.0
self.sourcePoint = QPointF()
self.destPoint = QPointF()
self.setAcceptedMouseButtons(Qt.NoButton)
self.source = sourceNode
self.dest = destNode
self.source.addEdge(self)
self.dest.addEdge(self)
self.adjust()
self.state = state
self.text = text
line = QLineF(sourceNode.pos(), destNode.pos())
self.weight = line.length()
def onMouseMove_draw(self, imageview, event):
self._navIntr.onMouseMove_default(imageview, event)
o = imageview.scene().data2scene.map(
QPointF(imageview.oldX, imageview.oldY))
n = imageview.scene().data2scene.map(QPointF(imageview.x, imageview.y))
# Draw temporary line for the brush stroke so the user gets feedback before the data is really updated.
pen = QPen(QBrush(self._brushingCtrl._brushingModel.drawColor),
self._brushingCtrl._brushingModel.brushSize, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin)
line = QGraphicsLineItem(o.x(), o.y(), n.x(), n.y())
line.setPen(pen)
imageview.scene().addItem(line)
line.setParentItem(imageview.scene().dataRectItem)
self._lineItems.append(line)
self._brushingCtrl._brushingModel.moveTo(imageview.mousePos)
def updateCursorPosition(self, imageview, event):
"""Update the position model's cursor position according to the given event position."""
imageview.mousePos = mousePos = imageview.mapMouseCoordinates2Data(
event.pos())
imageview.oldX, imageview.oldY = imageview.x, imageview.y
dataX = imageview.x = mousePos.x()
dataY = imageview.y = mousePos.y()
self._navCtrl.positionDataCursor(QPointF(dataX, dataY),
self._navCtrl._views.index(imageview))
def drawBackground(self, painter, rect):
painter.fillRect(rect, QBrush(QColor(0, 0, 0)))
if self.background_image:
#bm = self.back_matrix
#log_debug("m = [%g %g ; %g %g ]" % (bm.m11(), bm.m12(), bm.m21(), bm.m22()))
painter.setWorldTransform(self.back_matrix, True)
#real_rect = self.invert_back_matrix.mapRect(rect)
#rect = self.back_matrix.mapRect(real_rect)
#painter.drawImage(rect,self.background_image, real_rect)
painter.drawImage(QPointF(0, 0), self.background_image)
def foldInput(self, folded):
self.element.paramsFolded = folded
self.prepareGeometryChange()
if self.element.algorithm.outputs:
pt = self.getLinkPointForOutput(-1)
pt = QPointF(0, pt.y())
self.outButton.position = pt
for arrow in self.arrows:
arrow.updatePath()
self.update()
def updateAlgorithm(self, alg):
alg.pos = self.algs[alg.name].pos
self.algs[alg.name] = alg
from processing.modeler.ModelerGraphicItem import ModelerGraphicItem
for i, out in enumerate(alg.outputs):
alg.outputs[out].pos = (
alg.outputs[out].pos or
alg.pos + QPointF(ModelerGraphicItem.BOX_WIDTH,
(i + 1.5) * ModelerGraphicItem.BOX_HEIGHT))
def getPositionForParameterItem(self):
MARGIN = 20
BOX_WIDTH = 200
BOX_HEIGHT = 80
if self.alg.inputs:
maxX = max([i.pos.x() for i in self.alg.inputs.values()])
newX = min(MARGIN + BOX_WIDTH + maxX, self.CANVAS_SIZE - BOX_WIDTH)
else:
newX = MARGIN + BOX_WIDTH / 2
return QPointF(newX, MARGIN + BOX_HEIGHT / 2)
def create_polygon_pie(self, outer_radius, inner_raduis, start, lenght):
polygon_pie = QPolygonF()
# start = self.scale_angle_start_value
# start = 0
# lenght = self.scale_angle_size
# lenght = 180
# inner_raduis = self.width()/4
# print(start)
n = 360 # angle steps size for full circle
# changing n value will causes drawing issues
w = 360 / n # angle per step
# create outer circle line from "start"-angle to "start + lenght"-angle
x = 0
y = 0
# todo enable/disable bar graf here
if not self.enable_barGraph:
# float_value = ((lenght / (self.value_max - self.value_min)) * (self.value - self.value_min))
lenght = int(
round((lenght / (self.value_max - self.value_min)) *
(self.value - self.value_min)))
# print("f: %s, l: %s" %(float_value, lenght))
pass
# mymax = 0
for i in range(lenght + 1): # add the points of polygon
t = w * i + start - self.angle_offset
x = outer_radius * math.cos(math.radians(t))
y = outer_radius * math.sin(math.radians(t))
polygon_pie.append(QPointF(x, y))
# create inner circle line from "start + lenght"-angle to "start"-angle
for i in range(lenght + 1): # add the points of polygon
# print("2 " + str(i))
t = w * (lenght - i) + start - self.angle_offset
x = inner_raduis * math.cos(math.radians(t))
y = inner_raduis * math.sin(math.radians(t))
polygon_pie.append(QPointF(x, y))
# close outer line
polygon_pie.append(QPointF(x, y))
return polygon_pie
def read_patternRepeats_API_1_2(stream, numRepeats):
""" Read all patternRepeats from our output stream
NOTE: This is a legacy reader for pattern repeats
written with API versions 1 and 2.
"""
patternRepeats = []
for count in range(numRepeats):
# read all lines
lines = []
numPoints = stream.readInt32()
for pointCount in range(0, numPoints, 2):
point1 = QPointF()
stream >> point1
point2 = QPointF()
stream >> point2
lines.append(QLineF(point1, point2))
# read width and color
position = QPointF()
stream >> position
legendID = stream.readUInt16()
width = stream.readInt16()
color = QColor()
stream >> color
newItem = {
"lines": lines,
"position": position,
"width": width,
"color": color,
"legendID": legendID
}
patternRepeats.append(newItem)
return patternRepeats
def paintArc(self, painter, option, widget):
assert self.source is self.dest
node = self.source
def best_angle():
"""...is the one furthest away from all other angles"""
angles = [QLineF(node.pos(), other.pos()).angle()
for other in chain((edge.source for edge in node.edges
if edge.dest == node and edge.source != node),
(edge.dest for edge in node.edges
if edge.dest != node and edge.source == node))]
angles.sort()
if not angles: # If this self-constraint is the only edge
return 225
deltas = np.array(angles[1:] + [360 + angles[0]]) - angles
return (angles[deltas.argmax()] + deltas.max()/2) % 360
angle = best_angle()
inf = QPointF(-1e20, -1e20) # Doesn't work with real -np.inf!
line0 = QLineF(node.pos(), inf)
line1 = QLineF(node.pos(), inf)
line2 = QLineF(node.pos(), inf)
line0.setAngle(angle)
line1.setAngle(angle - 13)
line2.setAngle(angle + 13)
p0 = shape_line_intersection(node.shape(), node.pos(), line0)
p1 = shape_line_intersection(node.shape(), node.pos(), line1)
p2 = shape_line_intersection(node.shape(), node.pos(), line2)
path = QtGui.QPainterPath()
path.moveTo(p1)
line = QLineF(node.pos(), p0)
line.setLength(3*line.length())
pt = line.p2()
path.quadTo(pt, p2)
line = QLineF(node.pos(), pt)
self.setLine(line) # This invalidates DeviceCoordinateCache
painter.drawPath(path)
# Draw arrow head
line = QLineF(pt, p2)
self.arrowHead.clear()
for point in self._arrowhead_points(line):
self.arrowHead.append(point)
painter.setBrush(self.pen().color())
painter.drawPolygon(self.arrowHead)
# Update label position
self.label.setPos(path.pointAtPercent(.5))
if 90 < angle < 270: # Right-align the label
pos = self.label.pos()
x, y = pos.x(), pos.y()
self.label.setPos(x - self.label.boundingRect().width(), y)
self.squares.placeBelow(self.label)
def paint(self, painter, option, widget=None):
pt = QPointF(-self.WIDTH / 2, -self.HEIGHT / 2) + self.position
rect = QRectF(pt.x(), pt.y(), self.WIDTH, self.HEIGHT)
if self.isIn:
painter.setPen(QPen(Qt.transparent, 1))
painter.setBrush(QBrush(Qt.lightGray, Qt.SolidPattern))
else:
painter.setPen(QPen(Qt.transparent, 1))
painter.setBrush(QBrush(Qt.transparent, Qt.SolidPattern))
painter.drawRect(rect)
painter.drawPixmap(pt.x(), pt.y(), self.pixmap)
def __init__(self,
m={
'center': QPointF(0.0, 0.0),
'radius': 0.5,
'start': 0.0,
'span': 90.0
}):
r = m.get('radius', None)
if r is not None and r <= 0.0:
raise ArcException("radius must be > 0.0")
self.m = copy(m)
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner=(0, 0)):
if not self.skel_file or not isinstance(self.trajectories_data,
pd.DataFrame):
return
c_ratio_y = worm_qimg.width() / worm_img.shape[1]
c_ratio_x = worm_qimg.height() / worm_img.shape[0]
skel_id = int(row_data['skeleton_id'])
qPlg = {}
with tables.File(self.skel_file, 'r') as ske_file_id:
for tt in ['skeleton', 'contour_side1', 'contour_side2']:
dat = ske_file_id.get_node('/' + tt)[skel_id]
dat[:, 0] = (dat[:, 0] - roi_corner[0]) * c_ratio_x
dat[:, 1] = (dat[:, 1] - roi_corner[1]) * c_ratio_y
qPlg[tt] = QPolygonF()
for p in dat:
qPlg[tt].append(QPointF(*p))
if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0:
self.skel_colors = {
'skeleton': (102, 0, 0),
'contour_side1': (102, 0, 0),
'contour_side2': (102, 0, 0)
}
else:
self.skel_colors = {
'skeleton': (27, 158, 119),
'contour_side1': (217, 95, 2),
'contour_side2': (231, 41, 138)
}
pen = QPen()
pen.setWidth(2)
painter = QPainter()
painter.begin(worm_qimg)
for tt, color in self.skel_colors.items():
pen.setColor(QColor(*color))
painter.setPen(pen)
painter.drawPolyline(qPlg[tt])
pen.setColor(Qt.black)
painter.setBrush(Qt.white)
painter.setPen(pen)
radius = 3
painter.drawEllipse(qPlg['skeleton'][0], radius, radius)
painter.end()
def paint(self, painter, options, widget):
pw = self.pen().widthF() / 2
children = self.childrenBoundingRect()
m = self.margin
painter.setPen(self.pen())
painter.setBrush(self.brush())
painter.drawRect(
QRectF(
children.topLeft() - QPointF(pw + m, pw + m),
QSizeF(children.width() + pw + m + m,
children.height() + pw + m + m)))
def makeStarShaped(pts, pts2coords):
if len(pts) > 2:
coords = [pts2coords[pt_id] for pt_id in pts]
center = sum(coords, QPointF())/len(coords)
ref = coords[0] - center
angles = [angle(ref, p-center) for p in coords]
to_sort = list(range(len(angles)))
to_sort.sort(key=lambda k: angles[k])
return [pts[i] for i in to_sort]
else:
return pts
def __init__(self, parent=None):
super(Particle, self).__init__(parent)
self.effect = QGraphicsBlurEffect()
self.blur_radius = random.uniform(0.8, 1.6)
self.effect.setBlurRadius(self.blur_radius)
self.setGraphicsEffect(self.effect)
self.height = random.uniform(1, 6)
self.width = random.uniform(1, 6)
self.depth = 1
self.setZValue(self.depth)
self.newPos = QPointF()
self.animation_timer = QTimer()
self.animation_timer.setInterval(1000 / 25)
self.animation_timer.timeout.connect(self.advance)
self.animation_timer.start()
self.speed = 1
self.next_pos = QPointF(0, 0)
self.animated = True
self.max_speed = 3.0
self.color = QColor(0, 0, 0, 50)
def __init__(self, parent=None, text=""):
super(QGraphicsPathItem, self).__init__(parent)
self.setAcceptHoverEvents(True)
self.setPen(QPen(Qt.NoPen))
self.text = QGraphicsTextItem(self)
layout = self.text.document().documentLayout()
layout.documentSizeChanged.connect(self._onLayoutChanged)
self._text = ""
self._anchor = QPointF()
def panSlicingViews(self, point3d, axes):
"""
For each of the given axes, pan the slicing view to the ordinate-abscissa point in point3d,
but DON'T change the slicing plane.
"""
for axis, view in enumerate(self._views):
if axis in axes:
pos2d = posView2D(point3d, axis)
dataPoint = QPointF( *pos2d )
scenePoint = view.scene().data2scene.map(dataPoint)
view.centerOn( scenePoint )
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 = 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 rebuildDataBrushIfNeeded(self):
if not self.m_rebuildBrush or not self.m_gradientData:
return
self.m_rebuildBrush = False
p = self.palette()
dataBrush = QConicalGradient(QPointF(0.5, 0.5), self.m_nullPosition)
dataBrush.setCoordinateMode(QGradient.StretchToDeviceMode)
for i in range(0, len(self.m_gradientData)):
dataBrush.setColorAt(1 - self.m_gradientData[i][0],
self.m_gradientData[i][1])
p.setBrush(QPalette.Highlight, dataBrush)
self.setPalette(p)
def update(self):
QGraphicsObject.prepareGeometryChange(self)
self.__headPoint = self.mapFromItem(
self.__head[ENode.kGuiAttributeParent],
self.__head[ENode.kGuiAttributePlug])
self.__tailPoint = self.mapFromItem(
self.__tail[ENode.kGuiAttributeParent],
self.__tail[ENode.kGuiAttributePlug])
self.__headOffsetLine = QLineF(
self.__headPoint,
QPointF(self.__headPoint.x() + 15, self.__headPoint.y()))
self.__tailOffsetLine = QLineF(
self.__tailPoint,
QPointF(self.__tailPoint.x() - 15, self.__tailPoint.y()))
line = QLineF(self.__headPoint, self.__tailPoint)
self.__line = line
def setRect(self, fm=None):
if fm is None:
font = self.font()
if font is None:
return
fm = QFontMetrics(font)
lineHeight = fm.height()
height = lineHeight * self._dataLen() * 1.1
width = max(fm.width(data) for data in self._iterData()) + 10
if height != self._rect.height() or width != self._rect.width():
self.prepareGeometryChange()
self._rect.setBottomRight(QPointF(width, height))
def calculate_polygon_points(self):
# QPolygonF nesnesi oluşturup tüm köşe noktalarının
# x ve y değerlerini hesaplıyoruz. Sonrasında x,y
# değerleriyle QPointF nesnesi oluşturup QPolygon'a
# bu noktaları ekliyoruz.
p = QPolygonF()
angle = self.calculate_angle()
for i in range(self.edge_count):
x = cos(angle * i) * self.radius
y = sin(angle * i) * self.radius
p.append(QPointF(x, y))
return p
def centroid_qt(polygon):
from PyQt4.QtCore import QPointF
"""Determine the centroid of a QPolygon"""
x = 0.
y = 0.
n = polygon.count()
for i in range(n):
x += polygon.at(i).x()
y += polygon.at(i).y()
x /= n
y /= n
return QPointF(x, y)
def load_window_geometry(self):
"""Load from QSettings the window size of Ninja IDE"""
qsettings = QSettings(resources.SETTINGS_PATH, QSettings.IniFormat)
if qsettings.value("window/maximized", True, type=bool):
self.setWindowState(Qt.WindowMaximized)
else:
self.resize(qsettings.value(
"window/size",
QSizeF(800, 600).toSize(), type='QSize'))
self.move(qsettings.value(
"window/pos",
QPointF(100, 100).toPoint(), type='QPoint'))
def load_window_geometry(self):
"""Load from QSettings the window size of de Ninja IDE"""
qsettings = QSettings()
if qsettings.value("window/maximized", 'true') == 'true':
self.setWindowState(Qt.WindowMaximized)
else:
print dir(QSizeF)
self.resize(
qsettings.value("window/size", QSizeF(800, 600)).toSize())
self.move(
qsettings.value("window/pos", QPointF(100, 100)).toPoint())
def test_distance_to_caliper(self):
x_from = 0
x_to = 10
y1 = 0
y2 = 20
pos = QPointF(7, 15)
d_center, d_y2, d_x2, d_y1, d_x1 = compute_dist_caliper(x_from, x_to, y1, y2, pos)
self.assertAlmostEqual(d_center, 5.385, places=2)
self.assertEqual(d_x1, 7)
self.assertEqual(d_x2, 3)
self.assertEqual(d_y1, 15)
self.assertEqual(d_y2, 5)
