def draw_text(expected: QPainter, x: int, y: int, text: str):
window = expected.window()
scene = QGraphicsScene(0, 0, window.width(), window.height())
text_item = scene.addSimpleText(text)
font = expected.font()
text_item.setFont(font)
center_text_item(text_item, x, y)
scene.render(expected)
def __init__(self):
super().__init__()
# self.resize(300, 200)
scene = QGraphicsScene(self)
# scene.setItemIndexMethod(QGraphicsScene.NoIndex)
scene.setSceneRect(0, 0, self.width(), self.height())
self.setScene(scene)
recognizer = PanGestureRecognizer()
pan_gesture_id = QGestureRecognizer.registerRecognizer(recognizer)
self.grabGesture(pan_gesture_id)
def __init__(self):
super().__init__()
scene = QGraphicsScene(self)
scene.setSceneRect(0, 0, 10, 10)
self.setScene(scene)
recognizer = PanGestureRecognizer()
# CRASH HERE
pan_gesture_id = QGestureRecognizer.registerRecognizer(recognizer)
self.grabGesture(pan_gesture_id)
def test_click(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'spline_click') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png', QSize(240,
240))).setPos(1, 0)
black_ball = SplineDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(60, 60))
expected_scene.addPixmap(black_ball).setPos(115, 114)
expected_scene.render(expected)
display = SplineDisplay()
height = 0
row = 1
column = 2
piece_item = display.item_levels[height][row][column]
display.resize(348, 264)
display.grab() # Force layout to recalculate.
display.on_click(piece_item)
render_display(display, actual)
def test_update(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240, 'spargo_update') as (
actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SpargoDisplay.load_pixmap('board-1.png',
QSize(240, 240))).setPos(1, 0)
black_ball = SpargoDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(60, 60))
expected_scene.addPixmap(black_ball).setPos(63, 166)
expected_scene.render(expected)
display = SpargoDisplay()
display.resize(348, 264)
display.update_board(SpargoState("""\
A C E G
7 . . . . 7
5 . . . . 5
3 . . . . 3
1 . B . . 1
A C E G
>W
"""))
render_display(display, actual)
assert display.ui.black_count.text() == '1'
assert display.ui.white_count.text() == '0'
def test_double_update(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'spline_double_update') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png', QSize(240,
240))).setPos(1, 0)
white_ball = SplineDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(60, 60))
black_ball = SplineDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(60, 60))
expected_scene.addPixmap(black_ball).setPos(11, 10)
expected_scene.addPixmap(white_ball).setPos(63, 10)
expected_scene.addPixmap(black_ball).setPos(115, 62)
expected_scene.render(expected)
display = SplineDisplay()
trigger_resize(display, 300, 240)
display.update_board(
SplineState("""\
A C E G
7 W B . . 7
5 . . . W 5
3 . . . . 3
1 . . . . 1
A C E G
"""))
display.update_board(
SplineState("""\
A C E G
7 B W . . 7
5 . . B . 5
3 . . . . 3
1 . . . . 1
A C E G
"""))
display.resize(348, 264)
render_display(display, actual)
def test_hover_enter_remove(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(
240, 240, 'spook_hover_enter_remove') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SpookDisplay.load_pixmap('board-1.png', QSize(240,
240))).setPos(1, 0)
white_ball = SpookDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(60, 60))
red_ball = SpookDisplay.load_pixmap('ball-r-shadow-1.png',
QSize(60, 60))
black_ball = SpookDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(60, 60))
black_piece = expected_scene.addPixmap(black_ball)
black_piece.setPos(115, 114)
black_piece.setOpacity(0.5)
red_piece = expected_scene.addPixmap(red_ball)
red_piece.setPos(63, 62)
white_piece = expected_scene.addPixmap(white_ball)
white_piece.setPos(115, 62)
expected_scene.render(expected)
display = SpookDisplay()
display.update_board(
SpookState('''\
A C E G
7 . . . . 7
5 . R W . 5
3 . . B . 3
1 . . . . 1
A C E G
>R(R,B)
'''))
height = 0
row = 1
column = 2
piece_item = display.item_levels[height][row][column]
display.resize(348, 264)
display.grab() # Force layout to recalculate.
display.on_hover_enter(piece_item)
render_display(display, actual)
def test_hover_enter_red(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(
240, 240, 'sandbox_hover_enter_red') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SandboxDisplay.load_pixmap('board-1.png',
QSize(240, 240))).setPos(1, 0)
red_ball = SandboxDisplay.load_pixmap('ball-r-shadow-1.png',
QSize(60, 60))
new_piece = expected_scene.addPixmap(red_ball)
new_piece.setPos(115, 114)
new_piece.setOpacity(0.5)
expected_scene.render(expected)
display = SandboxDisplay()
display.selected_move_type = MoveType.RED
height = 0
row = 1
column = 2
piece_item = display.item_levels[height][row][column]
display.resize(348, 264)
display.grab() # Force layout to recalculate.
display.on_hover_enter(piece_item)
render_display(display, actual)
def __init__(self, start_state: ShibumiGameState):
super().__init__(start_state)
self.start_state = start_state
ui = self.ui = Ui_ShibumiDisplay()
ui.setupUi(self)
scene = QGraphicsScene()
ui.game_display.setScene(scene)
self.background_pixmap = self.assemble_board()
self.background_item = scene.addPixmap(self.background_pixmap)
self.white_scaled = self.white_pixmap = self.load_pixmap(
'ball-w-shadow-1.png')
self.black_scaled = self.black_pixmap = self.load_pixmap(
'ball-b-shadow-1.png')
self.red_scaled = self.red_pixmap = self.load_pixmap(
'ball-r-shadow-1.png')
self.remove_pixmap = self.load_pixmap('ball-x-shadow-1.png')
self.item_levels = []
self.hovered_piece: typing.Optional[GraphicsShibumiPieceItem] = None
for height in range(self.start_state.size):
item_level = []
for row in range(self.start_state.size - height):
item_row = []
for column in range(self.start_state.size - height):
item = GraphicsShibumiPieceItem(height, row, column, self)
scene.addItem(item)
item_row.append(item)
item_level.append(item_row)
self.item_levels.append(item_level)
self.row_labels = []
self.column_labels = []
for i in range(self.start_state.size * 2 - 1):
self.row_labels.append(scene.addSimpleText(str(i + 1)))
self.column_labels.append(scene.addSimpleText(chr(i + 65)))
self.ui.move_black.clicked.connect(
lambda: self.on_move_type_selected(MoveType.BLACK))
self.ui.move_white.clicked.connect(
lambda: self.on_move_type_selected(MoveType.WHITE))
self.ui.move_red.clicked.connect(
lambda: self.on_move_type_selected(MoveType.RED))
self.ui.remove.clicked.connect(
lambda: self.on_move_type_selected(MoveType.REMOVE))
self._selected_move_type = MoveType.BLACK
self._visible_counts: typing.FrozenSet[PlayerCode] = frozenset()
self._visible_move_types: typing.FrozenSet[MoveType] = frozenset()
self.ui.black_count_pixmap.setText('')
self.ui.white_count_pixmap.setText('')
self.ui.red_count_pixmap.setText('')
self.ui.move_black.setText('')
self.ui.move_white.setText('')
self.ui.move_red.setText('')
self.ui.remove.setText('')
self.ui.move_black.setIcon(self.black_pixmap)
self.ui.move_white.setIcon(self.white_pixmap)
self.ui.move_red.setIcon(self.red_pixmap)
self.ui.remove.setIcon(self.remove_pixmap)
self.ui.pass_button.setVisible(False)
self.show_counts = False
self.show_move_types = False
self.debug_message = ''
def rotate_selected(scene: QGraphicsScene, e: QKeyEvent):
for item in scene.selectedItems():
if e.key() == Qt.Key_Right:
item.setRotation(
(item.rotation() + 1 +
(2 * (e.modifiers() == Qt.ShiftModifier))) % 360)
elif e.key() == Qt.Key_Left:
item.setRotation(
(item.rotation() - 1 -
(2 * (e.modifiers() == Qt.ShiftModifier))) % 360)
def __init__(self, parent=None):
super(View, self).__init__(parent)
self.setScene(QGraphicsScene(self))
self.setDragMode(QGraphicsView.NoDrag)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# Chart
self._chart = QChart()
self._chart.setMinimumSize(640, 480)
self._chart.setTitle("Hover the line to show callout. Click the line "
"to make it stay")
self._chart.legend().hide()
self.series = QLineSeries()
self.series.append(1, 3)
self.series.append(4, 5)
self.series.append(5, 4.5)
self.series.append(7, 1)
self.series.append(11, 2)
self._chart.addSeries(self.series)
self.series2 = QSplineSeries()
self.series2.append(1.6, 1.4)
self.series2.append(2.4, 3.5)
self.series2.append(3.7, 2.5)
self.series2.append(7, 4)
self.series2.append(10, 2)
self._chart.addSeries(self.series2)
self._chart.createDefaultAxes()
self._chart.setAcceptHoverEvents(True)
self.setRenderHint(QPainter.Antialiasing)
self.scene().addItem(self._chart)
self._coordX = QGraphicsSimpleTextItem(self._chart)
self._coordX.setPos(self._chart.size().width() / 2 - 50,
self._chart.size().height())
self._coordX.setText("X: ")
self._coordY = QGraphicsSimpleTextItem(self._chart)
self._coordY.setPos(self._chart.size().width() / 2 + 50,
self._chart.size().height())
self._coordY.setText("Y: ")
self._callouts = []
self._tooltip = Callout(self._chart)
self.series.clicked.connect(self.keepCallout)
self.series.hovered.connect(self.tooltip)
self.series2.clicked.connect(self.keepCallout)
self.series2.hovered.connect(self.tooltip)
self.setMouseTracking(True)
def _on_calculate_word_freq(self):
# one reference
# selected = self.window.refListView.currentIndex().row()
# refPath = self.refPaths[selected]
selecteds = self.window.refListView.selectedIndexes()
selectedRefPaths = []
for selected in selecteds:
selectedRefPaths.append(self.refPaths[selected.row()])
self.backend.update_refs(selectedRefPaths)
wordCloudDraw = self.backend.drawWordCloud()
# binary
biWordCloudDraw = wordCloudDraw.to_array()
x = biWordCloudDraw.shape[1]
y = biWordCloudDraw.shape[0]
channel = biWordCloudDraw.shape[2]
frame = QImage(biWordCloudDraw, x, y, QImage.Format_RGB888)
pix = QPixmap.fromImage(frame)
scene = QGraphicsScene()
item = QGraphicsPixmapItem(pix)
scene.addItem(item)
self.window.wordCloudView.setScene(scene)
def fit_view():
self.window.wordCloudView.fitInView(item)
def save_image():
wordCloudDraw.to_file('wc.png')
rezoom = QAction(self.window.wordCloudView)
rezoom.setText('Rezoom')
rezoom.triggered.connect(fit_view)
save = QAction(self.window.wordCloudView)
save.setText('Save')
save.triggered.connect(save_image)
self.window.wordCloudView.addAction(rezoom)
self.window.wordCloudView.addAction(save)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.processing = False
self.rectangle = None
self.setMinimumHeight(405)
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(Qt.black))
self.view = QGraphicsView(self.scene)
self.viewfinder = QGraphicsVideoItem()
self.scene.addItem(self.viewfinder)
self.layout.addWidget(self.view)
self.setLayout(self.layout)
self.camera = None
self.captureSession = None
self.imageCapture = None
self.captureTimer = None
def __init__(self, parent=None, audio=None, settings=None):
super().__init__(parent)
self.setupUi(self)
self.bg_image = None
self.spectrogram_scene = QGraphicsScene(self)
self._audio = None
self._spectrogram = None
self._image_generator = None
self.sound_marker = None
self.marker_position = 0
self.yscale = 1
self.settings = settings
self.audio = audio
self.setup_graphics_view()
self.define_shortcuts()
self.install_filters()
def rescale_selected(scene: QGraphicsScene, e: QKeyEvent):
for item in scene.selectedItems():
transform = item.transform()
if e.key() == Qt.Key_W:
transform.scale(1, 1.01)
elif e.key() == Qt.Key_S:
transform.scale(1, 0.99)
elif e.key() == Qt.Key_D:
transform.scale(1.01, 1)
elif e.key() == Qt.Key_A:
transform.scale(0.99, 1)
item.setTransform(transform)
def test_empty(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'sandbox_empty') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SandboxDisplay.load_pixmap('board-1.png',
QSize(240, 240))).setPos(1, 0)
expected_scene.render(expected)
display = SandboxDisplay()
display.resize(348, 264)
render_display(display, actual)
for widget in (display.ui.move_black, display.ui.move_white,
display.ui.move_red, display.ui.remove,
display.ui.black_count_pixmap,
display.ui.white_count_pixmap, display.ui.red_count_pixmap,
display.ui.black_count, display.ui.white_count,
display.ui.red_count):
assert widget.isVisibleTo(display)
assert display.ui.move_black.isChecked()
assert display.ui.red_count.text() == '0'
def test_empty(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240, 'spargo_empty') as (
actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SpargoDisplay.load_pixmap('board-1.png',
QSize(240, 240))).setPos(1, 0)
expected_scene.render(expected)
display = SpargoDisplay()
display.resize(348, 264)
render_display(display, actual)
assert display.ui.move_text.text() == 'to move'
assert display.ui.black_count.text() == '0'
assert display.ui.red_count.text() == ''
assert display.ui.white_count.text() == '0'
black_icon = display.black_pixmap.toImage()
assert display.ui.black_count_pixmap.pixmap().toImage() == black_icon
assert display.ui.player_pixmap.pixmap().toImage() == black_icon
white_icon = display.white_pixmap.toImage()
assert display.ui.white_count_pixmap.pixmap().toImage() == white_icon
def test_coordinates(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 200,
'spline_coordinates') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 200)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png',
QSize(160, 160))).setPos(36, 0)
for i in range(7):
add_text(expected_scene, str(7 - i), 15 + i % 2 * 10, i * 17 + 27,
10)
add_text(expected_scene, chr(65 + i), i * 17 + 64,
178 - i % 2 * 10, 10)
expected_scene.render(expected)
display = SplineDisplay()
display.resize(348, 224)
display.show_coordinates = True
render_display(display, actual)
def test_first_level(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'spline_first_level') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png', QSize(240,
240))).setPos(1, 0)
white_ball = SplineDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(60, 60))
black_ball = SplineDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(60, 60))
expected_scene.addPixmap(white_ball).setPos(11, 10)
expected_scene.addPixmap(black_ball).setPos(63, 10)
expected_scene.addPixmap(black_ball).setPos(167, 62)
expected_scene.render(expected)
display = SplineDisplay()
display.update_board(
SplineState("""\
A C E G
7 W B . . 7
5 . . . B 5
3 . . . . 3
1 . . . . 1
A C E G
"""))
display.resize(348, 264)
render_display(display, actual)
white_icon = SplineDisplay.load_pixmap('ball-w-shadow-1.png').toImage()
assert display.ui.player_pixmap.pixmap().toImage() == white_icon
def __init__(self):
super().__init__()
scene = QGraphicsScene()
self.setScene(scene)
self.setRenderHint(QPainter.Antialiasing)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setMouseTracking(True)
self._offset = QPointF(0, 0)
self._zoom = 0
self.backgroundColor = QColor(40, 40, 40)
self.gridSpacing = QSizeF(60, 60)
self.gridThickness = 1
self.gridColor = QColor(100, 100, 100)
self.gridZoomThreshold = -1.5
self.showGrid = True
self.selectionBoxStrokeColor = QColor(52, 222, 235)
self.selectionBoxFillColor = QColor(52, 222, 235, 50)
self.selectionBoxThickness = 2
self._editing = True
self._hoveredItems: List[ChipItem] = []
self._selectedItems: List[ChipItem] = []
self._sceneItems: Set[ChipItem] = set()
self._boxSelectionRectAnchor = QPointF()
self._currentCursorPosition = QPointF()
self.selectionBox = self.scene().addRect(QRectF(),
QPen(self.selectionBoxStrokeColor, self.selectionBoxThickness),
QBrush(self.selectionBoxFillColor))
self.selectionBox.setVisible(False)
self._state = State.IDLE
self.UpdateView()
def test_hover_enter_leave(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(
240, 240, 'sandbox_hover_enter_leave') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SandboxDisplay.load_pixmap('board-1.png',
QSize(240, 240))).setPos(1, 0)
white_ball = SandboxDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(60, 60))
new_piece = expected_scene.addPixmap(white_ball)
new_piece.setPos(115, 114)
expected_scene.render(expected)
display = SandboxDisplay()
display.update_board(
SandboxState('''\
A C E G
7 . . . . 7
5 . . . . 5
3 . . W . 3
1 . . . . 1
A C E G
'''))
display.selected_move_type = MoveType.REMOVE
height = 0
row = 1
column = 2
piece_item = display.item_levels[height][row][column]
display.resize(348, 264)
display.grab() # Force layout to recalculate.
display.on_hover_enter(piece_item)
display.on_hover_leave(piece_item)
render_display(display, actual)
def test_resize_narrow(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(120, 240,
'spline_resize_narrow') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 120, 240)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png',
QSize(120, 123))).setPos(0, 59)
expected_scene.render(expected)
display = SplineDisplay()
display.resize(204, 264)
render_display(display, actual)
def test_empty(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'spline_empty') as (actual, expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
expected_scene.addPixmap(
SplineDisplay.load_pixmap('board-1.png', QSize(240,
240))).setPos(1, 0)
expected_scene.render(expected)
display = SplineDisplay()
display.resize(348, 264)
render_display(display, actual)
black_icon = SplineDisplay.load_pixmap('ball-b-shadow-1.png').toImage()
assert display.ui.player_pixmap.pixmap().toImage() == black_icon
assert display.ui.move_text.text() == 'to move'
def test_coordinates(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(360, 240,
'margo_coordinates') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 360, 240)
display = MargoDisplay(size=2)
full_board = display.assemble_board()
scaled_board = display.scale_pixmap(full_board, 185, 192)
expected_scene.addPixmap(scaled_board).setPos(82, 0)
add_text(expected_scene, '3', 57, 57, 12)
add_text(expected_scene, '2', 68, 93, 12)
add_text(expected_scene, '1', 57, 129, 12)
add_text(expected_scene, 'A', 141, 214, 12)
add_text(expected_scene, 'B', 177, 203, 12)
add_text(expected_scene, 'C', 213, 214, 12)
expected_scene.render(expected)
display.resize(492, 264)
display.show_coordinates = True
render_display(display, actual)
def delete_selected(scene: QGraphicsScene, gim: GraphicItemModel):
gim.delete_all_from_references(scene.selectedItems())
for item in scene.selectedItems():
scene.removeItem(item)
def __init__(self):
super(self.__class__, self).__init__()
Ui_Img.__init__(self)
self.setupUi(self)
self.bookId = ""
self.epsId = 0
self.curIndex = 0
self.setWindowTitle("IMG")
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.resize(800, 900)
self.checkBox.setChecked(True)
self.index = 0
self.comboBox.setCurrentIndex(self.index)
validator = QIntValidator(0, 9999999)
self.heighEdit.setValidator(validator)
self.widthEdit.setValidator(validator)
exp = QDoubleValidator(0.1, 64, 1)
exp.setNotation(exp.StandardNotation)
self.scaleEdit.setValidator(exp)
# self.setWindowFlags(Qt.FramelessWindowHint)
self.graphicsView.setFrameStyle(QFrame.NoFrame)
self.graphicsView.setObjectName("graphicsView")
self.graphicsView.setBackgroundBrush(QColor(Qt.white))
self.graphicsView.setCursor(Qt.OpenHandCursor)
self.graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphicsView.setRenderHints(QPainter.Antialiasing |
QPainter.SmoothPixmapTransform)
self.graphicsView.setCacheMode(self.graphicsView.CacheBackground)
self.graphicsView.setViewportUpdateMode(self.graphicsView.SmartViewportUpdate)
self.graphicsItem = QGraphicsPixmapItem()
self.graphicsItem.setFlags(QGraphicsPixmapItem.ItemIsFocusable |
QGraphicsPixmapItem.ItemIsMovable)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.CopyPicture)
self.graphicsScene = QGraphicsScene(self) # 场景
self.graphicsView.setScene(self.graphicsScene)
self.graphicsScene.addItem(self.graphicsItem)
self.graphicsView.setMinimumSize(10, 10)
self.pixMap = QPixmap("Loading")
self.graphicsItem.setPixmap(self.pixMap)
# self.radioButton.setChecked(True)
self.isStripModel = False
# self.radioButton.installEventFilter(self)
# self.radioButton_2.installEventFilter(self)
self.graphicsView.installEventFilter(self)
self.graphicsView.setWindowFlag(Qt.FramelessWindowHint)
# tta有BUG，暂时屏蔽 TODO
# self.ttaModel.setEnabled(False)
self.data = b""
self.waifu2xData = b""
self._delta = 0.1
self.scaleCnt = 0
self.backStatus = ""
self.format = ""
class QtImg(QtWidgets.QWidget, Ui_Img):
def __init__(self):
super(self.__class__, self).__init__()
Ui_Img.__init__(self)
self.setupUi(self)
self.bookId = ""
self.epsId = 0
self.curIndex = 0
self.setWindowTitle("IMG")
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.resize(800, 900)
self.checkBox.setChecked(True)
self.index = 0
self.comboBox.setCurrentIndex(self.index)
validator = QIntValidator(0, 9999999)
self.heighEdit.setValidator(validator)
self.widthEdit.setValidator(validator)
exp = QDoubleValidator(0.1, 64, 1)
exp.setNotation(exp.StandardNotation)
self.scaleEdit.setValidator(exp)
# self.setWindowFlags(Qt.FramelessWindowHint)
self.graphicsView.setFrameStyle(QFrame.NoFrame)
self.graphicsView.setObjectName("graphicsView")
self.graphicsView.setBackgroundBrush(QColor(Qt.white))
self.graphicsView.setCursor(Qt.OpenHandCursor)
self.graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphicsView.setRenderHints(QPainter.Antialiasing |
QPainter.SmoothPixmapTransform)
self.graphicsView.setCacheMode(self.graphicsView.CacheBackground)
self.graphicsView.setViewportUpdateMode(self.graphicsView.SmartViewportUpdate)
self.graphicsItem = QGraphicsPixmapItem()
self.graphicsItem.setFlags(QGraphicsPixmapItem.ItemIsFocusable |
QGraphicsPixmapItem.ItemIsMovable)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.CopyPicture)
self.graphicsScene = QGraphicsScene(self) # 场景
self.graphicsView.setScene(self.graphicsScene)
self.graphicsScene.addItem(self.graphicsItem)
self.graphicsView.setMinimumSize(10, 10)
self.pixMap = QPixmap("Loading")
self.graphicsItem.setPixmap(self.pixMap)
# self.radioButton.setChecked(True)
self.isStripModel = False
# self.radioButton.installEventFilter(self)
# self.radioButton_2.installEventFilter(self)
self.graphicsView.installEventFilter(self)
self.graphicsView.setWindowFlag(Qt.FramelessWindowHint)
# tta有BUG，暂时屏蔽 TODO
# self.ttaModel.setEnabled(False)
self.data = b""
self.waifu2xData = b""
self._delta = 0.1
self.scaleCnt = 0
self.backStatus = ""
self.format = ""
def ShowImg(self, data):
if data:
self.data = data
self.waifu2xData = b""
QtTask().CancelConver("QtImg")
self._ShowImg(data)
elif self.data:
self._ShowImg(self.data)
else:
pass
def _ShowImg(self, data):
self.scaleCnt = 0
self.pixMap = QPixmap()
self.pixMap.loadFromData(data)
self.show()
self.graphicsItem.setPixmap(self.pixMap)
self.graphicsView.setSceneRect(QRectF(QPointF(0, 0), QPointF(self.pixMap.width(), self.pixMap.height())))
size = ToolUtil.GetDownloadSize(len(data))
self.sizeLabel.setText(size)
weight, height = ToolUtil.GetPictureSize(data)
self.resolutionLabel.setText(str(weight) + "x" + str(height))
self.ScalePicture()
def ScalePicture(self):
rect = QRectF(self.graphicsItem.pos(), QSizeF(
self.pixMap.size()))
unity = self.graphicsView.transform().mapRect(QRectF(0, 0, 1, 1))
width = unity.width()
height = unity.height()
if width <= 0 or height <= 0:
return
self.graphicsView.scale(1 / width, 1 / height)
viewRect = self.graphicsView.viewport().rect()
sceneRect = self.graphicsView.transform().mapRect(rect)
if sceneRect.width() <= 0 or sceneRect.height() <= 0:
return
x_ratio = viewRect.width() / sceneRect.width()
y_ratio = viewRect.height() / sceneRect.height()
x_ratio = y_ratio = min(x_ratio, y_ratio)
self.graphicsView.scale(x_ratio, y_ratio)
# if self.readImg.isStripModel:
# height2 = self.pixMap.size().height() / 2
# height3 = self.graphicsView.size().height()/2
# height3 = height3/x_ratio
# p = self.graphicsItem.pos()
# self.graphicsItem.setPos(p.x(), p.y()+height2-height3)
self.graphicsView.centerOn(rect.center())
for _ in range(abs(self.scaleCnt)):
if self.scaleCnt > 0:
self.graphicsView.scale(1.1, 1.1)
else:
self.graphicsView.scale(1/1.1, 1/1.1)
def resizeEvent(self, event) -> None:
super(self.__class__, self).resizeEvent(event)
self.ScalePicture()
def eventFilter(self, obj, ev):
if ev.type() == QEvent.KeyPress:
return True
else:
return super(self.__class__, self).eventFilter(obj, ev)
def wheelEvent(self, event):
if event.angleDelta().y() > 0:
self.zoomIn()
else:
self.zoomOut()
def zoomIn(self):
"""放大"""
self.zoom(1.1)
def zoomOut(self):
"""缩小"""
self.zoom(1/1.1)
def zoom(self, factor):
"""缩放
:param factor: 缩放的比例因子
"""
_factor = self.graphicsView.transform().scale(
factor, factor).mapRect(QRectF(0, 0, 1, 1)).width()
if _factor < 0.07 or _factor > 100:
# 防止过大过小
return
if factor >= 1:
self.scaleCnt += 1
else:
self.scaleCnt -= 1
self.graphicsView.scale(factor, factor)
def CopyPicture(self):
clipboard = QApplication.clipboard()
clipboard.setPixmap(self.pixMap)
QtBubbleLabel.ShowMsgEx(self, "Copy Success")
return
def ReduceScalePic(self):
self.zoom(1/1.1)
return
def AddScalePic(self):
self.zoom(1.1)
return
def OpenPicture(self):
try:
filename = QFileDialog.getOpenFileName(self, "Open Image", ".", "Image Files(*.jpg *.png)")
if filename and len(filename) >= 1:
name = filename[0]
if os.path.isfile(name):
f = open(name, "rb")
data = f.read()
f.close()
self.ShowImg(data)
except Exception as ex:
Log.Error(ex)
return
def StartWaifu2xPng(self):
if self.StartWaifu2x("png"):
self.format = "png"
self.changeJpg.setEnabled(False)
self.changePng.setEnabled(False)
return
def StartWaifu2xJPG(self):
if self.StartWaifu2x("jpg"):
self.format = "jpg"
self.changeJpg.setEnabled(False)
self.changePng.setEnabled(False)
return
def StartWaifu2x(self, format):
if not self.data:
return False
if not config.CanWaifu2x:
return False
from waifu2x_vulkan import waifu2x_vulkan
self.SetStatus(False)
self.index = self.comboBox.currentIndex()
index = self.comboBox.currentIndex()
noise = int(self.noiseCombox.currentText())
if index == 0:
modelName = "CUNET"
elif index == 1:
modelName = "PHOTO"
elif index == 2:
modelName = "ANIME_STYLE_ART_RGB"
else:
return False
if noise == -1:
noiseName = "NO_NOISE"
else:
noiseName = "NOISE"+str(noise)
if modelName == "CUNET" and self.scaleRadio.isChecked() and round(float(self.scaleEdit.text()), 1) <= 1:
modelInsence = "MODEL_{}_NO_SCALE_{}".format(modelName, noiseName)
else:
modelInsence = "MODEL_{}_{}".format(modelName, noiseName)
if self.ttaModel.isChecked():
modelInsence += "_TTA"
model = {
"model": getattr(waifu2x_vulkan, modelInsence),
}
if self.scaleRadio.isChecked():
model['scale'] = round(float(self.scaleEdit.text()), 1)
else:
model['width'] = int(self.widthEdit.text())
model['high'] = int(self.heighEdit.text())
model['format'] = format
self.backStatus = self.GetStatus()
QtTask().AddConvertTask(self.data, model, self.AddConvertBack,
cleanFlag="QtImg")
self.changeLabel.setText(self.tr("正在转换"))
return True
def AddConvertBack(self, data, waifuId, backParam, tick):
if data:
self.waifu2xData = data
if self.checkBox.isChecked():
self._ShowImg(data)
self.changeLabel.setText(self.tr("已转换"))
self.tickLabel.setText(str(round(tick, 3)) + "s")
else:
self.changeLabel.setText(self.tr("失败"))
self.SetStatus(True)
return
def CheckHideButton(self):
if self.format == "":
self.changePng.setEnabled(True)
self.changeJpg.setEnabled(True)
elif self.format == "png":
self.changePng.setEnabled(False)
self.changeJpg.setEnabled(True)
else:
self.changePng.setEnabled(True)
self.changeJpg.setEnabled(False)
def SavePicture(self):
data = self.waifu2xData if self.waifu2xData else self.data
if not data:
return
try:
today = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
picFormat = self.format if self.format else "jpg"
filepath = QFileDialog.getSaveFileName(self, "Save", "{}.{}".format(today, picFormat))
if filepath and len(filepath) >= 1 and filepath[0]:
name = filepath[0]
f = open(name, "wb")
f.write(data)
f.close()
except Exception as es:
Log.Error(es)
return
def SwithPicture(self):
if self.checkBox.isChecked() and self.waifu2xData:
self._ShowImg(self.waifu2xData)
else:
self._ShowImg(self.data)
return
def ChangeModel(self, index):
# self.index = self.comboBox.currentIndex()
self.CheckScaleRadio()
return
def GetStatus(self):
data = str(self.noiseCombox.currentText()) + \
str(self.buttonGroup_2.checkedId()) + \
str(self.scaleEdit.text()) + \
str(self.heighEdit.text()) + \
str(int(self.ttaModel.isChecked())) + \
str(self.widthEdit.text()) + \
str(self.comboBox.currentIndex())
return data
def SetStatus(self, status):
self.scaleRadio.setEnabled(status)
self.heighRadio.setEnabled(status)
self.scaleEdit.setEnabled(status)
self.widthEdit.setEnabled(status)
self.heighEdit.setEnabled(status)
self.noiseCombox.setEnabled(status)
self.comboBox.setEnabled(status)
# self.radioButton_4.setEnabled(status)
# self.radioButton_5.setEnabled(status)
# self.radioButton_6.setEnabled(status)
# self.radioButton_7.setEnabled(status)
# self.radioButton_8.setEnabled(status)
# self.ttaModel.setEnabled(status)
self.CheckScaleRadio()
def SetEnable(self):
self.SetStatus(True)
def SetDisEnable(self):
self.SetStatus(False)
def CheckScaleRadio(self):
if self.scaleRadio.isChecked() and self.scaleRadio.isEnabled():
self.scaleEdit.setEnabled(True)
self.widthEdit.setEnabled(False)
self.heighEdit.setEnabled(False)
elif self.heighRadio.isChecked() and self.heighRadio.isEnabled():
self.scaleEdit.setEnabled(False)
self.widthEdit.setEnabled(True)
self.heighEdit.setEnabled(True)
data = self.GetStatus()
if self.backStatus != data:
self.changePng.setEnabled(True)
self.changeJpg.setEnabled(True)
else:
self.CheckHideButton()
def __init__(self, start_state: GridGameState):
super().__init__(start_state)
self.start_state: GridGameState = start_state
self.spaces = [] # self.spaces[i][j] holds row i, column j
self.column_dividers = []
self.row_dividers = []
self.column_labels = []
self.row_labels = []
self.text_x = self.text_y = 0
ui = self.ui = Ui_GridControls()
ui.setupUi(self)
scene = QGraphicsScene()
ui.game_display.setScene(scene)
scene.setBackgroundBrush(self.background_colour)
self.player1_icon = self.create_icon(self.player1_colour)
self.player2_icon = self.create_icon(self.player2_colour)
ui.black_count_pixmap.setText('')
ui.white_count_pixmap.setText('')
ui.black_count.setText('')
ui.white_count.setText('')
for _ in range(start_state.board_height - 1):
self.row_dividers.append(scene.addLine(0, 0, 1, 1))
for _ in range(start_state.board_width - 1):
self.column_dividers.append(scene.addLine(0, 0, 1, 1))
for i in range(start_state.board_height):
self.row_labels.append(scene.addSimpleText(f'{i + 1}'))
for j in range(start_state.board_width):
self.column_labels.append(scene.addSimpleText(chr(65 + j)))
self.to_move = scene.addEllipse(0,
0,
1,
1,
brush=self.get_player_brush(
self.start_state.X_PLAYER))
self.to_move.setVisible(False)
self.move_text = ui.move_text
for i in range(self.start_state.board_height):
row: typing.List[GraphicsPieceItem] = []
self.spaces.append(row)
for j in range(self.start_state.board_width):
piece = GraphicsPieceItem(i, j, self)
scene.addItem(piece)
piece.setBrush(self.background_colour)
piece.setPen(self.background_colour)
row.append(piece)
self.debug_message = ''
def __init__(self):
super(MainWindow, self).__init__()
# Załadowanie layoutu [Modyfikować tylko w Designerze!]:
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Ustawienie kilku parametrów aplikacji
self.setWindowTitle("Paint Application")
self.setWindowIcon(QIcon("../Icons/main_icon.png"))
self.ui.actionselect.setChecked(True)
self.unsaved_changes = False
# GraphicItemModel i listView
self.gim = GraphicItemModel()
self.ui.listView.setModel(self.gim)
# Scena
self.scene = QGraphicsScene()
# Widok - utworzenie, połączenie z widokiem, dodanie do okienka aplikacji
self.graphicsView = CustomQGraphicsView(self.scene,
self.centralWidget(), self.gim)
self.graphicsView.setObjectName(u"graphicsView")
self.graphicsView.setMinimumSize(QSize(250, 250))
self.ui.gridLayout.addWidget(self.graphicsView, 0, 0, 1, 1)
# Dialogi:
# PrePickerDialog - wyświetlanie dialogu przed wyborem koloru (dla brush lub pen)
self.color_picker_decide = PrePickerDialog()
# ColorDialog - wybór koloru, dialog wyświetlany po PrePickerDialog
self.color_picker_dialog = QColorDialog()
# UnsavedChangesDialog - wyświetalnie dialogu np. po "Quit" lub "New" gdy są niezapisane zmiany
self.unsaved_changes_dialog = UnsavedChangesDialog()
# AboutDialog - wyświetalnie dialogu z informacjami o aplikacji
self.about_dialog = AboutDialog()
# AboutDialog - wyświetalnie dialogu z informacjami o nawigacji
self.navigation_dialog = NavigationDialog()
# ItemsInputOutput - menadżer zapisu i odczytu plików zawierających figury
self.reader_writer = ItemsInputOutput(self.scene)
# Powiązanie sygnałów ze slotami
self.ui.actionNew.triggered.connect(self.slot_menu_new)
self.ui.actionExport.triggered.connect(self.slot_menu_export)
self.ui.actionSave.triggered.connect(self.slot_menu_save)
self.ui.actionOpen.triggered.connect(self.slot_menu_open)
self.ui.actionQuit.triggered.connect(self.slot_menu_quit)
self.ui.actionAbout.triggered.connect(self.slot_menu_about)
self.ui.actionNavigation.triggered.connect(self.slot_menu_navigation)
self.ui.actionselect.triggered.connect(self.slot_trigger_select)
self.ui.actionrectangle.triggered.connect(self.slot_trigger_rectangle)
self.ui.actiontriangle.triggered.connect(self.slot_trigger_triangle)
self.ui.actionellipse.triggered.connect(self.slot_trigger_ellipse)
self.ui.actionline.triggered.connect(self.slot_trigger_line)
self.ui.actionpolygon.triggered.connect(self.slot_trigger_polygon)
self.ui.actionpicker.triggered.connect(self.slot_trigger_picker)
self.ui.actionWidth.triggered.connect(self.slot_trigger_line_width)
self.ui.lineEdit.textEdited.connect(self.slot_text_edited)
self.color_picker_dialog.colorSelected.connect(
self.slot_color_selected)
self.gim.renamed.connect(self.unsaved_changes_detected)
self.graphicsView.changed.connect(self.unsaved_changes_detected)
class SpectrogramViewer(QtWidgets.QWidget, Ui_SpectrogramViewer):
seek = QtCore.Signal(float)
spectrogram_drawn = QtCore.Signal()
def __init__(self, parent=None, audio=None, settings=None):
super().__init__(parent)
self.setupUi(self)
self.bg_image = None
self.spectrogram_scene = QGraphicsScene(self)
self._audio = None
self._spectrogram = None
self._image_generator = None
self.sound_marker = None
self.marker_position = 0
self.yscale = 1
self.settings = settings
self.audio = audio
self.setup_graphics_view()
self.define_shortcuts()
self.install_filters()
def setup_graphics_view(self):
self.spectrogram_view.setScene(self.spectrogram_scene)
def define_shortcuts(self):
QtGui.QShortcut(
QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_Plus), self,
self.zoom_in)
QtGui.QShortcut(
QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_Minus),
self,
self.zoom_out,
)
def install_filters(self):
self.mouse_filter = SpectrogramMouseFilter(self)
self.spectrogram_scene.installEventFilter(self.mouse_filter)
@property
def audio(self):
return self._audio
@audio.setter
def audio(self, audio):
if audio is not None:
self._audio = audio
self.spectrogram = Spectrogram(audio, self.spectrogram_options)
self.marker_position = 0
@property
def spectrogram(self):
return self._spectrogram
@spectrogram.setter
def spectrogram(self, spectrogram):
self._spectrogram = spectrogram
self.display_spectrogram()
@property
def image_options(self):
return self.settings.image_options if self.settings else {}
@property
def spectrogram_options(self):
return self.settings.spectrogram_options if self.settings else {}
@property
def image_generator(self):
if self._image_generator is None:
self._image_generator = ImageGenerator(self.image_options)
return self._image_generator
def display_spectrogram(self):
# TODO: save image somewhere
im = self.image_generator.spec2img(self.spectrogram)
# TODO: change events when checkbox is checked
# if self.checkbox_draw_events.isChecked():
# im = self.draw_events(im, max_duration)
img = ImageQt.ImageQt(im)
pixmap = QtGui.QPixmap.fromImage(img)
# Change Qt array to a Qt graphic
self.bg_image = QGraphicsPixmapItem(pixmap)
self.spectrogram_scene.clear()
self.spectrogram_scene.addItem(self.bg_image)
# Ensure spectrogram graphic is displayed as background
self.bg_image.setZValue(-100)
self.bg_image.setPos(0, 0)
self.sound_marker = None
if self.marker_position:
self.update_sound_marker(None)
self.spectrogram_drawn.emit()
def display_text(self, text):
text_item = QGraphicsTextItem()
text_item.setPos(150, 100)
text_item.setPlainText(text)
self.spectrogram_scene.clear()
self.spectrogram_scene.addItem(text_item)
def update_sound_marker(self, position_sec):
# 100 # multiply by step-size in SpecGen()
if position_sec is not None:
self.marker_position = self.image_generator.sec2pixels(
position_sec)
line = QtCore.QLineF(
self.marker_position,
0,
self.marker_position,
self.image_generator["height"],
)
if not self.sound_marker:
penCol = QtGui.QColor()
penCol.setRgb(255, 0, 0)
self.sound_marker = self.spectrogram_scene.addLine(
line, QtGui.QPen(penCol))
else:
self.sound_marker.setLine(line)
self.spectrogram_scene.update()
if self.spectrogram_options["follow_sound"]:
self.center_view()
def center_view(self):
self.spectrogram_view.centerOn(self.marker_position,
self.get_center().y())
def zoom(self, scale, scene_pos=None):
self.yscale *= scale
self.spectrogram_view.scale(scale, scale)
if scene_pos:
self.spectrogram_view.centerOn(scene_pos)
def zoom_in(self):
self.zoom(1.5)
def zoom_out(self):
self.zoom(0.75)
def seek_sound(self, pos):
self.seek.emit(self.image_generator.pixels2sec(pos))
def update_spectrogram(self, option, redraw):
if redraw:
self.spectrogram = Spectrogram(self.audio,
self.spectrogram_options)
self.freq2pixels(6000)
def update_image(self, option, redraw):
if redraw:
self.display_spectrogram()
def get_center(self):
return self.spectrogram_view.mapToScene(
self.spectrogram_view.viewport().rect().center())
def clear_rects(self):
items = self.spectrogram_scene.items()
for item in items:
if isinstance(item, AnnotatedRectItem):
self.spectrogram_scene.removeItem(item)
def freq2pixels(self, freq):
res = 0
if self.spectrogram["scale"] == "Linear":
height = self.image_generator["height"]
max_freq = self.audio.sr / 2
freq_step = height / max_freq
res = height - (freq * freq_step)
else:
print("Only linear scale is supported so far")
return res
def draw_annotation(self, opts):
x1 = self.image_generator.sec2pixels(opts.get("start", 0))
x2 = self.image_generator.sec2pixels(opts.get("end", 0))
y1 = self.freq2pixels(opts.get("max_freq", 0))
y2 = self.freq2pixels(opts.get("min_freq", 0))
text = opts.get("text", "")
buffer = opts.get("vertical_buffer", 1)
top_offset = opts.get("top_offset", 0)
bottom_offset = opts.get("bottom_offset", 0)
if y2 - y1 <= 0:
y1 = 0
y2 = self.spectrogram_scene.height() - 2
if buffer:
v_offset = buffer * y2 / 100
y1 += v_offset + top_offset
y2 -= v_offset - bottom_offset
if text:
font = QtGui.QFont(opts.get("text_font", ""),
opts.get("text_fontsize", 12))
font_height = QtGui.QFontMetrics(font).height()
y1 += font_height
coords = (x1, y1, x2 - x1, y2 - y1)
opts["coords"] = coords
rect = AnnotatedRectItem(opts)
self.spectrogram_scene.addItem(rect)
def draw_rect(self,
start,
end,
y=0,
height=-1,
color="#ffffff",
fill="",
buffer=1):
x = self.image_generator.sec2pixels(start)
width = self.image_generator.sec2pixels(end - start)
if height == -1:
height = self.spectrogram_scene.height() - 2
rect = QtWidgets.QGraphicsRectItem()
rect.setPen(QtGui.QPen(color))
if fill is not None:
if not fill:
fill = color
rect.setBrush(QtGui.QBrush(fill, QtCore.Qt.SolidPattern))
if buffer:
y += buffer * height / 100
height -= buffer * height / 100
rect.setRect(x, y, width, height)
self.spectrogram_scene.addItem(rect)
