def catch(exprs: Sequence[str]) -> bool: """Detection function for solution polygons.""" points, _ = self.solution_polygon( exprs[0], exprs[1:-1], exprs[-1], self.vpoints ) if len(points) < 3: points = convex_hull( [(x + self.sr, y + self.sr) for x, y in points] + [(x - self.sr, y - self.sr) for x, y in points], as_qpoint=True ) else: points = [QPointF(x, y) for x, y in points] polygon = QPolygonF(points) if rect: return polygon.intersects( QPolygonF(self.selector.to_rect(self.zoom))) else: return polygon.containsPoint( QPointF(self.selector.x, -self.selector.y) * self.zoom, Qt.WindingFill )
def qwtDrawPanel(painter, rect, pal, lw): if lw > 0.0: if rect.width() == 0.0: painter.setPen(pal.window().color()) painter.drawLine(rect.topLeft(), rect.bottomLeft()) return if rect.height() == 0.0: painter.setPen(pal.window().color()) painter.drawLine(rect.topLeft(), rect.topRight()) return lw = min([lw, rect.height() / 2.0 - 1.0]) lw = min([lw, rect.width() / 2.0 - 1.0]) outerRect = rect.adjusted(0, 0, 1, 1) innerRect = outerRect.adjusted(lw, lw, -lw, -lw) lines = [QPolygonF(), QPolygonF()] lines[0] += outerRect.bottomLeft() lines[0] += outerRect.topLeft() lines[0] += outerRect.topRight() lines[0] += innerRect.topRight() lines[0] += innerRect.topLeft() lines[0] += innerRect.bottomLeft() lines[1] += outerRect.topRight() lines[1] += outerRect.bottomRight() lines[1] += outerRect.bottomLeft() lines[1] += innerRect.bottomLeft() lines[1] += innerRect.bottomRight() lines[1] += innerRect.topRight() painter.setPen(Qt.NoPen) painter.setBrush(pal.light()) painter.drawPolygon(lines[0]) painter.setBrush(pal.dark()) painter.drawPolygon(lines[1]) painter.fillRect(rect.adjusted(lw, lw, -lw + 1, -lw + 1), pal.window())
def updatePosition(self, scene): # 1. Get pix coords for each lat/lon point pos0 = scene.posFromLonLat(self._lon0, self._lat0) pos1 = scene.posFromLonLat(self._lon1, self._lat1) pos2 = scene.posFromLonLat(self._lon2, self._lat2) pos3 = scene.posFromLonLat(self._lon3, self._lat3) self.prepareGeometryChange() # Set the image to 0, 0, then use a transform to # to translate, rotate and warp it to the map # tranfsorm and scale self.setPos(0, 0) t = QTransform() poly1 = QPolygonF() w = self.pixmap().width() h = self.pixmap().height() poly1.append(QPointF(0, 0)) poly1.append(QPointF(w, 0)) poly1.append(QPointF(w, h)) poly1.append(QPointF(0, h)) poly2 = QPolygonF() poly2.append(QPointF(pos0[0], pos0[1])) poly2.append(QPointF(pos1[0], pos1[1])) poly2.append(QPointF(pos2[0], pos2[1])) poly2.append(QPointF(pos3[0], pos3[1])) success = QTransform.quadToQuad(poly1, poly2, t) if not success: logging.error('Unable to register image') self.setTransform(t)
def transform(self, img=None): if not self._geometry or not self.displaymode == DisplayMode.remesh: return super(EwaldCorrected, self).transform( img) # Do pixel space transform when not calibrated from camsaxs import remesh_bbox img, q_x, q_z = remesh_bbox.remesh(np.squeeze(img), self._geometry, reflection=False, alphai=None) # Build Quads shape = img.shape a = shape[-2] - 1, 0 # bottom-left b = shape[-2] - 1, shape[-1] - 1 # bottom-right c = 0, shape[-1] - 1 # top-right d = 0, 0 # top-left quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip([a, b, c, d], [a, b, c, d]): # the zip does the flip :P quad1.append(QPointF(*p[::-1])) quad2.append(QPointF(q_x[q], q_z[q])) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) for item in self.view.items: if isinstance(item, ImageItem): item.setTransform(transform) self._transform = transform return img, self._transform
def setData(self, data): xvals = data.coords[data.dims[-1]] yvals = data.coords[data.dims[-2]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = data.shape a = [(0, shape[-1]), (shape[-2] - 1, shape[-1]), (shape[-2] - 1, 1), (0, 1)] # b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)] b = [(xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) # Bind coords from the xarray to the timeline axis # super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode) self.image_item.setImage(np.asarray(data), autoLevels=False) self.image_item.setTransform(transform) # Label the image axes self.view.setLabel('left', data.dims[-2]) self.view.setLabel('bottom', data.dims[-1])
def catch(exprs: Sequence[str]) -> bool: """Detection function for solution polygons.""" points, _ = self.solution_polygon(exprs[0], exprs[1:-1], exprs[-1], self.vpoints) polygon = QPolygonF(points) if rect: return polygon.intersects( QPolygonF(self.selector.to_rect(self.zoom))) else: return polygon.containsPoint( QPointF(self.selector.x, self.selector.y), Qt.WindingFill)
def enableRoiMode(self, enable): if enable == self._roiMode: return if enable: self._roiPolygon = QPolygonF() self._roiItem.setPolygon(self._roiPolygon) self._tempRoiPolygon = QPolygonF(self._roiPolygon) self._tempRoiPolygon.append(QPointF()) if not enable: self._roiItem.setPolygon(self._roiPolygon) self.roiChanged.emit(self._roiPolygon) self._roiMode = enable self.roiModeChanged.emit(enable)
def qwtDrawHexagonSymbols(painter, points, numPoints, symbol): painter.setBrush(symbol.brush()) painter.setPen(symbol.pen()) cos30 = np.cos(30 * np.pi / 180.0) dx = 0.5 * (symbol.size().width() - cos30) dy = 0.25 * symbol.size().height() for pos in points: x = pos.x() y = pos.y() x1 = x - dx y1 = y - 2 * dy x2 = x1 + 1 * dx x3 = x1 + 2 * dx y2 = y1 + 1 * dy y3 = y1 + 3 * dy y4 = y1 + 4 * dy hexa = [ QPointF(x2, y1), QPointF(x3, y2), QPointF(x3, y3), QPointF(x2, y4), QPointF(x1, y3), QPointF(x1, y2), ] painter.drawPolygon(QPolygonF(hexa))
def qwtDrawTriangleSymbols(painter, type, points, numPoint, symbol): size = symbol.size() pen = QPen(symbol.pen()) pen.setJoinStyle(Qt.MiterJoin) painter.setPen(pen) painter.setBrush(symbol.brush()) sw2 = 0.5 * size.width() sh2 = 0.5 * size.height() for pos in points: x = pos.x() y = pos.y() x1 = x - sw2 x2 = x1 + size.width() y1 = y - sh2 y2 = y1 + size.height() if type == QwtTriangle.Left: triangle = [QPointF(x2, y1), QPointF(x1, y), QPointF(x2, y2)] elif type == QwtTriangle.Right: triangle = [QPointF(x1, y1), QPointF(x2, y), QPointF(x1, y2)] elif type == QwtTriangle.Up: triangle = [QPointF(x1, y2), QPointF(x, y1), QPointF(x2, y2)] elif type == QwtTriangle.Down: triangle = [QPointF(x1, y1), QPointF(x, y2), QPointF(x2, y1)] else: raise TypeError("Unknown triangle type %s" % type) painter.drawPolygon(QPolygonF(triangle))
def array2d_to_qpolygonf(xdata, ydata): """ Utility function to convert two 1D-NumPy arrays representing curve data (X-axis, Y-axis data) into a single polyline (QtGui.PolygonF object). This feature is compatible with PyQt4, PyQt5 and PySide2 (requires QtPy). License/copyright: MIT License © Pierre Raybaut 2020. :param numpy.ndarray xdata: 1D-NumPy array (numpy.float64) :param numpy.ndarray ydata: 1D-NumPy array (numpy.float64) :return: Polyline :rtype: QtGui.QPolygonF """ dtype = np.float if not (xdata.size == ydata.size == xdata.shape[0] == ydata.shape[0] and xdata.dtype == ydata.dtype == dtype): raise ValueError( "Arguments must be 1D, float64 NumPy arrays with same size") size = xdata.size polyline = QPolygonF(size) if PYSIDE2: # PySide2 (obviously...) address = shiboken2.getCppPointer(polyline.data())[0] buffer = (ctypes.c_double * 2 * size).from_address(address) else: # PyQt4, PyQt5 buffer = polyline.data() buffer.setsize(2 * size * np.finfo(dtype).dtype.itemsize) memory = np.frombuffer(buffer, dtype) memory[:(size - 1) * 2 + 1:2] = xdata memory[1:(size - 1) * 2 + 2:2] = ydata return polyline
def paintEvent(self, event: QtGui.QPaintEvent): border_distance = 5 rect = self.rect() mid = rect.y() + rect.height() / 2 line_begin = QPointF(rect.height() + 10 + self.text_size.width(), mid) line_end = QPointF(rect.width() + rect.x() - 5, mid) triangle = QPolygonF() side_length = rect.height() - 2 * border_distance triangle_height = side_length * sqrt(3) / 2 start_point = QPointF(rect.x() + border_distance, rect.y() + border_distance) if self.isChecked(): triangle.append(start_point) triangle.append(start_point + QPointF(0, side_length)) triangle.append(start_point + QPointF(triangle_height, side_length / 2)) else: triangle.append(start_point) triangle.append(start_point + QPointF(side_length, 0)) triangle.append(start_point + QPointF(side_length / 2, triangle_height)) painter = QPainter(self) painter.setBrush(Qt.black) top = rect.height() - (self.text_size.height() / 2) painter.drawText(rect.height() + 5, top, self.info_text) painter.drawPolygon(triangle, Qt.WindingFill) painter.drawLine(QLineF(line_begin, line_end))
def draw_arrow(self, QPainter, point_1: QPointF, point_2: QPointF) -> 'QPolygonF': """ 绘制箭头。 :param QPainter: :param point_1: :param point_2: :return: """ line = QLineF(point_1, point_2) v = line.unitVector() v.setLength(20) # 改变单位向量的大小,实际就是改变箭头长度 v.translate(QPointF(int(line.dx() / 2), int(line.dy() / 2))) n = v.normalVector() # 法向量 n.setLength(n.length() * 0.2) # 这里设定箭头的宽度 n2 = n.normalVector().normalVector() # 两次法向量运算以后,就得到一个反向的法向量 p1 = v.p2() p2 = n.p2() p3 = n2.p2() if PYSIDE2: QPainter.drawPolygon([p1, p2, p3]) else: QPainter.drawPolygon(p1, p2, p3) return QPolygonF([p1, p2, p3, p1])
def _paint_diamond(self, painter): size = self._size X = [0, size / 2, 0, -size / 2, 0] Y = [size / 2, 0, -size / 2, 0, size / 2] points = [QPointF(x, y) for x, y in zip(X, Y)] polygon = QPolygonF(points) painter.drawPolygon(polygon, len(points))
def paintEvent(self, event: QPaintEvent): painter = QPainter(self) painter.drawImage(self.rect(), self.image) if self.show_frame: painter.save() pen = QPen() pen.setWidth(2) pen.setColor(QColor("black")) painter.setPen(pen) rect = QRect(1, 1, self.width() - 2, self.height() - 2) painter.drawRect(rect) pen.setColor(QColor("white")) painter.setPen(pen) rect = QRect(3, 3, self.width() - 6, self.height() - 6) painter.drawRect(rect) painter.restore() if self.show_arrow: painter.save() triangle = QPolygonF() dist = 4 point1 = QPoint(self.width() - self.triangle_width, 0) size = QSize(20, self.height() // 2) rect = QRect(point1, size) painter.fillRect(rect, QColor("white")) triangle.append(point1 + QPoint(dist, dist)) triangle.append(point1 + QPoint(size.width() - dist, dist)) triangle.append(point1 + QPoint(size.width() // 2, size.height() - dist)) painter.setBrush(Qt.black) painter.drawPolygon(triangle, Qt.WindingFill) painter.restore()
def paint(self, p, *args): ''' Overrides the default implementation so as to draw a vertical marker. ''' # draw the text super(LineIDMarker, self).paint(p, args) # Add marker. Geometry depends on the # text being vertical or horizontal. points = [] bounding_rect = self.boundingRect() if self._orientation == 'vertical': x = bounding_rect.x() y = bounding_rect.y() + bounding_rect.height() / 2. points.append(QPointF(x, y)) points.append(QPointF(x - 20, y)) else: x = bounding_rect.x() + bounding_rect.width() / 2. y = bounding_rect.y() + bounding_rect.height() * 2. points.append(QPointF(x, y)) points.append(QPointF(x, y - 20)) polygon = QPolygonF(points) pen = QPen(QColor(functions.mkColor(self._color))) p.setPen(pen) p.drawPolygon(polygon)
def paintEvent(self, event: QPaintEvent): painter = QPainter(self) painter.save() painter.setRenderHint(QPainter.Antialiasing) size = min(self.width(), self.height()) rect = QRect(0, 0, size, size) painter.setBrush(self.background_color) painter.setPen(self.background_color) painter.drawEllipse(rect) painter.setBrush(self.main_color) painter.setPen(self.main_color) factor = self.nominator / self.denominator radius = size / 2 if factor > 0.5: painter.drawChord(rect, 0, 16 * 360 * 0.5) painter.drawChord(rect, 16 * 180, 16 * 360 * (factor - 0.5)) zero_point = QPointF(0, radius) else: painter.drawChord(rect, 0, 16 * 360 * factor) zero_point = QPointF(size, radius) mid_point = QPointF(radius, radius) point = mid_point + QPointF( math.cos(math.pi * (factor * 2)) * radius, -math.sin(math.pi * (factor * 2)) * radius ) polygon = QPolygonF() polygon += mid_point polygon += zero_point polygon += point painter.drawPolygon(polygon) painter.restore()
def draw_solution(self, func: str, args: Sequence[str], target: str, pos: Sequence[VPoint]) -> None: """Draw the solution triangle.""" points, color = self.solution_polygon(func, args, target, pos) color.setAlpha(150) pen = QPen(color) pen.setWidth(self.joint_size) self.painter.setPen(pen) def draw_arrow(index: int, text: str) -> None: """Draw arrow.""" x0, y0 = points[index] x1, y1 = points[-1] self.draw_arrow(x0, -y0, x1, -y1, zoom=False, line=False, text=text) draw_arrow(0, args[1]) if func == 'PLLP': draw_arrow(1, args[2]) color.setAlpha(30) self.painter.setBrush(QBrush(color)) self.painter.drawPolygon(QPolygonF([QPointF(x, y) for x, y in points])) self.painter.setBrush(Qt.NoBrush)
def draw_icon(self, painter): path = QPainterPath(QPointF(0, 0.3)) path.lineTo(0, 0.9) path.lineTo(1, 0.3) path.lineTo(1, 0.9) path.closeSubpath() painter.drawPath(path) prev_brush = painter.brush() prev_pen = painter.pen() painter.setPen(Qt.NoPen) painter.setBrush(self._arrow_brush) arrow = QPolygonF([ QPointF(0.2, 0), QPointF(0.2, 0.20), QPointF(0.5, 0.40), QPointF(0.8, 0.20), QPointF(0.8, 0) ]) painter.drawPolygon(arrow) painter.setPen(prev_pen) painter.setBrush(prev_brush) painter.drawLine(QPointF(0.2, 0), QPointF(0.5, 0.20)) painter.drawLine(QPointF(0.2, 0.20), QPointF(0.5, 0.40)) painter.drawLine(QPointF(0.5, 0.20), QPointF(0.8, 0)) painter.drawLine(QPointF(0.5, 0.40), QPointF(0.8, 0.20)) painter.drawLine(QPointF(0.5, 0.6), QPointF(0.5, 0.0))
def draw_solution( self, func: str, args: Sequence[str], target: str, pos: Sequence[VPoint] ) -> None: """Draw the solution triangle.""" points, color = self.solution_polygon(func, args, target, pos) color.setAlpha(150) pen = QPen(color) pen.setWidth(self.joint_size) self.painter.setPen(pen) def draw_arrow(index: int, text: str) -> None: """Draw arrow.""" self.__draw_arrow( points[-1].x(), points[-1].y(), points[index].x(), points[index].y(), text=text ) draw_arrow(0, args[1]) if func == 'PLLP': draw_arrow(1, args[2]) color.setAlpha(30) self.painter.setBrush(QBrush(color)) self.painter.drawPolygon(QPolygonF(points)) self.painter.setBrush(Qt.NoBrush)
def draw_icon(self, painter): path = QPainterPath(QPointF(0, 0.3)) path.lineTo(0, 0.9) path.lineTo(1, 0.3) path.lineTo(1, 0.9) path.closeSubpath() painter.drawPath(path) painter.drawLine(QPointF(0.5, 0.6), QPointF(0.5, 0.15)) # Draw the arrow end-caps painter.setBrush(QBrush(QColor(0, 0, 0))) top_arrow_point = QPointF(0.65, 0.36) arrow = QPolygonF([ QPointF(-0.09, 0.0), QPointF(-0.005, 0.0), QPointF(-0.005, 0.8), QPointF(0.005, 0.8), QPointF(0.005, 0.0), QPointF(0.09, 0.0), QPointF(0.00, -0.25) ]) t = QTransform() t.rotate(35) top_arrow_r = t.map(arrow) arrow_l = top_arrow_r.translated(top_arrow_point) painter.drawPolygon(arrow_l) painter.setBrush(self._interlock_brush) painter.drawRect(QRectF(0.3, 0, 0.4, 0.15))
def setImage(self, img, **kwargs): if hasattr(img, 'coords'): if 'transform' not in kwargs: xvals = img.coords[img.dims[-2]] yvals = img.coords[img.dims[-1]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = img.shape a = [(0, shape[-2]), (shape[-1] - 1, shape[-2]), (shape[-1] - 1, 1), (0, 1)] b = [(ymin, xmin), (ymax, xmin), (ymax, xmax), (ymin, xmax)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) kwargs['transform'] = transform if 'xvals' not in kwargs: kwargs['xvals'] = np.asarray(img.coords[img.dims[0]]) # Set the timeline axis label from dims self.ui.roiPlot.setLabel('bottom', img.dims[0]) # Label the image axes self.axesItem.setLabel('left', img.dims[-2]) self.axesItem.setLabel('bottom', img.dims[-1]) # Add a bit more size self.ui.roiPlot.setMinimumSize(QSize(0, 70)) # Bind coords from the xarray to the timeline axis super(XArrayView, self).setImage(img, **kwargs)
def mousePressEvent(self, event): super().mousePressEvent(event) if not self._roiMode: return self._appendPointToRoi(event.scenePos(), self._roiPolygon, False) self._roiItem.setPolygon(self._roiPolygon) self._tempRoiPolygon = QPolygonF(self._roiPolygon) self._tempRoiPolygon.append(QPointF())
def initCoords(self): w = 10 h = 10 r = 6 coords = [(-r / 2, r), (r / 2, 0), (-r / 2, -r)] coords = [(x + w, y + h) for x, y in coords] coords = [QPointF(x, y) for x, y in coords] coords = QPolygonF(coords) self.coords = coords
def drawSteps(self, painter, xMap, yMap, canvasRect, from_, to): """ Draw steps :param QPainter painter: Painter :param qwt.scale_map.QwtScaleMap xMap: Maps x-values into pixel coordinates. :param qwt.scale_map.QwtScaleMap yMap: Maps y-values into pixel coordinates. :param QRectF canvasRect: Contents rectangle of the canvas :param int from_: Index of the first point to be painted :param int to: Index of the last point to be painted. If to < 0 the curve will be painted to its last point. .. seealso:: :py:meth:`draw()`, :py:meth:`drawSticks()`, :py:meth:`drawDots()`, :py:meth:`drawLines()` """ size = 2 * (to - from_) + 1 if QT_API == "pyside6": polygon = QPolygonF() polygon.resize(size) elif QT_API == "pyqt6": polygon = QPolygonF([QPointF(0, 0)] * size) else: polygon = QPolygonF(size) inverted = self.orientation() == Qt.Vertical if self.__data.attributes & self.Inverted: inverted = not inverted series = self.data() ip = 0 for i in range(from_, to + 1): sample = series.sample(i) xi = xMap.transform(sample.x()) yi = yMap.transform(sample.y()) if ip > 0: p0 = polygon[ip - 2] if inverted: polygon[ip - 1] = QPointF(p0.x(), yi) else: polygon[ip - 1] = QPointF(xi, p0.y()) polygon[ip] = QPointF(xi, yi) ip += 2 painter.drawPolyline(polygon) if self.__data.brush.style() != Qt.NoBrush: self.fillCurve(painter, xMap, yMap, canvasRect, polygon)
def draw_item(self, painter): """ Draws the Polygon after setting up the canvas with a call to ```PyDMDrawing.draw_item```. """ super(PyDMDrawingPolygon, self).draw_item(painter) maxsize = not self.is_square() x, y, w, h = self.get_bounds(maxsize=not self.is_square()) poly = self._calculate_drawing_points(x, y, w, h) painter.drawPolygon(QPolygonF(poly))
def draw_item(self, painter): """ Draws the triangle after setting up the canvas with a call to ```PyDMDrawing.draw_item```. """ super(PyDMDrawingTriangle, self).draw_item(painter) x, y, w, h = self.get_bounds(maxsize=True) points = self._calculate_drawing_points(x, y, w, h) painter.drawPolygon(QPolygonF(points))
def transform(self, img=None): # Build Quads shape = img.shape a = [(0, shape[-2] - 1), (shape[-1] - 1, shape[-2] - 1), (shape[-1] - 1, 0), (0, 0)] b = [(0, 1), (shape[-1] - 1, 1), (shape[-1] - 1, shape[-2]), (0, shape[-2])] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) for item in self.view.items: if isinstance(item, ImageItem): item.setTransform(transform) self._transform = transform return img, transform
def setData(self, data): # Constrain squareness when units match is_square = data.dims[-2].split('(')[-1] == data.dims[-1].split( '(')[-1] self.view.vb.setAspectLocked(is_square) xvals = data.coords[data.dims[-1]] yvals = data.coords[data.dims[-2]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = data.shape a = [(0, shape[-2]), (shape[-1], shape[-2]), (shape[-1], 0), (0, 0)] # b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)] if self.slice_direction in ['horizontal', 'depth']: b = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)] elif self.slice_direction == 'vertical': b = [(xmax, ymax), (xmin, ymax), (xmin, ymin), (xmax, ymin)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) # Bind coords from the xarray to the timeline axis # super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode) self.image_item.setImage(np.asarray(data), autoLevels=False) self.image_item.setTransform(transform) # Label the image axes self.view.setLabel('left', data.dims[-2]) self.view.setLabel('bottom', data.dims[-1])
def array2d_to_qpolygonf(xdata, ydata): """ Utility function to convert two 1D-NumPy arrays representing curve data (X-axis, Y-axis data) into a single polyline (QtGui.PolygonF object). This feature is compatible with PyQt4, PyQt5 and PySide2 (requires QtPy). License/copyright: MIT License © Pierre Raybaut 2020-2021. :param numpy.ndarray xdata: 1D-NumPy array :param numpy.ndarray ydata: 1D-NumPy array :return: Polyline :rtype: QtGui.QPolygonF """ if not (xdata.size == ydata.size == xdata.shape[0] == ydata.shape[0]): raise ValueError("Arguments must be 1D NumPy arrays with same size") size = xdata.size if QT_API.startswith("pyside"): # PySide (obviously...) if QT_API == "pyside2": polyline = QPolygonF(size) else: polyline = QPolygonF() polyline.resize(size) address = shiboken.getCppPointer(polyline.data())[0] buffer = (ctypes.c_double * 2 * size).from_address(address) else: # PyQt4, PyQt5 if QT_API == "pyqt6": polyline = QPolygonF([QPointF(0, 0)] * size) else: polyline = QPolygonF(size) buffer = polyline.data() buffer.setsize( 16 * size) # 16 bytes per point: 8 bytes per X,Y value (float64) memory = np.frombuffer(buffer, np.float64) memory[:(size - 1) * 2 + 1:2] = np.array(xdata, dtype=np.float64, copy=False) memory[1:(size - 1) * 2 + 2:2] = np.array(ydata, dtype=np.float64, copy=False) return polyline
def catch(link: VLink) -> bool: """Detection function for links. + Is polygon: Using Qt polygon geometry. + If just a line: Create a range for mouse detection. """ points = self.__points_pos(link) if len(points) > 2: polygon = QPolygonF(convex_hull(points, as_qpoint=True)) else: polygon = QPolygonF(convex_hull( [(x + self.sr, y + self.sr) for x, y in points] + [(x - self.sr, y - self.sr) for x, y in points], as_qpoint=True )) if rect: return polygon.intersects(QPolygonF(self.selector.to_rect(self.zoom))) else: return polygon.containsPoint( QPointF(self.selector.x, -self.selector.y) * self.zoom, Qt.WindingFill )