def show_image(self,
pattern,
use_grayscale=False,
alpha=0,
beta=0,
gamma=0):
# if not self.connected:
# self.print_text_signal.emit("Impossible to show image: projector is not connected!")
# return
loaded_image = QImage(pattern).convertToFormat(
QImage.Format.Format_RGB32)
values = loaded_image.bits()
pixel_values = np.array(values).reshape(loaded_image.height(),
loaded_image.width(), 4)
if use_grayscale:
thickness = DLPColorCalibrator.my_log_function(
1, alpha, beta, gamma)
tmp, corrected_values = DLPColorCalibrator.my_color_correction(
pixel_values, alpha, beta, gamma, thickness)
corrected_values_tr = corrected_values.copy()
corrected_image = QImage(corrected_values_tr,
corrected_values_tr.shape[1],
corrected_values_tr.shape[0],
QImage.Format_RGB32)
self.img = QPixmap(corrected_image)
else:
self.img = QPixmap(loaded_image)
if self.horizontal_mirror:
self.img = self.img.transformed(QTransform().scale(-1, 1))
if self.vertical_mirror:
self.img = self.img.transformed(QTransform().scale(1, -1))
self.display_image_signal.emit(self.img)
self.setPixmap(self.img)
def testMap(self):
transform = QTransform()
values = (10.0, 20.0)
tx, ty = transform.map(*values)
self.assertTrue(isinstance(tx, float))
self.assertTrue(isinstance(ty, float))
self.assertEqual((tx, ty), values)
def anim_value_changed(self, value):
value = int(value)
t = QTransform()
t.rotate(value, Qt.YAxis)
self.setPixmap(self.dog_pixmap.transformed(t))
if value == 180:
self.anim1.start()
def mouseMoveEvent(self, event):
"""
Mouse move event handler
@param event:
@type event:
"""
modifiers = QApplication.keyboardModifiers()
# mouse coordinates, relative to parent widget
pos = self.mapToParent(event.pos())
img = self.tool.layer.parentImage
r = self.tool.resizingCoeff
self.tool.targetQuad_old = self.tool.getTargetQuad(
) # TODO added 15/05/18 validate
self.posRelImg = (pos - QPoint(img.xOffset, img.yOffset)) / r
if modifiers == Qt.ControlModifier | Qt.AltModifier:
if self.tool.isModified():
dlgWarn("A transformation is in progress", "Reset first")
return
# update the new starting position
self.posRelImg_ori = self.posRelImg # (pos - QPoint(img.xOffset, img.yOffset)) / r
self.posRelImg_frozen = self.posRelImg
self.tool.moveRotatingTool()
self.tool.parent().repaint()
return
curimg = self.tool.layer.getCurrentImage()
w, h = curimg.width(), curimg.height()
s = w / self.tool.img.width()
form = self.tool.getForm()
if form.options['Free']:
pass
elif form.options['Rotation']:
center = self.tool.getTargetQuad().boundingRect().center()
v = QPointF(self.posRelImg.x() - center.x(),
self.posRelImg.y() - center.y())
v0 = QPointF(self.posRelImg_frozen.x() - center.x(),
self.posRelImg_frozen.y() - center.y())
theta = (np.arctan2(v.y(), v.x()) -
np.arctan2(v0.y(), v0.x())) * 180.0 / np.pi
T = QTransform() # self.tool.geoTrans_ori)
T.translate(center.x(), center.y()).rotate(theta).translate(
-center.x(), -center.y())
q = T.map(self.tool.getFrozenQuad())
for i, role in enumerate(
['topLeft', 'topRight', 'bottomRight', 'bottomLeft']):
self.tool.btnDict[role].posRelImg = q.at(i)
elif form.options['Translation']:
# translation vector (coordinates are relative to the full size image)
p = QPointF(self.posRelImg) - QPointF(self.posRelImg_frozen)
T = QTransform()
T.translate(p.x(), p.y())
q = T.map(self.tool.getFrozenQuad())
for i, role in enumerate(
['topLeft', 'topRight', 'bottomRight', 'bottomLeft']):
self.tool.btnDict[role].posRelImg = q.at(i)
self.tool.moveRotatingTool()
self.tool.modified = True
self.tool.layer.applyToStack()
self.parent().repaint()
def testItemAt(self):
#QGraphicsScene.itemAt()
self.assertEqual(self.scene.itemAt(50, 50, QTransform()), self.topleft)
self.assertEqual(self.scene.itemAt(150, 50, QTransform()),
self.topright)
self.assertEqual(self.scene.itemAt(50, 150, QTransform()),
self.bottomleft)
self.assertEqual(self.scene.itemAt(150, 150, QTransform()),
self.bottomright)
def paint(self, painter: QPainter, model: BaseModel = None):
_pix_map = self._pixel_map.scaledToHeight(model.radius * 1.025,
mode=Qt.SmoothTransformation)
_seed = hash(model.name)
_transf = QTransform()
_transf.rotate(_seed % 360)
_pix_map = _pix_map.transformed(_transf, mode=Qt.SmoothTransformation)
_x, _y = self.transform(model.x - _pix_map.width() / 2.0,
model.y + _pix_map.height() / 2.0)
painter.drawPixmap(round(_x), round(_y), _pix_map)
def keyPressEvent(self, event):
"""Handles deleting and rotating the selected
item when dedicated keys are pressed.
Args:
event (QKeyEvent): Key event
"""
if event.key() == Qt.Key_Delete and self.isSelected():
self._project_item._project.remove_item(self.name())
event.accept()
elif event.key() == Qt.Key_R and self.isSelected():
# TODO:
# 1. Change name item text direction when rotating
# 2. Save rotation into project file
rect = self.mapToScene(self.boundingRect()).boundingRect()
center = rect.center()
t = QTransform()
t.translate(center.x(), center.y())
t.rotate(90)
t.translate(-center.x(), -center.y())
self.setPos(t.map(self.pos()))
self.setRotation(self.rotation() + 90)
links = set(lnk for conn in self.connectors.values()
for lnk in conn.links)
for link in links:
link.update_geometry()
event.accept()
else:
super().keyPressEvent(event)
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.horizontalSliderDikey.valueChanged.connect(self.dikey_egim)
labelCizgi0 = QLabel(self.ui.egimAnaFrame)
labelCizgi0.move(500, 348)
labelCizgi0.resize(25, 12)
labelCizgi0.setScaledContents(True)
labelCizgi0.setStyleSheet("QLabel{ background-color: none;}")
pixmapCizgi0 = QPixmap("aa.png")
xformCizgi0 = QTransform()
xformCizgi0.rotate(105)
xformed_pixmapCizgi0 = pixmapCizgi0.transformed(
xformCizgi0, Qt.SmoothTransformation)
labelCizgi0.setPixmap(xformed_pixmapCizgi0)
labelCizgi5 = QLabel(self.ui.egimAnaFrame)
labelCizgi5.move(480, 400)
labelCizgi5.resize(25, 18)
labelCizgi5.setScaledContents(True)
labelCizgi5.setStyleSheet("QLabel{ background-color: none;}")
pixmapCizgi5 = QPixmap("aa.png")
xformCizgi5 = QTransform()
xformCizgi5.rotate(130)
xformed_pixmapCizgi5 = pixmapCizgi5.transformed(xformCizgi5)
labelCizgi5.setPixmap(xformed_pixmapCizgi5)
self.show()
def mvp(self):
view_center = self.rect().center()
mvp = QTransform()
mvp.translate(view_center.x(), view_center.y())
mvp.scale(self.camera.zoom, self.camera.zoom)
mvp.translate(self.camera.pos.x(), self.camera.pos.y())
return mvp
def __init__(self, paint_device):
# NB: AllFeatures passed since doing otherwise results in unsupported
# features being turned into rasters (which is not a useful fallback
# here).
super().__init__(QPaintEngine.PaintEngineFeature.AllFeatures)
self._transform = QTransform()
self._pen = QPen()
# [((r, g, b, a) or None, width, [(x, y), ...]), ...]
#
# Colours are None or tuples of 0.0 to 1.0 floats. Line widths are
# given in pixels. Line coordinates are given in pixels.
self._outlines = []
def testsquareToQuad(self):
q1 = QPolygonF()
q1.append(QPointF(10.0, 10.0))
q1.append(QPointF(20.0, 10.0))
q1.append(QPointF(10.0, -10.0))
q1.append(QPointF(20.0, -10.0))
t1 = QTransform()
r1 = QTransform.squareToQuad(q1, t1)
r2 = QTransform.squareToQuad(q1)
self.assertTrue(r1)
self.assertTrue(r2)
self.assertEqual(t1, r2)
def _transform_image(self) -> QPixmap:
"""Create a randomly rotated and resized version of self.image."""
# Rotate
degrees = random.randint(0, 359)
transform = QTransform()
transform.rotate(degrees)
image = self.image.transformed(transform)
# Generate random dimensions but make sure the image fits to the screen
dim = 'width' if image.width() > image.height() else 'height'
image = self._normalize(image, dim)
other = {'width': 'height', 'height': 'width'}[dim]
if getattr(image, other)() >= getattr(self, 'screen_' + other):
image = self._normalize(image, other)
return image
def refreshImage(self, i, j):
currentItem = self.itemAt(self.xFromCol(j), self.yFromRow(i),
QTransform())
if currentItem != 0 and currentItem.data(0) == 777:
currentItem = None
filename = self.getPieceFilename(self.board[i][j])
if filename == "":
return
y = self.nPieceWidth * i
x = self.nPieceWidth * j
item = QGraphicsPixmapItem(QPixmap(filename))
colorize = QGraphicsColorizeEffect()
if self.board[i][j].color() == pieceColor.White:
if self.threatPiece[i][j]:
colorize.setColor(self.cLightPieceColorThreat)
else:
colorize.setColor(self.cLightPieceColor)
else:
if self.threatPiece[i][j]:
colorize.setColor(self.cDarkPieceColorThreat)
else:
colorize.setColor(self.cDarkPieceColor)
item.setGraphicsEffect(colorize)
item.setCacheMode(QGraphicsItem.NoCache) # needed for proper rendering
item.setData(0, 777)
self.addItem(item)
item.setPos(x, y)
def refreshTile(self, i, j):
currentItem = self.itemAt(j * self.nPieceWidth, i * self.nPieceWidth,
QTransform())
if currentItem != 0 and currentItem.data(0) == 777:
currentItem = None
self.drawTile(i, j)
def __init__(self, model_type: str = '', pst_xy: np.ndarray = None, dir_xy: np.ndarray = None, v_xy: np.ndarray = None,
radius: int = 1, damage: float = 0, life: float = 1, weight: float = 1, creator: str = 'unknown'):
self._type = model_type
self._pst_xy = np.array([0, 0]) if pst_xy is None else pst_xy
self._dir_xy = np.array([0, 1]) if dir_xy is None else dir_xy
self._v_xy = np.array([0, 0]) if v_xy is None else v_xy
self._transform = QTransform()
self._transform.rotate(self.angle)
self._damage = damage
self._radius = radius
self._life = life
self.color = 255, 255, 255
self.weight = weight
self.name = 'unknown'
self._creator = creator
def clearMap(self):
self.ui.gvWorldMap.setTransform(QTransform())
self.scene.clear()
self.drawMap()
self.ui.listWidget.clear()
self.ui.departure.setCurrentIndex(-1)
self.ui.arrival.setCurrentIndex(-1)
def changeAiLeftHandTo(self, number):
# self.player_left.setPixmap()
# image_hand = QtGui.QPixmap("Assets/AiPlayer/"+str(number)+"Kiri.png")
image_hand = QtGui.QPixmap("Assets/AiKiri/akiri0" + str(number) +
"f4.png")
image_hand = image_hand.transformed(QTransform().scale(1, -1))
self.ai_left.setPixmap(image_hand)
def mousePressEvent(self, event): # 重载鼠标事件
pos = event.scenePos() # 当前鼠标事件发生的场景坐标QPointF(x,y)
x, y = pos.toTuple()
old_point = self.current_point
if event.button() == Qt.LeftButton and not self.acceptMove: # 仅左键事件触发且不接受拖拽时
transform = QTransform(1, 0, 0, 0, 1, 0, 0, 0, 1) # 仿射变换矩阵，这里是不变
self.current_point = self.itemAt(pos, transform)
print("选中的图元：", self.current_point)
if isinstance(self.current_point, QGraphicsEllipseItem):
self.wh *= 2 # 选中后放大关键点
lx, ly = self.center2LeftTop(x, y)
self.current_point.setRect(QRect(lx, ly, self.wh, self.wh))
self.acceptMove = True # 允许拖拽
self.select_listItem()
else:
self.current_point = old_point # 防止选中了点后，没按右键释放，而是选中了图片图元
if event.button() == Qt.RightButton and self.acceptMove: # 仅右键事件触发
# 如果当前选中的Item是关键点，则将该关键点移动到当前光标所在位置
if isinstance(self.current_point, QGraphicsEllipseItem):
print("释放的点：", self.current_point.rect())
self.wh = self.wh_const # 释放后缩小关键点
lx, ly = self.center2LeftTop(x, y)
self.current_point.setRect(QRect(lx, ly, self.wh, self.wh))
self.updateBoneLine(x, y)
self.acceptMove = False
self.changeKeyPoints(x, y) # 将更改后的坐标映射回原图
self.update_listItem(x, y) # 更新列表框中的关键点坐标数值
self.update()
def __init__(self, reverse=False):
super(QRCItem, self).__init__()
self.reverse = reverse
self.ItemStacksBehindParent = True
self.pixmap = QPixmap(":/images/background.png")
self.pixmap_reflect = self.pixmap.transformed(QTransform().scale(
-1, 1))
def wheelEvent(self, event: QtGui.QWheelEvent):
"""Implementation.
Handles zooming the editor's view.
"""
if (event.modifiers() & Qt.ControlModifier
and event.orientation() == Qt.Vertical):
if event.delta() > 0:
self.zoomIn()
else:
self.zoomOut()
# TODO: Improve cursor anchoring; be more like Aseprite
prevAnchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setTransform(QTransform.fromScale(self.zoom(), self.zoom()))
self.updateSceneRect(self.zoom())
self.setTransformationAnchor(prevAnchor)
event.accept()
elif event.orientation() == Qt.Horizontal:
# XXX: Workaround for the insane horizontal scroll delta of 15240 on the
# Logitech G502 mouse.
if abs(event.delta()) == 15240:
newDelta = 120 if event.delta() > 0 else -120
event = QtGui.QWheelEvent(event.pos(),
event.globalPos(),
newDelta,
event.buttons(),
event.modifiers(),
orient=Qt.Horizontal)
super().wheelEvent(event)
else:
super().wheelEvent(event)
def mouseReleaseEvent(self, event):
# normal mode
if not self.draft_mode:
if event.button() == Qt.LeftButton:
# toggle sidebar with properties
clicked_item = self.itemAt(event.scenePos(), QTransform())
if self._clicked_item:
if isinstance(clicked_item, ProcessItem):
self.views()[0].sidebar_toggled.emit(
clicked_item.data(0))
self.views()[0].commodity_clicked.emit(None)
elif isinstance(clicked_item, CommodityItem):
self.views()[0].sidebar_toggled.emit(None)
self.views()[0].commodity_clicked.emit(
clicked_item.data(0))
else:
self.views()[0].sidebar_toggled.emit(None)
self.views()[0].commodity_clicked.emit(None)
else:
self.views()[0].sidebar_toggled.emit(None)
self.views()[0].commodity_clicked.emit(None)
return
# draft mode in selection
if self.edit_mode == SelectConnect.SELECT:
# release process item
if self._clicked_item:
self._clicked_item.setOpacity(1.0)
# remove clicked item from collision list with drop indicator
collision_items = self.collidingItems(self._drop_indicator)
if collision_items:
collision_items.remove(self._clicked_item)
# avoid placement if colliding with other items
if not collision_items:
self._clicked_item.setPos(self._drop_indicator.scenePos())
self._clicked_item.data(
0).coordinate = self._drop_indicator.pos()
self._bounding_rect.update()
self.disable_drop_indicator()
self._clicked_item = None
else:
# connecting processes
if event.button() == Qt.LeftButton:
clicked_item = self.itemAt(event.scenePos(), QTransform())
self.execute_connection(clicked_item, event.scenePos())
super().mouseReleaseEvent(event)
def changeAiRightHandTo(self, number):
# self.player_left.setPixmap()
# image_hand = QtGui.QPixmap("Assets/AiPlayer/"+str(number)+"Kanan.png")
image_hand = QtGui.QPixmap("Assets/AiKanan/akanan0" + str(number) +
"f4.png")
image_hand = image_hand.transformed(QTransform().scale(1, -1))
self.ai_right.setPixmap(image_hand)
self.ai_right.setScaledContents(True)
def __init__(self,
graph_view_form,
x,
y,
extent,
entity_id=None,
entity_class_id=None):
"""Initializes item
Args:
graph_view_form (GraphViewForm): 'owner'
x (float): x-coordinate of central point
y (float): y-coordinate of central point
extent (int): Preferred extent
entity_id (int, optional): The entity id in case of a non-wip item
entity_class_id (int, optional): The entity class id in case of a wip item
"""
if not entity_id and not entity_class_id:
raise ValueError(
"Can't create an RelationshipItem without relationship id nor relationship class id."
)
super().__init__()
self._graph_view_form = graph_view_form
self.db_mngr = graph_view_form.db_mngr
self.db_map = graph_view_form.db_map
self.entity_id = entity_id
self._entity_class_id = entity_class_id
self._entity_name = f"<WIP {self.entity_class_name}>"
self.arc_items = list()
self._extent = extent
self.refresh_icon()
self.setPos(x, y)
rect = self.boundingRect()
self.setOffset(-rect.width() / 2, -rect.height() / 2)
self._press_pos = None
self._merge_target = None
self._moved_on_scene = False
self._view_transform = QTransform(
) # To determine collisions in the view
self._views_cursor = {}
self._bg = None
self._bg_brush = Qt.NoBrush
self._init_bg()
self._bg.setFlag(QGraphicsItem.ItemStacksBehindParent, enabled=True)
self.is_wip = None
self._question_item = None # In case this becomes a template
if not self.entity_id:
self.become_wip()
else:
self.become_whole()
self.setZValue(0)
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=True)
self.setFlag(QGraphicsItem.ItemIsMovable, enabled=True)
self.setFlag(QGraphicsItem.ItemIgnoresTransformations, enabled=True)
self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges, enabled=True)
self.setAcceptHoverEvents(True)
self.setCursor(Qt.ArrowCursor)
def remove_marker(self, x, y):
transform = QTransform()
try:
self._scene.removeItem(
self._scene.itemAt(float(x), float(y), transform))
self._scene.removeItem(
self._scene.itemAt(float(x), float(y), transform))
except:
pass
def brushStrokeSeg(qp, x0, y0, x, y, brush):
"""
Base method for brush painting.
The method paints the straight line ((x0,y0), (x, y)) with the brush defined by brush,
using an active QPainter instance qp,
It returns the last painted position, or the initial position if
not any painting occurs, due to spacing constraints.
@param x0: image x-coord
@type x0: float
@param y0: image y-coord
@type y0: float
@param x: image x-coord
@type x: float
@param y: image y-coord
@type y: float
@param brush: painting brush or eraser
@type brush: dict
@return: last painted position
@rtype: 2-uple of float
"""
tmp_x = x
tmp_y = y
# vector of the move
a_x, a_y = tmp_x - x0, tmp_y - y0
# move length : use 1-norm for performance
d = sqrt(a_x * a_x + a_y * a_y)
spacing, jitter, radius, pxmp = brush['spacing'], brush[
'jitter'], brush['size'] / 2, brush['pixmap']
step = 1 if d == 0 else radius * 0.3 * spacing / d # 0.25
sinBeta, cosBeta = 0.0, 1.0
if jitter != 0.0:
step *= (1.0 + choice(brushFamily.jitterRange) * jitter / 100.0)
sinBeta = choice(brushFamily.jitterRange) * jitter / 100
cosbeta = sqrt(1 - sinBeta * sinBeta)
p_x, p_y = x0, y0
if d != 0.0:
cosTheta, sinTheta = a_x / d, a_y / d
if jitter != 0.0:
cosTheta = cosTheta * cosBeta + sinTheta * sinBeta
sinTheta = sinTheta * cosBeta - cosTheta * sinBeta
transform = QTransform(
cosTheta, sinTheta, -sinTheta, cosTheta, 0, 0
) # Caution: angles > 0 correspond to counterclockwise rotations of pxmp
pxmp = pxmp.transformed(transform)
count = 0
maxCount = int(1.0 / step)
while count < maxCount:
count += 1
if pxmp is None:
qp.drawEllipse(QPointF(p_x, p_y), radius, radius)
else:
qp.drawPixmap(QPointF(p_x - radius, p_y - radius),
pxmp) # TODO radius added 19/03/20 validate
p_x, p_y = p_x + a_x * step, p_y + a_y * step
# return last brush position
return p_x, p_y
def __init__(self, scene: 'QTetris.QScene'):
super(QTetris.QView, self).__init__()
self.setTransform(QTransform().rotate(+90).scale(+1, -1))
self.setMinimumSize(100, 200)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setRenderHints(QPainter.Antialiasing)
self.setFrameStyle(QFrame.NoFrame)
self.setMouseTracking(True)
self.setScene(scene)
def mousePressEvent(self, event):
""" Start mouse pan or zoom mode.
"""
if event.button() == Qt.LeftButton:
self.x1 = event.x()
self.y1 = event.y()
pic_x=self.picshow.x()
pic_y=self.picshow.y()
transform=QTransform()
print(self.x1,self.y1)
def testquadToQuad(self):
q1 = QPolygonF()
q1.append(QPointF(10.0, 10.0))
q1.append(QPointF(20.0, 10.0))
q1.append(QPointF(10.0, -10.0))
q1.append(QPointF(20.0, -10.0))
q2 = QPolygonF()
q2.append(QPointF(20.0, 20.0))
q2.append(QPointF(30.0, 20.0))
q2.append(QPointF(20.0, -20.0))
q2.append(QPointF(30.0, -20.0))
t1 = QTransform()
r1 = QTransform.quadToQuad(q1, q2, t1)
r2 = QTransform.quadToQuad(q1, q2)
self.assertTrue(r1)
self.assertTrue(r2)
self.assertEqual(t1, r2)
def paintTileMap(self):
tilemap = self._tilemaps[self._current_tilemap]
tm_w = tilemap.size().width()
tm_h = tilemap.size().height()
self.setFixedWidth(tm_w + 20)
self.setFixedHeight(tm_h + 20)
self._scene.setSceneRect(0, 0, tm_w, tm_h)
if self._current_tilemap_item is not None:
self._current_tilemap_item = self._scene.itemAt(
float(0), float(0), QTransform())
self._scene.removeItem(self._current_tilemap_item)
item = self._scene.addPixmap(tilemap)
def handleRightButton(self, pos: QPointF):
"""Handles the right mouse button for the Editor area.
Returns whether or not the calling event should be accepted.
"""
editor = self._editor
coord = editor.sceneToGrid(pos)
item = editor.itemAtGridPos(coord, QTransform())
if isinstance(item, Tile):
editor.removeTile(coord)
return True
else:
return False
