def on_Show_Gate_clicked(self):
"""
生成选通门函数
"""
try:
self.gate_width = float(self.Set_Gate_Width.text())
self.x_lim = np.arange((-self.gate_width),
self.gate_width,
step=0.1)
self.gate = self.gate_function(self.x_lim, self.gate_width / 2)
self.num_gate = len(self.x_lim)
fig = Figure()
self.ax_gate = fig.add_subplot(111)
self.ax_gate.set_xlim([(-self.gate_width), self.gate_width])
self.ax_gate.plot(self.x_lim, self.gate)
self.ax_gate.set_xlabel('T/ns')
self.ax_gate.set_ylabel('Normalizated Volts/mJ')
self.ax_gate.set_title('Gate')
self.ax_gate.text(-self.gate_width / 4, 0.8,
'Gate Width %s ns' % self.gate_width)
dr = FigureCanvas(fig)
graphicscene = QGraphicsScene()
graphicscene.addWidget(dr)
self.GraphicsView_Gate.setScene(graphicscene)
self.GraphicsView_Gate.show()
except BaseException:
QMessageBox.information(self, '错误', '请输入选通门宽度', QMessageBox.Ok)
def on_Show_Res_clicked(self):
"""
显示回波能量
"""
try:
con_result = signal.convolve(self.laser, self.gate, mode='same')
res = (con_result - con_result.min()) / \
(con_result.max() - con_result.min())
x = np.linspace(-(self.gate_width), self.gate_width, self.num_gate)
fig = Figure()
self.ax_res = fig.add_subplot(111)
self.ax_res.set_xlim([
-(self.laser_width + self.gate_width),
(self.laser_width + self.gate_width)
])
self.ax_res.plot(x, res)
self.ax_res.set_xlabel('T/ns')
self.ax_res.set_ylabel('Normalizated Energy/mJ')
self.ax_res.set_title('Echo Energy Envelope')
dr = FigureCanvas(fig)
graphicscene = QGraphicsScene()
graphicscene.addWidget(dr)
self.GraphicsView_Res.setScene(graphicscene)
self.GraphicsView_Res.show()
except BaseException:
QMessageBox.information(self, '错误', '请先输入激光宽度和选通门宽度',
QMessageBox.Ok)
def draw_graph_first(self):
# Создание кубита. Рисование сферы и осей
plt.close()
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_wireframe(self.x, self.y, self.z, color="black", lw=0.5)
frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
frame1.axes.yaxis.set_ticklabels([])
frame1.axes.zaxis.set_ticklabels([])
x, y, z = self.convert_3d_plot_first(0, 0, 1)
ax.quiver(0, 0, 0, x, y, z, length=1.0, color='red', lw=4)
ax.quiver(0, 0, 0, 0, 0, 1.7, length=1.0, color='green', lw=1)
ax.text(0, 0, 1.8, 'Z', rotation=38, fontsize=10)
ax.text(0, 0, 1.2, '|0>', rotation=38, fontsize=13, color='red')
ax.text(0, 0, -1.2, '|1>', rotation=38, fontsize=13, color='red')
ax.quiver(0, 0, 0, 0, -1.7, 0, length=1.0, color='green', lw=1)
ax.text(0, -1.8, 0, 'X', rotation=38, fontsize=10)
ax.quiver(0, 0, 0, 1.7, 0, 0, length=1.0, color='green', lw=1)
ax.text(1.8, 0, 0, 'Y', rotation=38, fontsize=10)
ax.view_init(elev=self.Alpha3D, azim=self.Beta3D)
ax.dist = 9
ax.grid(False)
scene = QGraphicsScene(self)
scene.setSceneRect(100, 100, 300, 300)
canvas = FigureCanvas(fig)
canvas.setGeometry(0, 0, 500, 500)
scene.addWidget(canvas)
self.graphicsView.setScene(scene)
def initScenes(self):
scan_scene = QGraphicsScene()
widg = QWidget()
widg.setGeometry(0, 0, 400, 400)
set_background(widg, "/home/emogrrlxx/Desktop/me.jpg")
scan_scene.addWidget(widg)
self.controller.add_scene(scan_scene, "scan")
def __init__(self, x, y, rotation, i, scene: QGraphicsScene, rocket_id):
super().__init__()
self.rocket_id = rocket_id.__int__()
number_of_active_bullets = 0
if self.rocket_id == 1:
number_of_active_bullets = Server.rocket1_bulletsCounter
elif self.rocket_id == 2:
number_of_active_bullets = Server.rocket2_bulletsCounter
elif self.rocket_id == 3:
number_of_active_bullets = Server.rocket3_bulletsCounter
elif self.rocket_id == 4:
number_of_active_bullets = Server.rocket4_bulletsCounter
if number_of_active_bullets < Server.maximum_of_bullets:
self.image = QPixmap("Images/bullet.png")
t = QTransform().rotate(rotation)
self.setStyleSheet("background:transparent;color:white;")
self.image = self.image.transformed(t)
self.setPixmap(self.image)
self.init_x = x + 20 + 30 * float(cos(radians(rotation)))
self.init_y = y + 20 - 30 * float(sin(radians(rotation)))
self.IDS = Server.bulletIDS
Server.bulletIDS = Server.bulletIDS + 1
inttX = int(round(self.init_x))
inttY = int(round(self.init_y))
if self.rocket_id == 1:# u odnosu na to koja raketa je ispalila metak svrstaj ga u odredjen kolekciju
Server.bulletsCollection1X[self.IDS] = 0
Server.bulletsCollection1Y[self.IDS] = 0
Server.bulletsCollection1X[self.IDS] = inttX
Server.bulletsCollection1Y[self.IDS] = inttY
elif self.rocket_id == 2:
Server.bulletsCollection2X[self.IDS] = 0
Server.bulletsCollection2Y[self.IDS] = 0
Server.bulletsCollection2X[self.IDS] = inttX
Server.bulletsCollection2Y[self.IDS] = inttY
elif self.rocket_id == 3:
Server.bulletsCollection3X[self.IDS] = 0
Server.bulletsCollection3Y[self.IDS] = 0
Server.bulletsCollection3X[self.IDS] = inttX
Server.bulletsCollection3Y[self.IDS] = inttY
elif self.rocket_id == 4:
Server.bulletsCollection4X[self.IDS] = 0
Server.bulletsCollection4Y[self.IDS] = 0
Server.bulletsCollection4X[self.IDS] = inttX
Server.bulletsCollection4Y[self.IDS] = inttY
self.scene = scene
self.xMovement = float(cos(radians(rotation)))
self.yMovement = float(sin(radians(rotation)))
scene.addWidget(self)
self.kreni.connect(self.moveSelf)
self.initBullet()
if self.rocket_id == 1:
Server.rocket1_bulletsCounter = Server.rocket1_bulletsCounter + 1
elif self.rocket_id == 2:
Server.rocket2_bulletsCounter = Server.rocket2_bulletsCounter + 1
elif self.rocket_id == 3:
Server.rocket3_bulletsCounter = Server.rocket3_bulletsCounter + 1
elif self.rocket_id == 4:
Server.rocket4_bulletsCounter = Server.rocket4_bulletsCounter + 1
class Road(QGraphicsView):
def __init__(self, parent):
QGraphicsView.__init__(self, parent=parent)
self.stopGameButton = QPushButton("X")
self.stopGameButton.hide()
self.stopGameButton.setFixedWidth(30)
self.stopGameButton.setFixedHeight(30)
self.stopGameButton.setGeometry(0, 0, 0, 0)
self.stopGameButton.clicked.connect(parent.stop)
self.scene = QGraphicsScene(self)
self.makeRoad(parent)
self.scene.addWidget(self.stopGameButton)
self.setScene(self.scene)
def makeRoad(self, parent):
self.line_space = (parent.height() / (LINE_COUNT - 2)) - LINE_H
bg = QGraphicsRectItem()
bg.setRect(0, 0, parent.width(), parent.height())
bg.setBrush(QBrush(Qt.gray))
self.scene.addItem(bg)
self.lines = []
self.topLineIndex = 0
ax = (parent.width() / 2) - (LINE_W / 2)
for i in range(LINE_COUNT):
line = QGraphicsRectItem()
ay = (i - 1) * (LINE_H + self.line_space)
line.setRect(0, 0, LINE_W, LINE_H)
line.setPos(ax, ay)
line.setBrush(QBrush(Qt.white))
self.scene.addItem(line)
self.lines.append(line)
""" Because of the lines, the scene isn't in the middle """
""" So we add an extra rectangle to center the scene """
spaceFill = QGraphicsRectItem()
ay = (LINE_COUNT - 1) * (LINE_H + self.line_space) - self.line_space
spaceFill.setRect(ax, ay, LINE_W, self.line_space)
self.scene.addItem(spaceFill)
self.setFixedSize(parent.width(), parent.height())
def gameUpdate(self, parent):
index = 0
for line in self.lines:
line.setPos(line.x(), line.y() + ROAD_SPEED)
if line.y() > parent.height():
line.setPos(
line.x(), self.lines[self.topLineIndex].y() -
self.line_space - LINE_H)
self.topLineIndex = index
index += 1
# Disable scrolling window with wheel
def wheelEvent(self, event):
event.ignore()
def on_Show_Laser_clicked(self):
"""
根据所选择的tabwidget ID来确定是生成矩形脉冲还是高斯脉冲
"""
try:
self.index = self.tabWidget.currentIndex()
if self.index == 0: # 将激光脉冲看作矩形函数
self.num_laser = len(self.x_lim)
self.laser_width = float(self.Set_Laser_Width.text())
self.laser = self.gate_function(self.x_lim,
self.laser_width / 2)
fig = Figure()
self.ax_laser = fig.add_subplot(111)
self.ax_laser.set_xlim([(-self.gate_width), self.gate_width])
self.ax_laser.set_xlim([0, 1])
self.ax_laser.cla() # 清除坐标轴
self.ax_laser.plot(self.x_lim, self.laser)
self.ax_laser.set_xlabel('T/ns')
self.ax_laser.set_ylabel('Normalizated Energy/mJ')
self.ax_laser.set_title('Laser Pulse')
self.ax_laser.text(-self.laser_width / 4, 0.8,
'Laser Width %s ns' % self.laser_width)
dr = FigureCanvas(fig)
graphicscene_laser = QGraphicsScene()
graphicscene_laser.addWidget(dr)
self.GraphicsView_Laser.setScene(graphicscene_laser)
self.GraphicsView_Laser.show()
elif self.index == 1: # 将激光脉冲看作高斯脉冲
self.miu = 0
self.laser_width = float(self.Set_Sigma.text())
self.num_laser = len(self.x_lim)
self.laser_no = self.gaussian(self.x_lim, self.miu,
self.laser_width)
self.laser = (self.laser_no - self.laser_no.min()) / \
(self.laser_no.max() - self.laser_no.min())
fig = Figure()
self.ax_laser = fig.add_subplot(111)
self.ax_laser.set_xlim([(-self.gate_width), self.gate_width])
self.ax_laser.set_xlim([0, 1])
self.ax_laser.cla() # 清除坐标轴
self.ax_laser.plot(self.x_lim, self.laser)
self.ax_laser.set_xlabel('T/ns')
self.ax_laser.set_ylabel('Normalizated Energy/mJ')
self.ax_laser.set_title('Laser Pulse')
self.ax_laser.text(-self.miu,
self.laser.max() / 2,
'Laser Width %s ns' % self.laser_width)
dr = FigureCanvas(fig)
graphicscene_laser = QGraphicsScene()
graphicscene_laser.addWidget(dr)
self.GraphicsView_Laser.setScene(graphicscene_laser)
self.GraphicsView_Laser.show()
except BaseException:
QMessageBox.information(self, '错误', '请输入激光脉冲宽度', QMessageBox.Ok)
def compute_and_show_when_click(self):
try:
width = float(self.Width_input.text())
height = float(self.Height_input.text())
delta = float(self.Delta_input.text())
epsi_r_1 = float(self.Epsilon_r1_input.text())
epsi_r_2 = float(self.Epsilon_r2_input.text())
strip_center = float(self.Strip_center_input.text())
strip_width = float(self.Strip_width_input.text())
strip_height = float(self.Strip_height_input.text())
except:
self.err_window = ErrorWindow()
self.err_window.show()
return
bar = 1e-16
if (delta < bar or width < delta or height < delta or epsi_r_1 < 0.0
or epsi_r_2 < 0.0 or strip_center < delta
or strip_center > width or strip_width < delta
or strip_center + 0.5 * strip_width > width
or strip_height < delta or strip_height > height):
self.err_window = ErrorWindow()
self.err_window.show()
return
self.progressBar.setValue(5)
fc = Figure_Canvas()
C_temp = fc.draw_field(width * sl.UM, height * sl.UM, delta * sl.UM,
epsi_r_1, epsi_r_1, strip_center * sl.UM,
strip_width * sl.UM, strip_height * sl.UM)
self.progressBar.setValue(45)
C = fc.draw_field(width * sl.UM, height * sl.UM, delta * sl.UM,
epsi_r_1, epsi_r_2, strip_center * sl.UM,
strip_width * sl.UM, strip_height * sl.UM)
self.progressBar.setValue(85)
if (C_temp < 0.0 or C < 0.0):
self.err_window = ErrorWindow()
self.err_window.Error_message.setText(
"Your grid resolution is too low!")
self.err_window.show()
self.progressBar.setValue(0)
return
graphicscene = QGraphicsScene()
graphicscene.addWidget(fc)
self.field_plot.setScene(graphicscene)
self.progressBar.setValue(95)
MIU = 4 * 3.14159265358979 * 1e-7
EPSI0 = 8.854187817e-12
L = (MIU * EPSI0 * epsi_r_1) / C_temp
C = C * 1e12
L = L * 1e12
self.C_output.setText(str(C))
self.L_output.setText(str(L))
self.progressBar.setValue(0)
class MainWindow(MainControlMixin, MainEventsMixin, QMainWindow):
def __init__(self):
logger.info('%s init', self.__class__.__qualname__)
super().__init__()
self._setupWindow()
self._attachElements()
self._setupContextMenu()
@inject.params(gs=GState)
def reloadState(self, chgs={}, gs=None):
if gs.cfg:
self.setupDynamic(gs.cfg)
if gs.bud or gs.bReload['Window']:
# self.scene.clear()
# self.wdg = BudWidget(gs.bud, gs.cfg)
# self.scene.addWidget(self.wdg)
self.wdg.refreshBuds()
self.centerOnCursor()
if chgs.get('toggle', False):
self.setVisible(not self.isVisible())
def _attachElements(self):
self.ipr = InputProcessor()
self.wdg = BudWidget()
self.scene = QGraphicsScene()
self.scene.addWidget(self.wdg)
self.view = MainView(self.scene)
self.setCentralWidget(self.view)
def _setupWindow(self):
self.setAttribute(Qt.WA_TranslucentBackground)
wflags = Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint | Qt.Tool
self.setWindowFlags(self.windowFlags() | wflags)
self.installEventFilter(self)
self.setMouseTracking(True)
self.setMinimumSize(10, 10)
self.setWindowTitle("{} {}".format(
piony.__appname__, piony.__version__))
def _setupContextMenu(self):
from PyQt5.QtWidgets import QAction
# SEE: http://doc.qt.io/qt-5/qtwidgets-mainwindows-menus-example.html
aQuit = QAction("E&xit", self, shortcut="Ctrl+Q",
shortcutContext=Qt.ApplicationShortcut,
triggered=qApp.quit)
self.addAction(aQuit)
# TODO: for release use Qt.NoContextMenu, enable only in edit-mode
self.setContextMenuPolicy(Qt.ActionsContextMenu)
def initUI(self):
self.setWindowState(Qt.WindowMaximized)
self.setWindowFlags(Qt.WindowMinMaxButtonsHint
| Qt.WindowCloseButtonHint)
self.fc = MyFigureCanvas()
self.fc.test()
graphicscene = QGraphicsScene()
graphicscene.addWidget(self.fc)
self.graphicview = QGraphicsView(self)
self.graphicview.setScene(graphicscene)
grid = QGridLayout()
grid.setSpacing(20)
grid.addWidget(self.graphicview)
self.setLayout(grid)
self.setWindowTitle('全国近十年房价数据箱线图')
def replot(self, music_segment):
self.music_segment = music_segment
self.graphic_view = QGraphicsView()
self.graphic_view.setObjectName('graphic_view')
self.segment_canvas = SegmentCanvas()
self.segment_canvas.plot(self.music_segment.msgs)
graphic_scene = QGraphicsScene()
graphic_scene.addWidget(self.segment_canvas)
self.graphic_view.setScene(graphic_scene)
self.graphic_view.show()
# self.graphic_view.setFixedSize(400, 700)
self.graphic_window.setCentralWidget(self.graphic_view)
self.show()
class Window(QGraphicsView):
def __init__(self):
super().__init__()
self.setWindowTitle('loading_gif')
self.resize(250, 120)
self.scene = QGraphicsScene()
self.setScene(self.scene)
main_layout = QGraphicsLinearLayout(Qt.Horizontal)
form = QGraphicsWidget()
form.setLayout(main_layout)
self.scene.addItem(form)
for i in range(3):
movie = QMovie("loading.gif")
label_loading = QLabel()
label_loading.setMovie(movie)
movie.start()
label_loading.setFrameStyle(QLabel.Box)
label_loading.setAttribute(Qt.WA_OpaquePaintEvent)
proxy_item = self.scene.addWidget(label_loading)
main_layout.addItem(proxy_item)
def tileimport(self):
try:
self.dname = self.lineEdit_PendingPath.text()
self.fname = self.lineEdit_TilePath.text()
self.tiles_exist, self.tiles_to_file = tile_compare(
self.dname, self.fname, self.tilemode)
self.status = 1
if self.tilemode == 0:
self.draw = FigureCanvas(tile_plt(self.tiles_exist))
graphicscene = QGraphicsScene()
graphicscene.addWidget(self.draw)
self.graphicsView.setScene(graphicscene)
self.graphicsView.show()
self.hint()
except:
self.label.setText('匯入檔案發生錯誤!')
def __init__(self,
parent=None,
canvasParent=None,
id=None,
width=14,
height=12,
dpi=100):
# 创建一个Figure，注意：该Figure为matplotlib下的figure，不是matplotlib.pyplot下面的figure
super().__init__()
self.parent = parent
self.id = id
self.lastTickTgam = 0
self.lastTickAd59 = 0
self.count = 0
self.__isUpdate = False
self.fig = Figure(figsize=(width, height), dpi=dpi)
# self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
FigureCanvas.__init__(self.canvas, self.fig) # 初始化父类
self.canvas.setParent(canvasParent)
# self.canvas.setParent(parent)
self.canvasParent = canvasParent
graphicsScene = QGraphicsScene()
graphicsScene.addWidget(self.canvas)
graphicsView = QGraphicsView()
graphicsView.setScene(graphicsScene)
graphicsView.show()
self.viewLayout = QVBoxLayout()
self.viewLayout.addWidget(graphicsView)
self.setLayout(self.viewLayout)
self.canvas.draw()
self.figureOpenInit()
self.fft3dAxInit()
self.freqScoreAxInit()
self.biologyResAxInit()
self.powerScoreAxInit()
self.featureValueAxInit()
self.noticeRelaxAxInit()
self.fig.align_labels() # 对齐标签
# onenet service
self.onenetTgam = onenet.onenet(self.id, "tgam_pack")
self.onenetAd59 = onenet.onenet(self.id, "ad59_pack")
def initUI(self):
self.graphic_view = QGraphicsView()
self.graphic_view.setObjectName('graphic_view')
self.segment_canvas = SegmentCanvas()
self.segment_canvas.plot(self.music_segment.msgs)
graphic_scene = QGraphicsScene()
graphic_scene.addWidget(self.segment_canvas)
self.graphic_view.setScene(graphic_scene)
self.graphic_view.show()
# self.graphic_view.setFixedSize(400, 700)
self.graphic_window = QMainWindow()
self.graphic_window.setCentralWidget(self.graphic_view)
self.maximizeBtn = QPushButton('Expand / Shrink View')
self.btnFont = QFont('Times', 12, QFont.DemiBold)
self.btnFont.setStyleHint(QFont.OldEnglish)
self.maximizeBtn.setFont(self.btnFont)
self.maximizeBtn.setStyleSheet(self.btn_style)
self.maximizeBtn.setMinimumHeight(30)
# self.maximizeBtn.setMaximumWidth(800)
self.maximizeBtn.clicked.connect(self.change_window_size)
self.scrollArea = QScrollArea()
self.scrollAreaContent = QMainWindow()
# self.scrollAreaContent.setGeometry(QRect(0, 0, 400, 700))
self.scrollLayout = QVBoxLayout()
# self.scrollLayout.setSpacing(5)
# self.scrollLayout.setContentsMargins(5, 10, 5, 0)
self.scrollLayout.addWidget(self.maximizeBtn)
self.scrollLayout.addWidget(self.graphic_window)
self.scrollAreaContent.setLayout(self.scrollLayout)
self.scrollArea.setLayout(self.scrollLayout)
self.setCentralWidget(self.scrollArea)
self.setWindowIcon(QIcon(resource_path('icon/gramophone.png')))
self.setWindowTitle('MusicCritique Notes Display')
self.setWindowFlags(Qt.WindowMinimizeButtonHint | Qt.WindowCloseButtonHint)
self.move(1505, 125)
self.resize(400, 770)
self.show()
def draw_move_2(self):
if (self.my_counter == 200):
self.my_counter = 0
self.my_counter += 1
self.moveTeta = self.my_counter * np.pi / 100
self.movePhi = np.pi + self.Hook*self.moveTeta*0.5
#Создание кубита. Рисование сферы и осей
plt.close()
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_wireframe(self.x, self.y, self.z, color="black", lw=0.5)
frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
frame1.axes.yaxis.set_ticklabels([])
frame1.axes.zaxis.set_ticklabels([])
x, y, z = self.convert_3d_plot_move(0, 0, 1)
ax.quiver(0, 0, 0, x, y, z, length=1.0, color='red', lw=4)
ax.quiver(0, 0, 0, 0, 0, 1.7, length=1.0, color='green', lw=1)
ax.text(0, 0, 1.8, 'Z', rotation=38, fontsize=10)
ax.text(0, 0, 1.2, '|0>', rotation=38, fontsize=13, color='red')
ax.text(0, 0, -1.2, '|1>', rotation=38, fontsize=13, color='red')
ax.quiver(0, 0, 0, 0, -1.7, 0, length=1.0, color='green', lw=1)
ax.text(0, -1.8, 0, 'X', rotation=38, fontsize=10)
ax.quiver(0, 0, 0, 1.7, 0, 0, length=1.0, color='green', lw=1)
ax.text(1.8, 0, 0, 'Y', rotation=38, fontsize=10)
ax.view_init(elev=self.moveAlpha3D, azim=self.moveBeta3D)
ax.dist = 9
ax.grid(False)
scene = QGraphicsScene(self)
scene.setSceneRect(100, 100, 300, 300)
canvas = FigureCanvas(fig)
canvas.setGeometry(0, 0, 500, 500)
scene.addWidget(canvas)
self.graphicsView_2.setScene(scene)
self.label_3.setText(f'{round(np.cos(self.moveTeta/2) ** 2, 4)}')
self.label_4.setText(f'{round(np.sin(self.moveTeta/2) ** 2, 4)}')
def setBlurBorder(self, count, **dic):
x = self.width * dic["left"]
y = self.height * dic["top"]
w = self.width * (1-dic["left"]-dic["right"])
h = self.height * (1-dic["top"]-dic["bottom"])
max = sqrt(w*w + h*h)
r = dic["rotation"]
label = QLabel()
label.resize(w, h)
label.setFrameShape(QFrame.Box)
label.setStyleSheet("border:1px solid red;background-color:transparent") #transparent
scene = QGraphicsScene()
scene.addWidget(label)
view = QGraphicsView(scene)
view.resize(max, max)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.rotate(r)
view.setStyleSheet("background-color:transparent")
self.scene.addWidget(view).setPos(x-(max-w)/2, y-(max-h)/2)
class Window(QWidget):
def __init__(self):
super().__init__()
self.scene = QGraphicsScene()
self.scene.setSceneRect(0, 0, 200, 200)
self.view = QGraphicsView()
self.view.setRenderHint(QPainter.HighQualityAntialiasing)
self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.view.setScene(self.scene)
scene_layout = QGraphicsLinearLayout(Qt.Horizontal)
form = QGraphicsWidget()
form.setLayout(scene_layout)
self.scene.addItem(form)
self.main_layout = QHBoxLayout()
self.main_layout.addWidget(self.view)
self.setLayout(self.main_layout)
self.rb0 = QPushButton("Hello")
proxy_rb0 = self.scene.addWidget(self.rb0)
scene_layout.addItem(proxy_rb0)
self.rb1 = QPushButton("Hello")
proxy_rb1 = self.scene.addWidget(self.rb1)
proxy_rb1.setRotation(90)
scene_layout.addItem(proxy_rb1)
self.rb2 = QPushButton("Hello")
proxy_rb2 = self.scene.addWidget(self.rb2)
proxy_rb2.setRotation(180)
scene_layout.addItem(proxy_rb2)
self.rb3 = QPushButton("Hello")
proxy_rb3 = self.scene.addWidget(self.rb3)
proxy_rb3.setRotation(-166)
scene_layout.addItem(proxy_rb3)
def setBlur(self, count, **dic):
x = self.width * dic["left"]
y = self.height * dic["top"]
w = self.width * (1-dic["left"]-dic["right"])
h = self.height * (1-dic["top"]-dic["bottom"])
r = dic["rotation"]
max = sqrt(w*w + h*h)
color = ["#70DB93", "#5C3317", "#9F5F9F", "#B5A642", "#D9D919", "#A62AA2", "#8C7853", "#A67D3D", "#F0F8FF"]
style = "background-color:" + color[count]
label = QLabel()
label.resize(w, h)
label.setStyleSheet(style)
scene = QGraphicsScene()
scene.addWidget(label)
view = QGraphicsView(scene)
view.resize(max, max)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.rotate(r)
view.setStyleSheet("background-color:transparent")
self.scene.addWidget(view).setPos(x-(max-w)/2, y-(max-h)/2)
def vol_show(self):
print("Shape before resampling\t", self.imgs.shape)
imgs_after_resamp, spacing = ldf.resample(self.imgs, self.patient)
print("Shape after resampling\t", imgs_after_resamp.shape)
try:
v, f = ldf.make_mesh(imgs_after_resamp,
threshold=self.threshold,
step_size=self.step)
except Exception:
print('re-resample...')
imgs_after_resamp, spacing = ldf.resample(self.imgs, self.patient)
v, f = ldf.make_mesh(imgs_after_resamp,
threshold=self.threshold,
step_size=self.step)
dr = CFigureCanvas()
dr.plt_3d(v, f, alpha=self.alpha)
graphicscene = QGraphicsScene()
graphicscene.addWidget(dr)
self.graphicsView.setScene(graphicscene)
self.graphicsView.show()
class MainGraphicsWidget(QGraphicsView):
def __init__(self, parent=None):
super(MainGraphicsWidget, self).__init__(parent)
self._scene = QGraphicsScene()
self.setScene(self._scene)
self.transpSlider = QtWidgets.QSlider(
QtCore.Qt.Horizontal,
minimum=10,
maximum=100,
value=100,
valueChanged=self.onValueChanged,
)
self.mainButton = QPushButton('I want it to be "Test" button \n QUIT')
self.mainButton.resize(150, 150)
self.mainButton.clicked.connect(parent.close)
self._scene.addWidget(self.mainButton)
self._scene.addWidget(self.transpSlider)
self.transpSlider.move(300, 100)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
c = QColor(220, 30, 30)
c.setAlphaF(1)
self.setBackgroundBrush(QBrush(c))
self.setFrameShape(QFrame.NoFrame)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
@QtCore.pyqtSlot(int)
def onValueChanged(self, value):
c = QColor(220, 30, 30)
c.setAlphaF(value * 0.01)
self.setBackgroundBrush(QBrush(c))
window.setWindowOpacity(value * 0.03)
self.setStyleSheet(
"MainGraphicsWidget {{background-color: rgba(0, 215, 55, {});}}".
format(value))
def draw_pie(self, data, today):
# if not data:
# return
def sum_data(data):
res = {}
for x in data:
res[x[0]] = 0
for x in data:
res[x[0]] += x[1]
return res
data = sum_data(data)
print('new pie data is {}'.format(data))
self.F = MyFigure(width=3, height=2)
values = [x for x in data.values()]
labels = [x for x in data.keys()]
#colors = ['#7199cf', '#4fc4aa', '#ffff10']
colors_sample = []
for i in range(len(values)):
colors_sample.append(self.colors[i % len(self.colors)])
print(colors_sample)
# 设置饼图的凸出显示
explode = [0 for i in range(len(values))]
self.F.axes.pie(values,
labels=labels,
colors=colors_sample,
explode=explode,
shadow=False)
self.F.fig.suptitle(today)
# graphicscene是一个展示2D图形的场景，setSceneRect的效果是设置场景中可见的矩形范围
# 参数a b c d; a是可见范围左上角坐标的横坐标 b是纵坐标； c是可见范围的横向距离，d是纵向距离
# graphicscene.setSceneRect(QtCore.QRectF(101, 300, 590, 100))
graphicscene = QGraphicsScene()
graphicscene.addWidget(self.F)
graphicscene.setSceneRect(QRectF(101, 300, 590, 100))
self.graphicview.setScene(graphicscene)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# 设置窗口标题
self.setWindowTitle('My First App')
self.setFixedSize(800, 600)
# ===通过graphicview来显示图形
self.graphicview = QGraphicsView() # 第一步，创建一个QGraphicsView
self.graphicview.setObjectName("graphicview")
dr = Figure_Canvas()
# 实例化一个FigureCanvas
dr.test() # 画图
graphicscene = QGraphicsScene(
) # 第三步，创建一个QGraphicsScene，因为加载的图形（FigureCanvas）不能直接放到graphicview
# 控件中，必须先放到graphicScene，然后再把graphicscene放到graphicview中
graphicscene.addWidget(
dr) # 第四步，把图形放到QGraphicsScene中，注意：图形是作为一个QWidget放到QGraphicsScene中的
self.graphicview.setScene(
graphicscene) # 第五步，把QGraphicsScene放入QGraphicsView
self.graphicview.show() # 最后，调用show方法呈现图形！Voila!!
self.setCentralWidget(self.graphicview)
self.graphicview.setFixedSize(800, 600)
def compute(self):
self.listWidget.clear()
if self.comboBox.currentText() == 'xgboost':
lis = self.calc.xgboosting()
figure = self.calc.plot_pred(self.calc.predicts)
scene = QGraphicsScene()
canvas = FigureCanvas(figure)
canvas.setGeometry(0, 0, 650, 650)
scene.addWidget(canvas)
self.graphicsView.setScene(scene)
self.graphicsView.show()
for result_name in lis:
self.listWidget.addItem(result_name)
elif self.comboBox.currentText() == 'naive_bayes':
lis = self.calc.naive_bayes_calc()
figure = self.calc.plot_pred(self.calc.predicts)
scene = QGraphicsScene()
canvas = FigureCanvas(figure)
canvas.setGeometry(0, 0, 650, 650)
scene.addWidget(canvas)
self.graphicsView.setScene(scene)
self.graphicsView.show()
for result_name in lis:
self.listWidget.addItem(result_name)
elif self.comboBox.currentText() == 'kmeans':
figure1, figure2 = self.calc.kmeans_plot()
scene = QGraphicsScene()
canvas = FigureCanvas(figure1)
canvas.setGeometry(0, 0, 650, 650)
scene.addWidget(canvas)
self.graphicsView.setScene(scene)
self.graphicsView.show()
scene = QGraphicsScene()
canvas = FigureCanvas(figure2)
canvas.setGeometry(0, 0, 650, 650)
scene.addWidget(canvas)
self.graphicsView_2.setScene(scene)
self.graphicsView_2.show()
class AIWidget(QWidget):
def __init__(self, reader):
super().__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.reader = reader
self.canvas = AICanvas()
# create a timer to control reading and refreshing
self.timer = QTimer()
self.timer.timeout.connect(self._update_plot)
self.timer.start(1)
# link the canvas to the graphical view
self.scene = QGraphicsScene()
self.scene.addWidget(self.canvas)
self.ui.graphicsView.setScene(self.scene)
self.ui.graphicsView.show()
self.show()
def _update_plot(self):
self.canvas.refresh_data(self.reader.read_one_sample())
class Panel(QGraphicsView):
def __init__(self):
super().__init__()
self.init_fig()
self.canvas = FigureCanvas(self.fig)
self.graphicscene = QGraphicsScene()
self.graphicscene.addWidget(self.canvas)
self.setScene(self.graphicscene)
self.setFixedSize(950, 650)
self.timer = QTimer()
self.timer.timeout.connect(self.handle_timer)
self.timer.setInterval(50)
self.timer.start()
def handle_timer(self):
self.line_target.set_ydata(Y)
self.line_act.set_ydata(Y_)
self.fig.canvas.draw()
def init_fig(self):
self.fig = Figure(figsize=(9, 6), dpi=100)
axes = self.fig.add_subplot(111)
axes.set_ylim(-10, 100)
axes.set_xlim(0, X_LEN)
self.x = np.arange(0, X_LEN)
self.y = np.zeros(X_LEN)
self.line_target, = axes.plot(self.x, self.y, color='C0')
self.x_ = np.arange(0, X_LEN)
self.y_ = np.zeros(X_LEN)
self.line_act, = axes.plot(self.x_, self.y_, color='C3')
class CFG(QGraphicsView):
changeCFG = pyqtSignal(int)
gotoAddress = pyqtSignal(int)
log = pyqtSignal(str)
def __init__(self):
super(CFG, self).__init__()
self.scene = QGraphicsScene(self)
self.setScene(self.scene)
self.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setFocusPolicy(Qt.ClickFocus)
self.mapItems = {}
self.lastAddress = None
self.clickedBlock = None
def wheelEvent(self, event):
modifiers = QApplication.keyboardModifiers()
if modifiers == Qt.ControlModifier:
self.scaleView(pow(2.0, event.angleDelta().y() / 500.0))
else:
super(CFG, self).wheelEvent(event)
def scaleView(self, scaleFactor):
factor = self.transform().scale(scaleFactor, scaleFactor).mapRect(
QRectF(0, 0, 1, 1)).width()
if factor < 0.07 or factor > 100:
return
self.scale(scaleFactor, scaleFactor)
def mousePressEvent(self, event):
self.clickedBlock = None
x = self.mapToScene(event.pos()).x()
y = self.mapToScene(event.pos()).y()
for block in self.mapItems:
if (block.x() <= x) and (x <= block.x() + block.width()) and (
block.y() <= y) and (y <= block.y() + block.height()):
self.clickedBlock = block
break
if self.clickedBlock is not None:
for block in self.mapItems:
if block != self.clickedBlock:
block.clearSelection()
block.clearFocus()
block.clearAllEffect()
else:
block.clearAllEffect()
super(CFG, self).mousePressEvent(event)
def clearAllFocus(self):
for block in self.mapItems:
block.clearSelection()
block.clearFocus()
block.clearAllEffect()
def focusLoc(self, loc):
for block in self.mapItems:
block.clearSelection()
block.clearFocus()
block.clearAllEffect()
for block, view in self.mapItems.items():
if block.lockey == loc:
block.selectionModel().select(block.model.index(0, 0),
QItemSelectionModel.Select)
self.centerOn(view)
def addBlock(self, blockView, x, y):
item = self.scene.addWidget(blockView)
item.setPos(x, y)
item.setFocusPolicy(Qt.ClickFocus)
blockView.highlightText.connect(self.highlightText)
self.mapItems[blockView] = item
def selectAddress(self, address, focus=True, clearEffect=True):
if clearEffect:
self.clearAllFocus()
self.lastAddress = address
for block in self.mapItems:
for i in range(block.model.rowCount()):
line = block.model.item(i, 0)
if not isinstance(line, LocLine):
if line.address == address:
block.selectionModel().select(
block.model.index(i, 0),
QItemSelectionModel.Select)
if focus:
self.centerOn(self.mapItems[block])
return
def mouseDoubleClickEvent(self, event) -> None:
if self.clickedBlock is not None:
line = self.clickedBlock.getLineSelected()
if not isinstance(line, LocLine):
if line.ref:
self.changeCFG.emit(line.ref)
else:
arg = line.args[self.clickedBlock.lastClickIndex]
if isinstance(arg, ExprInt):
num = int(arg.arg)
for func in BinaryAnalysis.funcs:
if func.address == num:
self.changeCFG.emit(func.address)
super(CFG, self).mouseDoubleClickEvent(event)
return
self.gotoAddress.emit(int(arg.arg))
super(CFG, self).mouseDoubleClickEvent(event)
class SchedulerGUI(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent=parent)
self.setupUi(self)
self.schedule = sampleSchedule()
self.activatedColumns = {}
for key in self.schedule.columns:
self.activatedColumns[key] = True
self.lang = 'en'
self.restore_buttons = []
self.restoreAllButton.clicked.connect(self.restoreAllColumns)
self.translateDict = {}
for widget in self.centralwidget.findChildren((QPushButton, QLabel)):
langDict = {}
for l in languages:
langDict[l] = trans(widget.text(), l)
key = widget
self.translateDict[key] = langDict
self.translateWidgets()
self.language0Button.clicked.connect(partial(self.changeLang, 'en'))
self.language1Button.clicked.connect(partial(self.changeLang, 'ru'))
self.language2Button.clicked.connect(partial(self.changeLang, 'de'))
self.drawAlarm = QTimer()
self.drawAlarm.timeout.connect(self.drawAlarmFunc)
self.drawAlarm.start(0.3)
def closeEvent(self, event):
quit()
def resizeEvent(self, event):
self.draw()
def drawAlarmFunc(self):
self.drawAlarm.stop()
self.draw()
def draw(self):
self.scheduleScene = QGraphicsScene()
self.activatedScene = QGraphicsScene()
self.w = self.scheduleView.width()
self.h = Y_SIDE * 24
self.h_a = self.activatedView.height()
self.gridPen = QPen(QtCore.Qt.gray)
for i in range(0, 24):
self.scheduleScene.addLine(0, i * Y_SIDE, self.w, i * Y_SIDE)
self.drawTimeTapes()
cols = self.getActivatedColumns()
if (len(cols) > 0):
self.drawColumns(cols)
self.scheduleView.setScene(self.scheduleScene)
self.activatedView.setScene(self.activatedScene)
def drawTimeTapes(self):
for i in range(0, len(self.schedule.timeTapes)):
self.scheduleScene.addLine(WIDTH_TL * i, 0, WIDTH_TL * i, self.h)
self.activatedScene.addLine(WIDTH_TL * i, 0, WIDTH_TL * i,
self.h_a)
l = QLabel(self.schedule.timeTapes[i].name)
l.move(WIDTH_TL * i, 0)
self.activatedScene.addWidget(l)
for j in range(0, 24):
l = QLabel(self.schedule.timeTapes[i].labels[j])
l.move(WIDTH_TL * i, Y_SIDE * j)
self.scheduleScene.addWidget(l)
def drawColumns(self, cols):
x_offset = WIDTH_TL * len(self.schedule.timeTapes)
act_col_width = (self.w - x_offset) / len(cols)
self.deactivateButtons = []
for i in range(0, len(cols)):
self.scheduleScene.addLine(x_offset + act_col_width * i, 0,
x_offset + act_col_width * i, self.h)
self.activatedScene.addLine(x_offset + act_col_width * i, 0,
x_offset + act_col_width * i, self.h_a)
b = QPushButton(cols[i].name[self.lang])
b.move(x_offset + act_col_width * i, 0)
b.clicked.connect(partial(self.deactivateColumn, cols[i].abr))
b.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
b.resize(act_col_width, self.h_a)
b = self.activatedScene.addWidget(b)
for event in cols[i].events:
self.drawEvent(event, x_offset, act_col_width, i)
def drawEvent(self, event, x_offset, col_width, x_loc):
t0_f = timeStrToFloat(event.t0)
t1_f = timeStrToFloat(event.t1)
length = (t1_f - t0_f) * (self.h / 24)
space = QtCore.QSizeF(col_width, length)
r = QtCore.QRectF(
QtCore.QPointF(x_offset + x_loc * col_width, t0_f * (self.h / 24)),
space)
pen = QtGui.QPen(QtCore.Qt.blue)
brush = QtGui.QBrush(QtCore.Qt.blue)
self.scheduleScene.addRect(r, pen, brush)
font_size = MAX_EVENT_FONT_PT
l_title = QLabel(event.title[self.lang])
l_title.move(x_offset + x_loc * col_width, t0_f * (self.h / 24))
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width()
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height()
while (title_height > length
or title_width > col_width) and font_size > MIN_EVENT_FONT_PT:
font_size -= 2
l_title.setFont(
QtGui.QFont(DEFAULT_EVENT_FONT, font_size, QtGui.QFont.Bold))
title_width = l_title.fontMetrics().boundingRect(
l_title.text()).width()
title_height = l_title.fontMetrics().boundingRect(
l_title.text()).height()
print(font_size, length, title_width, col_width)
'''
l_title = QLabel(event.title[self.lang])
l_title.move(x_offset + x_loc * col_width, t0_f * (self.h/24))
l_time = QLabel(event.t0 + ' - ' + event.t1)
if (length > 2 * LABEL_FONT_PT + 2):
titleFont = QtGui.QFont(LABEL_FONT, LABEL_FONT_PT,
QtGui.QFont.Bold)
l_title.setFont(titleFont)
title_height = l_title.fontMetrics().boundingRect(l_title.text()).height()
timeFont = QtGui.QFont(LABEL_FONT, LABEL_FONT_PT, QtGui.QFont.Bold)
l_time.move(x_offset + i * act_col_width, t0_f * (self.h/24) + title_height + 1)
l_time.setFont(timeFont)
'''
self.scheduleScene.addWidget(l_title)
#self.scheduleScene.addWidget(l_time)
def getActivatedColumns(self):
cols = []
for key in self.schedule.columns:
if self.activatedColumns[key]:
cols.append(self.schedule.columns[key])
cols = sorted(cols, key=lambda x: x.abr)
return cols
def getDeactivatedColumns(self):
cols = []
for key in self.schedule.columns:
if not self.activatedColumns[key]:
cols.append(self.schedule.columns[key])
cols = sorted(cols, key=lambda x: x.abr)
return cols
def deactivateColumn(self, key):
b = QPushButton(RESTORE[self.lang] + ' ' +
self.schedule.columns[key].name[self.lang])
b.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.restoreButtonLayout.insertWidget(-1, b)
b.clicked.connect(partial(self.activateColumn, key, b))
self.restore_buttons.append(b)
self.activatedColumns[key] = False
self.draw()
def activateColumn(self, key, b):
self.activatedColumns[key] = True
self.draw()
b.deleteLater()
self.restore_buttons.remove(b)
def restoreAllColumns(self):
for key in self.activatedColumns:
self.activatedColumns[key] = True
for b in self.restore_buttons:
b.deleteLater()
self.restore_buttons = []
self.draw()
def translateWidgets(self):
for widget in self.centralwidget.findChildren((QPushButton, QLabel)):
try:
widget.setText(self.translateDict[widget][self.lang])
except KeyError:
langDict = {}
for l in languages:
langDict[l] = trans(widget.text(), l)
key = widget
self.translateDict[key] = langDict
widget.setText(self.translateDict[widget][self.lang])
def changeLang(self, lang):
self.lang = lang
self.translateWidgets()
self.drawAlarm.start(1)
class Visualizer(QMainWindow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# 设置窗口标题
self.setWindowTitle('Spectrogram Visualizer')
self.setFixedSize(800, 600)
# Set menus
openFile = QAction(QIcon('open.png'), 'Open', self)
openFile.setShortcut('Ctrl+O')
openFile.setStatusTip('Open File')
openFile.triggered.connect(self.showDialog)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(openFile)
self.layout_widget = LayoutWidget(self)
self.setCentralWidget(self.layout_widget)
# set open button action
self.layout_widget.open_btn.clicked.connect(self.showDialog)
# set filelist addAction
self.layout_widget.filelist.currentItemChanged.connect(
self.on_filelist_change)
#
self.w = self.layout_widget.graphicview.frameGeometry().width(
) / 100 - 0.2
self.h = self.layout_widget.graphicview.frameGeometry().height(
) / 100 - 0.2
self.graphicscene = QGraphicsScene()
self.layout_widget.graphicview.setScene(self.graphicscene)
self.layout_widget.graphicview.show()
def showDialog(self):
fname = QFileDialog.getOpenFileName(self, 'Open file', '.')
print('Reading: ', fname[0])
if fname[0]:
# print on the filepath_edit
self.layout_widget.filepath_edit.setText(fname[0])
# add to the list
self.layout_widget.filelist.addItem(fname[0])
# draw
self.draw_sgram(fname[0])
def on_filelist_change(self, curr, prev):
self.draw_sgram(curr.text())
def draw_sgram(self, fname):
# Perform stft
lin_sgram = get_spectrograms(fname)
#实例化一个FigureCanvas
dr = Figure_Canvas(lin_sgram, width=self.w, height=self.h)
self.graphicscene.addWidget(dr)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(794, 679)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.frame = QtWidgets.QFrame(self.centralwidget)
self.frame.setGeometry(QtCore.QRect(440, 200, 371, 441))
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName("frame")
self.verticalLayoutWidget = QtWidgets.QWidget(self.frame)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(30, 20, 221, 241))
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
self.adjustLabel = QtWidgets.QLabel(self.verticalLayoutWidget)
self.adjustLabel.setAlignment(QtCore.Qt.AlignCenter)
self.adjustLabel.setObjectName("adjustLabel")
self.verticalLayout.addWidget(self.adjustLabel)
self.imageView = QtWidgets.QGraphicsView(self.verticalLayoutWidget)
self.imageView.setStyleSheet(
"border-image: url(:/img/drawing(1).png);")
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.NoBrush)
self.imageView.setBackgroundBrush(brush)
self.imageView.setObjectName("imageView")
self.verticalLayout.addWidget(self.imageView)
self.selectImageButton = QtWidgets.QPushButton(
self.verticalLayoutWidget)
self.selectImageButton.setObjectName("selectImageButton")
self.verticalLayout.addWidget(self.selectImageButton)
self.horizontalScrollBar = QtWidgets.QScrollBar(
self.verticalLayoutWidget)
self.horizontalScrollBar.setOrientation(QtCore.Qt.Horizontal)
self.horizontalScrollBar.setObjectName("horizontalScrollBar")
self.verticalLayout.addWidget(self.horizontalScrollBar)
self.recognizeButton = QtWidgets.QPushButton(self.frame)
self.recognizeButton.setGeometry(QtCore.QRect(30, 270, 121, 41))
self.recognizeButton.setObjectName("recognizeButton")
self.horizontalLayoutWidget = QtWidgets.QWidget(self.frame)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(30, 330, 181, 31))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(
self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.resultLabel = QtWidgets.QLabel(self.horizontalLayoutWidget)
self.resultLabel.setObjectName("resultLabel")
self.horizontalLayout.addWidget(self.resultLabel)
self.resultText = QtWidgets.QLineEdit(self.horizontalLayoutWidget)
self.resultText.setObjectName("resultText")
self.horizontalLayout.addWidget(self.resultText)
self.frame_2 = QtWidgets.QFrame(self.centralwidget)
self.frame_2.setGeometry(QtCore.QRect(30, 210, 371, 341))
self.frame_2.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_2.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.tabWidget = QtWidgets.QTabWidget(self.frame_2)
self.tabWidget.setGeometry(QtCore.QRect(10, 30, 351, 321))
self.tabWidget.setTabPosition(QtWidgets.QTabWidget.North)
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
self.consoleBrowser = QtWidgets.QTextBrowser(self.tab)
self.consoleBrowser.setGeometry(QtCore.QRect(10, 10, 321, 271))
self.consoleBrowser.setObjectName("consoleBrowser")
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.lossView = QtWidgets.QGraphicsView(self.tab_2)
self.lossView.setGeometry(QtCore.QRect(10, 10, 321, 271))
self.lossView.setObjectName("lossView")
self.tabWidget.addTab(self.tab_2, "")
self.tab_3 = QtWidgets.QWidget()
self.tab_3.setObjectName("tab_3")
self.performanceBrowser = QtWidgets.QTextBrowser(self.tab_3)
self.performanceBrowser.setGeometry(QtCore.QRect(10, 10, 321, 271))
self.performanceBrowser.setObjectName("performanceBrowser")
self.tabWidget.addTab(self.tab_3, "")
self.trainResultLabel = QtWidgets.QLabel(self.frame_2)
self.trainResultLabel.setGeometry(QtCore.QRect(20, 10, 101, 16))
self.trainResultLabel.setObjectName("trainResultLabel")
self.frame_3 = QtWidgets.QFrame(self.centralwidget)
self.frame_3.setGeometry(QtCore.QRect(50, 20, 731, 171))
self.frame_3.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_3.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_3.setObjectName("frame_3")
self.gridLayoutWidget = QtWidgets.QWidget(self.frame_3)
self.gridLayoutWidget.setGeometry(QtCore.QRect(14, 20, 641, 103))
self.gridLayoutWidget.setObjectName("gridLayoutWidget")
self.gridLayout = QtWidgets.QGridLayout(self.gridLayoutWidget)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setObjectName("gridLayout")
self.nbLayerBox = QtWidgets.QComboBox(self.gridLayoutWidget)
self.nbLayerBox.setObjectName("nbLayerBox")
self.gridLayout.addWidget(self.nbLayerBox, 2, 1, 1, 1)
self.nbLayer3Text = QtWidgets.QLineEdit(self.gridLayoutWidget)
self.nbLayer3Text.setObjectName("nbLayer3Text")
self.gridLayout.addWidget(self.nbLayer3Text, 2, 3, 1, 1)
self.nbLayer3Label = QtWidgets.QLabel(self.gridLayoutWidget)
self.nbLayer3Label.setObjectName("nbLayer3Label")
self.gridLayout.addWidget(self.nbLayer3Label, 2, 2, 1, 1)
self.nbLayer2Label = QtWidgets.QLabel(self.gridLayoutWidget)
self.nbLayer2Label.setObjectName("nbLayer2Label")
self.gridLayout.addWidget(self.nbLayer2Label, 1, 2, 1, 1)
self.epochText = QtWidgets.QLineEdit(self.gridLayoutWidget)
self.epochText.setObjectName("epochText")
self.gridLayout.addWidget(self.epochText, 1, 1, 1, 1)
self.nbLayerLabel = QtWidgets.QLabel(self.gridLayoutWidget)
self.nbLayerLabel.setObjectName("nbLayerLabel")
self.gridLayout.addWidget(self.nbLayerLabel, 2, 0, 1, 1)
self.dataDirText = QtWidgets.QLineEdit(self.gridLayoutWidget)
self.dataDirText.setObjectName("dataDirText")
self.gridLayout.addWidget(self.dataDirText, 0, 1, 1, 1)
self.nbLayer1Label = QtWidgets.QLabel(self.gridLayoutWidget)
self.nbLayer1Label.setObjectName("nbLayer1Label")
self.gridLayout.addWidget(self.nbLayer1Label, 0, 2, 1, 1)
self.nbLayer1Text = QtWidgets.QLineEdit(self.gridLayoutWidget)
self.nbLayer1Text.setObjectName("nbLayer1Text")
self.gridLayout.addWidget(self.nbLayer1Text, 0, 3, 1, 1)
self.epochLabel = QtWidgets.QLabel(self.gridLayoutWidget)
self.epochLabel.setObjectName("epochLabel")
self.gridLayout.addWidget(self.epochLabel, 1, 0, 1, 1)
self.dataDirLabel = QtWidgets.QLabel(self.gridLayoutWidget)
self.dataDirLabel.setObjectName("dataDirLabel")
self.gridLayout.addWidget(self.dataDirLabel, 0, 0, 1, 1)
self.nbLayer2Text = QtWidgets.QLineEdit(self.gridLayoutWidget)
self.nbLayer2Text.setObjectName("nbLayer2Text")
self.gridLayout.addWidget(self.nbLayer2Text, 1, 3, 1, 1)
self.trainModelButton = QtWidgets.QPushButton(self.frame_3)
self.trainModelButton.setGeometry(QtCore.QRect(240, 130, 92, 23))
self.trainModelButton.setObjectName("trainModelButton")
self.loadModelButton = QtWidgets.QPushButton(self.frame_3)
self.loadModelButton.setGeometry(QtCore.QRect(360, 130, 75, 23))
self.loadModelButton.setObjectName("loadModelButton")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 794, 23))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.actionOpen = QtWidgets.QAction(MainWindow)
self.actionOpen.setObjectName("actionOpen")
self.actionQuit = QtWidgets.QAction(MainWindow)
self.actionQuit.setObjectName("actionQuit")
self.actionQuit_2 = QtWidgets.QAction(MainWindow)
self.actionQuit_2.setObjectName("actionQuit_2")
self.actionHow_to_use = QtWidgets.QAction(MainWindow)
self.actionHow_to_use.setObjectName("actionHow_to_use")
self.actionAbout_us = QtWidgets.QAction(MainWindow)
self.actionAbout_us.setObjectName("actionAbout_us")
self.actionSave_As = QtWidgets.QAction(MainWindow)
self.actionSave_As.setObjectName("actionSave_As")
self.actionQuit_3 = QtWidgets.QAction(MainWindow)
self.actionQuit_3.setObjectName("actionQuit_3")
self.actionUsing_help = QtWidgets.QAction(MainWindow)
self.actionUsing_help.setObjectName("actionUsing_help")
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(
_translate(
"MainWindow",
"Getting started with AI-Identifying squares and circles"))
self.adjustLabel.setText(_translate("MainWindow", "Adjust "))
self.selectImageButton.setText(
_translate("MainWindow", "Select Image..."))
self.recognizeButton.setText(_translate("MainWindow", "Recognize"))
self.resultLabel.setText(_translate("MainWindow",
"Recognition result"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
_translate("MainWindow", "Console"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2),
_translate("MainWindow", "Loss"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3),
_translate("MainWindow", "Performance"))
self.trainResultLabel.setText(
_translate("MainWindow", "Training results"))
self.nbLayer3Label.setText(
_translate("MainWindow", "Number of neurons in 3 layer"))
self.nbLayer2Label.setText(
_translate("MainWindow", "Number of neurons in 2 layer"))
self.nbLayerLabel.setText(_translate("MainWindow",
"Number of layers:"))
self.nbLayer1Label.setText(
_translate("MainWindow", "Number of neurons in 1 layer"))
self.epochLabel.setText(
_translate("MainWindow", "Number of iterations:"))
self.dataDirLabel.setText(
_translate("MainWindow", "Current dataset path:"))
self.trainModelButton.setText(
_translate("MainWindow", "Training model"))
self.loadModelButton.setText(_translate("MainWindow", "Load Model"))
self.actionOpen.setText(_translate("MainWindow", "Open"))
self.actionQuit.setText(_translate("MainWindow", "Save As..."))
self.actionQuit_2.setText(_translate("MainWindow", "Quit"))
self.actionHow_to_use.setText(_translate("MainWindow", "Using help"))
self.actionAbout_us.setText(_translate("MainWindow", "About us"))
self.actionSave_As.setText(_translate("MainWindow", "Save As..."))
self.actionQuit_3.setText(_translate("MainWindow", "Quit"))
self.actionUsing_help.setText(_translate("MainWindow", "Using help"))
# import img_rc
def initialize(self):
self.filename = ""
self.dataDirText.setText("/Dataset/basicshapes")
self.dataDirText.setDisabled(True)
self.selectImageButton.clicked.connect(self.selectImageClicked)
self.trainModelButton.clicked.connect(self.trainModelClicked)
self.recognizeButton.clicked.connect(self.recognizeClicked)
self.loadModelButton.clicked.connect(self.loadModelClicked)
self.nbLayer2Text.setDisabled(True)
self.nbLayer3Text.setDisabled(True)
self.nbLayerBox.addItem('1')
self.nbLayerBox.addItem('2')
self.nbLayerBox.addItem('3')
self.nbLayerBox.currentIndexChanged.connect(
self.nbLayerBoxIndexChanged)
sys.stdout = EmittingStream(textWritten=self.outputWritten)
sys.stderr = EmittingStream(textWritten=self.outputWritten)
dataframe = pd.read_csv('imagePixel.csv')
y = dataframe.iloc[0:200, 0].values
y = np.where(y == 0, 0, 1)
X = dataframe.iloc[0:200, 1:785].values
for i in range(200):
for j in range(784):
X[i][j] = float(X[i][j])
X_std = np.copy(X)
X_std[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std()
X_std[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std()
X_train = np.array(X_std)
self.data_train, self.data_test, self.target_train, self.target_test = train_test_split(
X_train, y, test_size=0.2)
def plotLoss(self):
self.F = MyFigure(width=3, height=2, dpi=100)
x = range(0, self.nn.num_epoch)
self.F.axes.plot(x, self.nn.array_loss, label='loss')
self.F.axes.legend(bbox_to_anchor=(0., 1.02, 1., .102),
loc=0,
ncol=3,
mode="expand",
borderaxespad=0.)
def performance(self):
str_train_accuracy = 'Accuracy of the trainset: {}\n'.format(
self.nn.train_accuracy)
str_train_precision = 'Precision of the trainset: {}\n'.format(
self.nn.train_precision)
str_train = str_train_accuracy + str_train_precision
count_test_error = 0
for data, label in zip(self.data_test, self.target_test):
predict = self.nn.predict(data).tolist()
if not label == round(predict[1][0]):
count_test_error += 1
str_test_error = 'Number of prediction errors in the test set = {}/40\n'.format(
count_test_error)
return str_train + str_test_error
def nbLayerBoxIndexChanged(self):
if self.nbLayerBox.currentText() == "1":
self.nbLayer1Text.setDisabled(False)
self.nbLayer2Text.setDisabled(True)
self.nbLayer3Text.setDisabled(True)
elif self.nbLayerBox.currentText() == "2":
self.nbLayer1Text.setDisabled(False)
self.nbLayer2Text.setDisabled(False)
self.nbLayer3Text.setDisabled(True)
elif self.nbLayerBox.currentText() == "3":
self.nbLayer1Text.setDisabled(False)
self.nbLayer2Text.setDisabled(False)
self.nbLayer3Text.setDisabled(False)
def selectImageClicked(self):
filename, _ = QFileDialog.getOpenFileName(
self, "Sélectionnez les images à reconnaître")
self.filename = filename
print("The path of the selected image:" + self.filename)
self.imageView.setStyleSheet("border-image: url(" + filename + ");")
def trainModelClicked(self):
button = QMessageBox.question(
self, "Reminder",
self.
tr("The training process may take a long time, please wait patiently if the program does not respond"
), QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Ok)
if button == QMessageBox.Ok:
self.trainModel()
elif button == QMessageBox.Cancel:
pass
else:
return
def loadModelClicked(self):
self.loadModel()
def trainModel(self):
# self.textEdit.setText("Training, please wait.")
# self.textEdit.setText("Training, please wait.")
nbLayer1 = int(self.nbLayer1Text.text())
nbLayer2 = 0
nbLayer3 = 0
if self.nbLayer2Text.text() != "":
nbLayer2 = int(self.nbLayer2Text.text())
if self.nbLayer3Text.text() != "":
nbLayer3 = int(self.nbLayer3Text.text())
self.nn = neural_network(self.data_train,
self.target_train,
self.nbLayerBox.currentIndex() + 2,
784,
2,
int(self.epochText.text()),
nbLayer1,
nbLayer2,
nbLayer3,
is_bias=False)
self.nn.learning()
np.set_printoptions(suppress=True, precision=2)
self.plotLoss()
self.scene = QGraphicsScene() # 创建一个场景
self.scene.addWidget(self.F) # 将图形元素添加到场景中
self.lossView.setScene(self.scene) # 将创建添加到图形视图显示窗口
self.performanceBrowser.setText(self.performance())
self.saveModel()
def recognizeClicked(self):
if self.filename == "":
QMessageBox.warning(self, "Warning",
self.tr("You have to choose an image file"))
elif self.filename[-3:] != 'png':
QMessageBox.warning(
self, "Warning",
self.tr("The selected file must be an PNG type"))
else:
self.recognize()
def recognize(self):
if self.filename != "":
img = cv2.imread(self.filename, cv2.IMREAD_GRAYSCALE)
# Picture tags
row_data = []
# Get picture pixels
row_data.extend(img.flatten())
# Write picture data to csv file
predict = self.nn.predict(np.array(row_data)).tolist()
if round(predict[1][0]) == 0:
result = "circle"
elif (round(predict[1][0]) == 1):
result = "square"
print("Prediction Result:" + result)
self.resultText.setText(result)
def outputWritten(self, text):
cursor = self.consoleBrowser.textCursor()
cursor.movePosition(QtGui.QTextCursor.End)
cursor.insertText(text)
self.consoleBrowser.setTextCursor(cursor)
self.consoleBrowser.ensureCursorVisible()
def saveModel(self):
modelName = "model-" + str(self.nn.array_loss[-1])
with open(modelName, "w", newline="") as f:
writer = csv.writer(f)
writer.writerow(str(self.nn.num_layer))
writer.writerow([str(self.nn.nbneuron1)])
writer.writerow([str(self.nn.nbneuron2)])
writer.writerow([str(self.nn.nbneuron3)])
writer.writerow([str(self.nn.array_loss[-1])])
writer.writerow([str(self.nn.train_accuracy)])
writer.writerow([str(self.nn.train_precision)])
for i in range(self.nn.num_layer):
if i == 0:
weight_size = self.nn.input_size
elif i == 1:
weight_size = self.nn.nbneuron1
elif i == 2:
weight_size = self.nn.nbneuron2
elif i == 3:
weight_size = self.nn.nbneuron3
for j in range(weight_size):
writer.writerow(self.nn.weights[i][j].tolist())
print("The stored model file name is " + modelName)
def loadModel(self):
modelPath, _ = QFileDialog.getOpenFileName(self,
"Choose a trained model")
self.modelPath = modelPath
if modelPath != "":
print("The path of the selected model:" + self.modelPath)
f = open(self.modelPath, 'r')
lines = []
for line in f.readlines():
line = line.strip()
lines.append(line)
num_layer = int(lines[0])
nbLayer1 = int(lines[1])
nbLayer2 = int(lines[2])
nbLayer3 = int(lines[3])
self.nbLayerBox.setCurrentIndex(num_layer - 2)
self.nbLayer1Text.setText(lines[1])
if nbLayer2 != 0:
self.nbLayer2Text.setText(lines[2])
self.nbLayer2Text.setDisabled(False)
if nbLayer3 != 0:
self.nbLayer3Text.setText(lines[3])
self.nbLayer3Text.setDisabled(False)
self.nn = neural_network(self.data_train,
self.target_train,
num_layer,
784,
2,
1000,
nbLayer1,
nbLayer2,
nbLayer3,
is_bias=False)
self.nn.array_loss.append(float(lines[4]))
self.nn.train_accuracy = float(lines[5])
self.nn.train_precision = float(lines[6])
self.nn.weights = []
weignts = []
for i in range(7, 791):
poids = []
for j in range(nbLayer1):
poid = float(lines[i].split(',')[j])
poids.append(poid)
weignts.append(poids)
weight_0 = np.array(weignts)
self.nn.weights.append(weight_0)
linestart = 791
lineend = 791 + nbLayer1
if num_layer >= 3:
weignts = []
for i in range(791, 791 + nbLayer1):
poids = []
for j in range(nbLayer2):
poid = float(lines[i].split(',')[j])
poids.append(poid)
weignts.append(poids)
weight_1 = np.array(weignts)
self.nn.weights.append(weight_1)
linestart = 791 + nbLayer1
lineend = linestart + nbLayer2
if num_layer >= 4:
weignts = []
for i in range(791 + nbLayer1, 791 + nbLayer1 + nbLayer2):
poids = []
for j in range(nbLayer3):
poid = float(lines[i].split(',')[j])
poids.append(poid)
weignts.append(poids)
weight_2 = np.array(weignts)
self.nn.weights.append(weight_2)
linestart = 791 + nbLayer1 + nbLayer2
lineend = linestart + nbLayer3
weignts = []
for i in range(linestart, lineend):
poids = []
for j in range(2):
poid = float(lines[i].split(',')[j])
poids.append(poid)
weignts.append(poids)
weight_3 = np.array(weignts)
self.nn.weights.append(weight_3)
print("Loss of this model: {}".format(self.nn.array_loss[-1]))
print(self.performance())
self.performanceBrowser.setText(self.performance())
class Minimap2(QGraphicsView):
'''
Minimap
'''
def __init__(self, parent=0):
'''
Constructor
'''
super(Minimap2, self).__init__(parent)
self._scene = QGraphicsScene()
self.setRenderHint(QPainter.Antialiasing, True)
self._text_browser = TextBrowser()
self._scrollbar = None
self.setAutoFillBackground(True)
# try:
# from PyQt5.QtWidgets import QOpenGLWidget
# self.setViewport(QOpenGLWidget())
# except ImportError: # work around for pyQt 5.2
# from PyQt5.QtOpenGL import QGLWidget
# self.setViewport(QGLWidget())
self.setScene(self._scene)
self.setAlignment(Qt.AlignTop)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# cursor:
self._nav_cursor = Cursor()
self._nav_cursor.graphics_view = self
self._scene.addItem(self._nav_cursor)
self._nav_cursor.setZValue(1)
self._text_edit = None
self._minimap_doc = None
self._doc = None
self._graphics_proxy_text_browser = self._scene.addWidget(
self._text_browser)
self._scale = 0.2
self._graphics_proxy_text_browser.setScale(self._scale)
def update_minimap_doc(self, position, charsRemoved, charsAdded):
def select_blocks(first_block, last_block):
first_block_pos = first_block.position()
doc_cursor.setPosition(first_block_pos)
last_block_pos = last_block.position()
doc_cursor.setPosition(last_block_pos, QTextCursor.KeepAnchor)
doc_cursor.movePosition(
QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
print("selected text :", doc_cursor.selectedText())
return doc_cursor.selectedText()
doc_cursor = QTextCursor(self._doc)
minimap_cursor = QTextCursor(self._minimap_doc)
# IF one same block is modified
if self._minimap_doc.blockCount() == self._doc.blockCount():
doc_cursor.setPosition(position)
doc_cursor.select(QTextCursor.BlockUnderCursor)
minimap_cursor.setPosition(position)
minimap_cursor.select(QTextCursor.BlockUnderCursor)
minimap_cursor.insertFragment(doc_cursor.selection())
# TODO: if the doc is modified on more than one block but resulting in
# the same count of blocks (right now only the first block would be
# updated)
else:
# ELSE
doc_cursor.select(QTextCursor.Document)
minimap_cursor.select(QTextCursor.Document)
minimap_cursor.insertFragment(doc_cursor.selection())
@property
def text_edit(self):
return self._text_edit
@text_edit.setter
def text_edit(self, text_edit):
if not isinstance(text_edit, QTextEdit):
return
self._text_edit = text_edit
# self._text_edit.textChanged.connect(self.update)
# self._scrollbar.valueChanged.connect(self._change_cursor_pos)
self.setFixedWidth(self._text_edit.width() * self._scale)
self._doc = self._text_edit.document()
# connect scrollbar
baseScrollBar = self._text_edit.verticalScrollBar()
baseScrollBar.rangeChanged.connect(self._set_scrollBar_range)
# baseScrollBar.valueChanged.connect(self._text_browser.verticalScrollBar().setValue)
self._text_browser.verticalScrollBar().valueChanged.connect(
baseScrollBar.setValue)
self._text_browser.verticalScrollBar().hide()
# set cursor:
# self._text_browser.verticalScrollBar().valueChanged.connect(self._set_nav_cursor_y)
baseScrollBar.valueChanged.connect(self._set_nav_cursor_y)
self.set_activated(True)
def set_activated(self, value):
if value is True:
self.blockSignals(False)
self._minimap_doc = self._doc.clone(self)
self._text_browser.setDocument(self._minimap_doc)
self._doc.contentsChange.connect(self.update_minimap_doc)
else:
self.blockSignals(True)
try:
self._doc.contentsChange.disconnect(self.update_minimap_doc)
except TypeError:
pass
@pyqtSlot()
def update(self):
# if self._is_cursor_moved:
# return
pass
def _change_scrollbar_value(self, value):
# self._scrollbar.setValue(value)
pass
@pyqtSlot('int')
def _set_nav_cursor_y(self, value):
sc_bar = self._text_edit.verticalScrollBar()
max = sc_bar.maximum()
# print(self._doc.size().height())
if max == 0:
self._nav_cursor.setY(0)
return
ratio = value / max
self._nav_cursor.setY(self._doc.size().height() * self._scale * ratio)
@pyqtSlot('QSize')
def update_size(self, size):
self.setFixedWidth(self._text_edit.width() * self._scale)
def resizeEvent(self, event):
cursor = QTextCursor(self._text_edit.cursorForPosition(QPoint(0, 0)))
# self._graphics_proxy_text_browser.resize(self._scene.sceneRect().size())
self._graphics_proxy_text_browser.setGeometry(QRectF(
0, 0, event.size().width() / self._scale, event.size().height() / self._scale))
self.setSceneRect(0, 0, event.size().width(), event.size().height())
self._nav_cursor.set_width(event.size().width())
# cursor height :
self._nav_cursor.set_height(
(self._text_edit.viewport().height() - 1) * self._scale)
# return QGraphicsView.resizeEvent(self, event)
def _set_scrollBar_range(self, min_, max_):
self._text_browser.verticalScrollBar().setMinimum(min_)
self._text_browser.verticalScrollBar().setMaximum(max_)
if min_ == 0 and max_ == 0:
self._text_browser.verticalScrollBar().hide()
else:
self._text_browser.verticalScrollBar().show()
class GUI(Ui_MainWindow):
def __init__(self):
super().setupUi(MainWindow)
self.initUI()
#connect widgets with functions
def initUI(self):
self.scene1=QGraphicsScene()
self.scene2=QGraphicsScene()
self.scene3=QGraphicsScene()
self.scene4=QGraphicsScene()
self.actionOpen.triggered.connect(self.imageOpen)
self.histogram.clicked.connect(self.imageHistogram)
self.GrayvalueScrollBar.valueChanged.connect(self.sliderval)
self.OTSU.clicked.connect(self.OTSUThreshold)
self.MedianFilter.clicked.connect(self.medianfilter)
self.MeanFilter.clicked.connect(self.meanfilter)
self.GaussianFilter.clicked.connect(self.gaussianfilter)
self.CoustomizedFilter.clicked.connect(self.coustomizefilter)
self.BinaryErosion.clicked.connect(self.binaryerosion)
self.BinaryDilation.clicked.connect(self.binarydilation)
self.actionClear_All.triggered.connect(self.clearall)
self.DistanceTransform.clicked.connect(self.distancetransform)
self.Skeleton.clicked.connect(self.skeleton)
self.SkeletonRestoration.clicked.connect(self.skeletonrestoration)
self.GrayErosion.clicked.connect(self.grayerosion)
self.GrayDilation.clicked.connect(self.graydilation)
self.EdgeDetection.clicked.connect(self.edgedetection)
self.Gradient.clicked.connect(self.gradient)
self.Reconstraction_Binary.clicked.connect(self.reconstruction_binary)
self.Reconstraction_Gray.clicked.connect(self.reconstruction_gray)
#function menubar-file-open: Open image and show it in view1
def imageOpen(self):
# filename,_ = QFileDialog.getOpenFileName(MainWindow,'Open a image',os.getenv('HOME'))
filename,_ = QFileDialog.getOpenFileName(MainWindow,'Open a image','.',"Image Files(*.bmp *jpg *png *jpeg)")
# filename="/home/lab105/git-sen/python_gui/lena512.bmp"
# print(filename)
pix=QtGui.QPixmap(filename)
pix=pix.scaledToHeight(256)
self.image=plt.imread(filename)
Size=self.image.shape
if (len(Size)==3):
if (type(self.image[1,1,1]) is np.float32):
self.image=misc.imread(filename)
self.image=self.image[:,:,1]
self.image_temp=self.image
self.scene1.addPixmap(QPixmap(pix))
self.View1.setScene(self.scene1)
self.clearall()
#function mainwindow tab histogram-greylevel histogram: compute and show the greyvalue histogram in view 2
def imageHistogram(self):
greyimage=self.image
#greyimage.dtype
Height, Width=greyimage.shape
x=np.zeros(Height*Width)
for h in range(Height):
for w in range(Width):
x[h*Height+w]=greyimage[h,w]
num_bins=255
plt.figure(figsize=(256,256),dpi=1)
n,self.bins,patches=plt.hist(x,num_bins,normed=1,facecolor='green',alpha=0.5)
plt.axis("off")
plt.gca().set_position([0,0,1,1])
self.figure=plt.gcf()
canvas2=FigureCanvas(self.figure)
self.scene2.addWidget(canvas2)
self.View2.setScene(self.scene2)
def sliderval(self):
Threshold=self.GrayvalueScrollBar.value()
self.Binarization(Threshold)
# self.label.setText(str(Threshold))
#threshlod function
def Binarization(self,Threshold):
#filename="/home/lab105/git-sen/python_gui/lena512.bmp"
#img=misc.imread(filename)
img=self.image
BinaryArray= img >Threshold
plt.close(3)
plt.figure(num=3,figsize=(256,256),dpi=1)
plt.axis("off")
plt.gca().set_position([0,0,1,1])
plt.imshow(BinaryArray,cmap='binary_r')
figure3=plt.gcf()
canvas3=FigureCanvas(figure3)
self.scene3.clear()
self.scene3.addWidget(canvas3)
self.View3.setScene(self.scene3)
self.label.setText(str(Threshold))
def OTSUThreshold(self):
img=self.image
thresh=threshold_otsu(img)
binary=img > thresh
self.showView4(binary)
def showView4(self,image):
plt.close(4)
plt.figure(num=4,figsize=(256,256),dpi=1)
if (image.max()>1):
plt.imshow(image,cmap='gray')
else:
plt.imshow(image,cmap='binary_r')
plt.gca().set_position([0,0,1,1])
plt.axis("off")
figure4=plt.gcf()
canvas4=FigureCanvas(figure4)
self.scene4.clear()
self.scene4.addWidget(canvas4)
self.View4.setScene(self.scene4)
def getmatrixsize(self):
matrixsize=3
if (self.radioButton_1.isChecked()):
matrixsize=3
if (self.radioButton_2.isChecked()):
matrixsize=5
return matrixsize
def medianfilter(self):
self.image_temp=ndimage.median_filter(self.image_temp,size=int(self.plainTextEdit.toPlainText()))
self.showView4(self.image_temp)
def meanfilter(self):
self.image_temp=ndimage.uniform_filter(self.image_temp,size=int(self.plainTextEdit.toPlainText()))
self.showView4(self.image_temp)
def gaussianfilter(self):
self.image_temp=ndimage.gaussian_filter(self.image_temp,sigma=float(self.plainTextEdit_2.toPlainText()))
self.showView4(self.image_temp)
def getmatrix(self):
self.Matrix=[]
if (self.getmatrixsize()==3):
matrix=np.zeros((3,3))
matrix[0,0]=float(self.plainTextEdit1_1.toPlainText())
matrix[0,1]=float(self.plainTextEdit1_2.toPlainText())
matrix[0,2]=float(self.plainTextEdit1_3.toPlainText())
matrix[1,0]=float(self.plainTextEdit2_1.toPlainText())
matrix[1,1]=float(self.plainTextEdit2_2.toPlainText())
matrix[1,2]=float(self.plainTextEdit2_3.toPlainText())
matrix[2,0]=float(self.plainTextEdit3_1.toPlainText())
matrix[2,1]=float(self.plainTextEdit3_2.toPlainText())
matrix[2,2]=float(self.plainTextEdit3_3.toPlainText())
if (matrix.max()==0):
matrix[:,:]=1
if (self.getmatrixsize()==5):
matrix=np.zeros((5,5))
matrix[0,0]=float(self.plainTextEdit1_1.toPlainText())
matrix[0,1]=float(self.plainTextEdit1_2.toPlainText())
matrix[0,2]=float(self.plainTextEdit1_3.toPlainText())
matrix[0,3]=float(self.plainTextEdit1_4.toPlainText())
matrix[0,4]=float(self.plainTextEdit1_5.toPlainText())
matrix[1,0]=float(self.plainTextEdit2_1.toPlainText())
matrix[1,1]=float(self.plainTextEdit2_2.toPlainText())
matrix[1,2]=float(self.plainTextEdit2_3.toPlainText())
matrix[1,3]=float(self.plainTextEdit2_4.toPlainText())
matrix[1,4]=float(self.plainTextEdit2_5.toPlainText())
matrix[2,0]=float(self.plainTextEdit3_1.toPlainText())
matrix[2,1]=float(self.plainTextEdit3_2.toPlainText())
matrix[2,2]=float(self.plainTextEdit3_3.toPlainText())
matrix[2,3]=float(self.plainTextEdit3_4.toPlainText())
matrix[2,4]=float(self.plainTextEdit3_5.toPlainText())
matrix[3,0]=float(self.plainTextEdit4_1.toPlainText())
matrix[3,1]=float(self.plainTextEdit4_2.toPlainText())
matrix[3,2]=float(self.plainTextEdit4_3.toPlainText())
matrix[3,3]=float(self.plainTextEdit4_4.toPlainText())
matrix[3,4]=float(self.plainTextEdit4_5.toPlainText())
matrix[4,0]=float(self.plainTextEdit5_1.toPlainText())
matrix[4,1]=float(self.plainTextEdit5_2.toPlainText())
matrix[4,2]=float(self.plainTextEdit5_3.toPlainText())
matrix[4,3]=float(self.plainTextEdit5_4.toPlainText())
matrix[4,4]=float(self.plainTextEdit5_5.toPlainText())
if (matrix.max()==0):
matrix[:,:]=1
self.Matrix=matrix
def coustomizefilter(self):
self.getmatrix()
self.image_temp=ndimage.correlate(self.image_temp,self.Matrix)
self.showView4(self.image_temp)
def binaryerosion(self):
self.getmatrix()
self.image_temp=ndimage.binary_erosion(self.image_temp,self.Matrix)
self.showView4(self.image_temp)
def binarydilation(self):
self.getmatrix()
self.image_temp=ndimage.binary_dilation(self.image_temp,self.Matrix)
self.showView4(self.image_temp)
def distancetransform(self):
Size=self.image_temp.shape
distance=np.zeros(Size)
distance=distance+self.image_temp
self.getmatrix()
while (self.image_temp.max()!=0):
self.image_temp=ndimage.binary_erosion(self.image_temp,self.Matrix)
distance=distance+self.image_temp
self.image_temp=self.image
self.showView4(distance)
def clearall(self):
self.scene2.clear()
self.scene3.clear()
self.scene4.clear()
self.image_temp=self.image
def skeleton(self):
Size=self.image_temp.shape
skeleton=np.zeros(Size)
self.store=np.zeros(Size)
skeleton_remain=self.image_temp
i=1
while (skeleton_remain.max()!=0):
skeleton_remain=ndimage.binary_erosion(self.image_temp,np.ones([2*i-1,2*i-1]))
subset=skeleton_remain-ndimage.binary_opening(skeleton_remain,np.ones([3,3]))
skeleton=np.logical_or(skeleton,subset)
self.store=self.store+subset*i
i=i+1
self.showView4(skeleton)
def skeletonrestoration(self):
i=self.store.max()
Size=self.image_temp.shape
result=mid_result=np.zeros(Size)
while (i!=0):
index= self.store == i
mid_result=ndimage.binary_dilation(index,np.ones([2*i-1,2*i-1]))
result=np.logical_or(result,mid_result)
i=i-1
self.showView4(result)
def grayerosion(self):
self.getmatrix()
self.image_temp=ndimage.grey_erosion(self.image_temp,footprint=self.Matrix)
self.showView4(self.image_temp)
def graydilation(self):
self.getmatrix()
self.image_temp=ndimage.grey_dilation(self.image_temp,footprint=self.Matrix)
self.showView4(self.image_temp)
def getEdgeType(self):
Type='S'
if (self.S.isChecked()):
Type='S'
if (self.I.isChecked()):
Type='I'
if (self.E.isChecked()):
Type='E'
return Type
def edgedetection(self):
Type=self.getEdgeType()
Size=self.image_temp.shape
EdgeImage=np.zeros(Size)
if (Type=='S'):
EdgeImage=ndimage.grey_dilation(self.image_temp,footprint=np.ones([3,3]))-ndimage.grey_erosion(self.image_temp,footprint=np.ones([3,3]))
if (Type=='I'):
EdgeImage=self.image_temp-ndimage.grey_erosion(self.image_temp,footprint=np.ones([3,3]))
if (Type=='E'):
EdgeImage=ndimage.grey_dilation(self.image_temp,footprint=np.ones([3,3]))-self.image_temp
self.showView4(EdgeImage)
def gradient(self):
Type=self.getEdgeType()
Size=self.image_temp.shape
EdgeImage=np.zeros(Size)
if (Type=='S'):
EdgeImage=(ndimage.grey_dilation(self.image_temp,footprint=np.ones([3,3]))-ndimage.grey_erosion(self.image_temp,footprint=np.ones([3,3])))/2
if (Type=='I'):
EdgeImage=(self.image_temp-ndimage.grey_erosion(self.image_temp,footprint=np.ones([3,3])))/2
if (Type=='E'):
EdgeImage=(ndimage.grey_dilation(self.image_temp,footprint=np.ones([3,3]))-self.image_temp)/2
self.showView4(EdgeImage)
def reconstruction_binary(self):
Size=self.image_temp.shape
Mark_temp=np.zeros(Size)
Mark=np.zeros(Size)
Mark[:,112]=1
while ((not np.array_equal(Mark,Mark_temp))):
Mark_temp=Mark
Mark=ndimage.binary_dilation(Mark,np.ones([3,3]))
Mark=np.logical_and(Mark,self.image_temp)
self.showView4(Mark)
def reconstruction_gray(self):
Size=self.image_temp.shape
Mark_temp=np.zeros(Size)
Mark=np.zeros(Size)
Mark[:,112]=self.image_temp[:,112]
while ((not np.array_equal(Mark,Mark_temp))):
Mark_temp=Mark
Mark=ndimage.grey_dilation(Mark,footprint=np.ones([3,3]))
logical=Mark >= self.image_temp
Mark=Mark-Mark*logical+self.image_temp*logical
self.showView4(Mark)
