def getNewWindow(cls,
targetImage=None,
axeSize=500,
layer=None,
parent=None,
mainForm=None,
curveType='quadric'):
newWindow = graphicsToneForm(targetImage=targetImage,
axeSize=axeSize,
layer=layer,
parent=parent,
mainForm=mainForm,
curveType=curveType)
newWindow.setWindowTitle(layer.name)
# init marker
triangle = QPolygonF()
s = 10
triangle.append(QPointF(-s, s))
triangle.append(QPointF(0, 0))
triangle.append(QPointF(s, s))
newWindow.inputMarker = QGraphicsPolygonItem(triangle)
newWindow.scene().addItem(newWindow.inputMarker)
newWindow.inputMarker.setBrush(QBrush(Qt.white))
return newWindow
def __init__(self, boxManager):
super().__init__()
# Variables
self.message = ''
self.imageData = None
self.boxes = []
self.drawingRect = None
self.drawing = False
# Objects
self.image = None
self.messageResetTimer = QTimer()
self.brush = QBrush()
self.pen = QPen()
self.font = QFont('Arial', 8)
self.boxManager = boxManager
# Styling
self.setMinimumSize(QSize(850, 725))
self.messageResetTimer.setInterval(3000)
self.messageResetTimer.setSingleShot(True)
# Connections
self.messageResetTimer.timeout.connect(self.resetMessage)
def __init__(self, parent, config):
super(DigitalBarHorizontal, self).__init__(parent)
self.config = config
self.value = config["min"]
self.font = QFont()
self.note_font = QFont()
self.color = QColor(config["color"])
self.red_color = QColor(config["redline_color"])
self.no_color = QColor()
self.no_color.setAlpha(0)
self.brush = QBrush(self.color)
self.red_brush = QBrush(self.red_color)
self.pen = QPen(self.color)
self.red_pen = QPen(self.red_color)
self.no_pen = QPen(self.no_color)
self.font_db = QFontDatabase()
self.font_id = self.font_db.addApplicationFont("fonts/DS-DIGI.TTF")
self.families = self.font_db.applicationFontFamilies(self.font_id)
#print [str(f) for f in self.families] #DS-Digital
self.font = QFont("DS-Digital")
self.note_font = QFont("DS-Digital")
self.title_font = QFont("DS-Digital")
self.color = QColor(config["color"])
self.pen_color = QColor(Qt.black)
self.red_color = QColor(config["redline_color"])
self.brush = QBrush(self.color)
self.brush_bg = QBrush(QColor("#555555"))
self.brush_red = QBrush(self.red_color)
self.brush_red_bg = QBrush(QColor("#73311c"))
self.pen = QPen(self.pen_color)
self.red_pen = QPen(self.red_color)
self.text_pen = QPen(self.color)
self.font.setPixelSize(self.config["font_size"])
self.note_font.setPixelSize(self.config["note_font_size"])
self.pen.setWidth(3)
self.red_pen.setWidth(3)
customPlot.setWindowTitle('Sinc Scatter Demo')
customPlot.legend.setVisible(True)
customPlot.legend.setFont(QFont("Helvetica", 9))
# set locale to english, so we get english decimal separator:
customPlot.setLocale(QLocale(QLocale.English, QLocale.UnitedKingdom))
# add confidence band graphs:
customPlot.addGraph()
pen = QPen()
pen.setStyle(Qt.DotLine)
pen.setWidth(1)
pen.setColor(QColor(180, 180, 180))
customPlot.graph(0).setName("Confidence Band 68%")
customPlot.graph(0).setPen(pen)
customPlot.graph(0).setBrush(QBrush(QColor(255, 50, 30, 20)))
customPlot.addGraph()
customPlot.legend.removeItem(customPlot.legend.itemCount() - 1)
customPlot.graph(1).setPen(pen)
customPlot.graph(0).setChannelFillGraph(customPlot.graph(1))
# add theory curve graph:
customPlot.addGraph()
pen.setStyle(Qt.DashLine)
pen.setWidth(2)
pen.setColor(Qt.red)
customPlot.graph(2).setPen(pen)
customPlot.graph(2).setName("Theory Curve")
# add data point graph:
customPlot.addGraph()
customPlot.graph(3).setPen(QPen(Qt.blue))
customPlot.graph(3).setLineStyle(QCPGraph.lsNone)
def popTableMenu(self, pos):
self.subtitle.cellChanged.disconnect(self.subEdit)
pos = QPoint(pos.x() + 55, pos.y() + 30)
menu = QMenu()
copy = menu.addAction('复制')
paste = menu.addAction('粘贴')
setSpan = menu.addAction('合并')
clrSpan = menu.addAction('拆分')
addSub = menu.addAction('导入字幕')
cutSub = menu.addAction('裁剪字幕')
action = menu.exec_(self.subtitle.mapToGlobal(pos))
selected = self.subtitle.selectionModel().selection().indexes()
yList = [selected[0].row(), selected[-1].row()]
xSet = set()
for i in range(len(selected)):
xSet.add(selected[i].column())
if action == copy:
for x in xSet:
self.clipBoard = []
for y in range(yList[0], yList[1] + 1):
if self.subtitle.item(y, x):
self.clipBoard.append(self.subtitle.item(y, x).text())
else:
self.clipBoard.append('')
break
elif action == paste:
self.subtitle.cellChanged.connect(self.subEdit)
for x in xSet:
for cnt, text in enumerate(self.clipBoard):
self.subtitle.setItem(yList[0] + cnt, x, QTableWidgetItem(text))
self.subtitleDict[x][(yList[0] + cnt) * self.globalInterval] = [self.globalInterval, text]
self.subtitle.cellChanged.disconnect(self.subEdit)
elif action == setSpan:
for x in xSet:
if not self.subtitle.item(yList[0], x):
firstItem = ''
else:
firstItem = self.subtitle.item(yList[0], x).text()
for y in range(yList[0], yList[1] + 1):
self.subtitle.setSpan(y, x, 1, 1)
self.subtitle.setItem(y, x, QTableWidgetItem(firstItem))
self.subtitle.item(y, x).setBackground(QBrush(QColor('#35545d')))
if y * self.globalInterval in self.subtitleDict[x]:
del self.subtitleDict[x][y * self.globalInterval]
for x in xSet:
self.subtitle.setSpan(yList[0], x, yList[1] - yList[0] + 1, 1)
self.setSubtitleDict(yList[0], x, yList[1] - yList[0] + 1, firstItem)
elif action == clrSpan:
for x in xSet:
if not self.subtitle.item(yList[0], x):
firstItem = ''
else:
firstItem = self.subtitle.item(yList[0], x).text()
for cnt, y in enumerate(range(yList[0], yList[1] + 1)):
self.subtitle.setSpan(y, x, 1, 1)
if not cnt:
self.subtitle.setItem(yList[0], x, QTableWidgetItem(firstItem))
if firstItem:
self.subtitle.item(y, x).setBackground(QBrush(QColor('#35545d')))
else:
self.subtitle.item(y, x).setBackground(QBrush(QColor('#232629')))
else:
self.subtitle.setItem(y, x, QTableWidgetItem(''))
self.subtitle.item(y, x).setBackground(QBrush(QColor('#232629')))
self.setSubtitleDict(yList[0], x, yList[1] - yList[0] + 1, firstItem)
break
elif action == addSub:
self.subtitle.cellChanged.connect(self.subEdit)
for x in xSet:
self.addSubtitle(x)
self.subtitle.cellChanged.disconnect(self.subEdit)
elif action == cutSub:
for x in xSet:
start = yList[0] * self.globalInterval
end = yList[1] * self.globalInterval
self.exportSubWindow(start, end, x + 1)
self.subtitle.cellChanged.connect(self.subEdit)
def build_func_tree(self):
""" Build the function target display tree """
self._func_tree.setSortingEnabled(False)
self.model.clear()
self.model.setHorizontalHeaderLabels([
"Function Name",
"File",
"File Offset",
"Order Seen",
"Calling Module",
# "Return Address",
"Targeting Mode",
])
self.model.horizontalHeaderItem(0).setToolTip(
"The name of a fuzzable function")
self.model.horizontalHeaderItem(1).setToolTip(
"The name of the file (if any) the function tried to read")
self.model.horizontalHeaderItem(2).setToolTip(
"The bytes in the file that the program tried to read (if available)"
)
self.model.horizontalHeaderItem(3).setToolTip(
"The order in which the wizard encountered this function")
self.model.horizontalHeaderItem(4).setToolTip(
"Which part of the program called this function. .exe modules are generally the most promising"
)
self.model.horizontalHeaderItem(5).setToolTip(
"How we re-identify whether we're calling this function again")
for index, option in enumerate(self.target_data):
funcname_widget = CheckboxTreeWidgetItem(
self._func_tree, index, "{func_name}".format(**option))
filename_widget = QStandardItem(option.get("source", None))
filename_widget.setEditable(False)
offset_widget = QStandardItem(
"0x{:x} - 0x{:x}".format(option["start"], option["end"]) if (
"end" in option and "start" in option) else None)
offset_widget.setEditable(False)
funcname_widget.setCheckState(
Qt.Checked if option["selected"] else Qt.Unchecked)
funcname_widget.setColumnCount(3)
add = []
hx = []
asc = []
for address in range(0, min(len(option["buffer"]), 16 * 5), 16):
add.append("0x%04X" % address)
hx.append(" ".join("{:02X}".format(c)
for c in option["buffer"][address:address +
16]))
asc.append("".join(
(chr(c) if c in range(31, 127) else ".")
for c in option["buffer"][address:address + 16]))
addr = QStandardItem("\n".join(add))
hexstr = QStandardItem("\n".join(hx))
asciistr = QStandardItem("\n".join(asc))
addr.setEditable(False)
hexstr.setEditable(False)
asciistr.setEditable(False)
addr.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))
hexstr.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))
asciistr.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))
funcname_widget.appendRow([addr, hexstr, asciistr])
idx_widget = QStandardItem(str(index))
idx_widget.setEditable(False)
mod_widget = QStandardItem(str(option.get("called_from", None)))
mod_widget.setEditable(False)
addr_widget = QStandardItem(str(option.get("retAddrOffset", None)))
addr_widget.setEditable(False)
mode_widget = QStandardItem(mode_labels[option.get("mode")])
mode_widget.setData(option.get("mode"), role=Qt.UserRole)
mode_widget.setData(index, role=Qt.UserRole + 1)
mode_widget.setData(QBrush(QColor(0, 0, 0, 16)),
role=Qt.BackgroundRole)
self.model.appendRow([
funcname_widget,
filename_widget,
offset_widget,
idx_widget,
mod_widget,
# addr_widget,
mode_widget,
])
# self._func_tree.edit(self.model.indexFromItem(mode_widget))
self._func_tree.expandAll()
self._func_tree.resizeColumnToContents(0)
self._func_tree.resizeColumnToContents(1)
self._func_tree.resizeColumnToContents(2)
self._func_tree.resizeColumnToContents(3)
self._func_tree.sortByColumn(3, Qt.AscendingOrder)
self._func_tree.setSortingEnabled(True)
def paint(self, painter, styleoptions, parent=None):
brush = QBrush()
brush.setColor(self.color)
painter.setBrush(self.color)
painter.drawRect(self._bounding_rect)
def handle_packet(self, packet, writer):
"""
处理抓到的数据包
:parma packet: 需要处理分类的包
"""
unkown = False
try:
# 如果暂停，则不对列表进行更新操作
if not self.pause_flag and packet.name == "Ethernet":
protocol = None
if self.packet_id == 1:
self.start_timestamp = packet.time
packet_time = packet.time - self.start_timestamp
# 网络层
net = packet.payload
network_layer = net.name
version_add = ""
# IPv4
if network_layer == "IP":
source = packet[IP].src
destination = packet[IP].dst
self.counter["ipv4"] += 1
# IPv6
elif network_layer == "IPv6":
source = packet[IPv6].src
destination = packet[IPv6].dst
version_add = "v6"
self.counter["ipv6"] += 1
# ARP
elif network_layer == "ARP":
self.counter["arp"] += 1
protocol = network_layer
source = packet[Ether].src
destination = packet[Ether].dst
if destination == "ff:ff:ff:ff:ff:ff":
destination = "Broadcast"
else:
try:
protocol = network_layer
unkown = True
except:
# 其他协议不处理
return
if network_layer != "ARP" and not unkown:
# 传输层
trans = net.payload
protocol = trans.name
sport = None
dport = None
if protocol == "TCP":
sport = packet[TCP].sport
dport = packet[TCP].dport
protocol += version_add
self.counter["tcp"] += 1
elif protocol == "UDP":
sport = packet[UDP].sport
dport = packet[UDP].dport
protocol += version_add
self.counter["udp"] += 1
elif len(protocol) >= 4 and protocol[0:4] == "ICMP":
protocol = "ICMP" + version_add
self.counter["icmp"] += 1
else:
return
if trans.haslayer(HTTPRequest) or trans.haslayer(
HTTPResponse):
protocol = "HTTP" + version_add
elif trans.haslayer(TLS):
protocol = https_version[trans[TLS].version]
if sport and dport:
if sport in ports:
protocol = ports[sport] + version_add
elif dport in ports:
protocol = ports[dport] + version_add
item = QTreeWidgetItem(self.main_window.packet_tree)
# 根据协议类型不同设置颜色
try:
color = color_dict[protocol]
except:
color = "#ff80c0"
for i in range(7):
item.setBackground(i, QBrush(QColor(color)))
# 添加行内容
item.setData(0, Qt.DisplayRole, self.packet_id)
item.setText(1, f"{packet_time:.6f}")
item.setText(2, source)
item.setText(3, destination)
item.setText(4, protocol)
item.setData(5, Qt.DisplayRole, len(packet))
item.setText(6, packet.summary())
# 时间栏右对齐，为了格式化后不影响排序
# item.setTextAlignment(1, Qt.AlignRight)
self.packet_id += 1
if writer:
writer.write(packet)
except:
pass
def testQColor(self):
#QGraphicsAbstractShapeItem.setBrush(QColor)
self.item.setBrush(self.color)
self.assertEqual(QBrush(self.color), self.item.brush())
def _updateAll(self, newGroup=None):
try:
self.chSelector.itemChanged.disconnect(self.itemChanged)
self.sSelector.itemChanged.disconnect(self.itemChanged)
except:
pass
if newGroup == '':
return
chStruct = self.chartData[newGroup]
sStruct = self.chartData[newGroup].getColStructure()
self.chSelector.clear()
for ws in chStruct:
gparent = QTreeWidgetItem(self.chSelector)
gparent.setText(0, ws)
gparent.setBackgroundColor(0, Qt.white)
gparent.setFlags(Qt.ItemIsEnabled)
for key in chStruct[ws]:
parent = QTreeWidgetItem(gparent)
parent.setText(0, key)
if chStruct[ws][key][0] == True:
dataNames = chStruct[ws][key][3]
sColor = QColor(chStruct[ws][key][4])
sColor.setAlpha(100)
parent.setBackgroundColor(0, sColor)
else:
dataNames = ','.join(chStruct[ws][key][2])
sColor = QColor(chStruct[ws][key][3])
sColor.setAlpha(100)
parent.setBackgroundColor(0, sColor)
parent.setText(1, dataNames)
if chStruct[ws][key][1] == True:
parent.setCheckState(0, Qt.Checked)
else:
parent.setCheckState(0, Qt.Unchecked)
parent.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
self.sSelector.clear()
self.gSelector.clear()
for ws in sStruct:
firstChannel = sStruct[ws][0]
isOneSignal = self.chartData[newGroup][firstChannel][ws][0]
if isOneSignal:
gparent = QTreeWidgetItem(self.sSelector)
gparent.setText(0, ws)
gparent.setFlags(Qt.ItemIsEnabled | Qt.ItemIsDragEnabled
| Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
if True:
## if chStruct['CH1'][ws][5] == True:
gparent.setCheckState(0, Qt.Checked)
else:
gparent.setCheckState(0, Qt.Unchecked)
for key in sStruct[ws]:
parent = QTreeWidgetItem(gparent)
parent.setText(0, key)
if chStruct[key][ws][2] == True:
parent.setCheckState(0, Qt.Checked)
else:
parent.setCheckState(0, Qt.Unchecked)
parent.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
sColor = QColor(chStruct[key][ws][4])
sColor.setAlpha(100)
sGradient = QLinearGradient(0, 0, 100, 10)
sGradient.setColorAt(0, sColor)
sGradient.setColorAt(1, Qt.white)
sBrush = QBrush(sGradient)
sBrush.setStyle(Qt.LinearGradientPattern)
sBrush.setColor(sColor)
gparent.setBackground(0, sBrush)
else:
gparent = QTreeWidgetItem(self.gSelector)
gparent.setText(0, ws)
gparent.setFlags(Qt.ItemIsEnabled | Qt.ItemIsDropEnabled
| Qt.ItemIsUserCheckable)
if chStruct['CH1'][ws][5] == True:
gparent.setCheckState(0, Qt.Checked)
else:
gparent.setCheckState(0, Qt.Unchecked)
signalNames = chStruct[key][ws][2]
sColor = QColor(chStruct[key][ws][3])
sColor.setAlpha(100)
gparent.setBackgroundColor(0, sColor)
for signal in signalNames:
parent = QTreeWidgetItem(gparent)
parent.setText(0, signal)
parent.setFlags(Qt.ItemIsEnabled)
for key in sStruct[signal]:
sColor = QColor(chStruct[key][signal][4])
sColor.setAlpha(100)
parent.setBackgroundColor(0, sColor)
break
self.chSelector.itemChanged.connect(self.itemChanged)
self.sSelector.itemChanged.connect(self.itemChanged)
self.curSelect = None
def update_xsd_files_information(self):
'''
update 函数直接与vs类关联，得到所有的文件类，这样只用update就能更新最新
:return:
'''
if self.vsp == None:
QMessageBox.information(self.main_window, "提示", "没有加载项目，无法获得xsd文件")
return
self.xsd_files_item = []
try:
filenames = list(self.vsp.relative_path_XVI_dict.keys())
filenames = sorted(filenames)
tw = self.main_window_ui.xsdFileTreeWidget
index = 0
tw.clear()
# TODO :这里让用户自选显示的顺序和内容
tw.setHeaderLabels(self.xsd_file_headers)
tw.setColumnCount(len(self.xsd_file_headers))
file_name_item_dict = {}
root = QTreeWidgetItem(tw)
root.setText(0, self.vsp.local_project_dir)
for file in filenames:
l = [root]
trees = file.split("/")[1:] # 第一个元素是“”，是root
# 按照文件目录树进行，如果能够获取到子集就开始增加内容，否则增加child
for i in range(len(trees) + 1): # 对于剩下的child
node_name = "/".join(trees[:i])
try: # 尝试找到这个node，如果没有就创建
node = file_name_item_dict[node_name]
except:
# 创建child node，加入到字典中
node = QTreeWidgetItem(l[-1])
index += 1
node.setText(0, node_name.split("/")[-1])
file_name_item_dict[node_name] = node
try:
# 这里面的每个显示都是直接从xvi信息中获取，然后设置
# 这里如果node能够获取到文件，就开始加上文件信息，否则就是空的只作为有内容的node的parent
xvi_item = self.vsp.relative_path_XVI_dict[
"/" + node_name]
for i in range(len(self.xsd_file_contents)):
#if getattr(xvi_item,"type","") == "":xvi_item.type = Type.Origin
node.setText(
i + 1,
getattr(xvi_item,
self.xsd_file_contents[i], "None"))
if self.xsd_file_contents[i] == "status":
# 这些set使用index进行的，所以先判断是不是在相应的列，也可改成名称为key，value为index
node.setBackground(
i + 1,
QBrush(STATUS_COLOR[xvi_item.status]))
if self.xsd_file_contents[i] == "type":
try:
node.setBackground(
i + 1,
QBrush(Type_Color[xvi_item.type]))
except: # 这个是应对之前没有这个attr的项目，之后可以删除此
node.setBackground(
i + 1,
QBrush(Type_Color[Type.Origin]))
if self.xsd_file_contents[i] == "mark_text":
node.setText(
i + 1,
getattr(xvi_item,
self.xsd_file_contents[i],
"None"))
try:
node.setBackground(
i + 1,
QBrush(QColor(
xvi_item.mark_color)))
except:
traceback.print_exc()
node.setBackground(
i + 1,
QBrush(QColor(255, 255, 255)))
node.file_path = "/" + node_name # 这里强行给这个实例增加了属性，之后直接调用，这里相当于继承
self.xsd_files_item.append(node)
except KeyError:
pass
except:
traceback.print_exc()
l.append(node)
l[-2].addChild(l[-1])
def load_column_status():
# 这里设置列的长度，首先用一个变量去存储这些列，存储在save project中
try:
info = self.vsp.xsd_tree_widget_param["column_status"]
for i in range(tw.columnCount()):
tw.setColumnWidth(i, info[i])
except:
return
load_column_status()
# 把node的信息存储一下！用于接下来搞node的扩展
self.tree_node_widget_item_info = file_name_item_dict
# 这里我们用一个与tree node widget 。。key一模一样的字典去存储node的expand信息，之后
# 用这个key去获取node以及node的expand信息然后修改！
def expand(): # 存储各个列的expand情况
try:
info = self.vsp.xsd_tree_widget_param["expanded_status"]
tw.expandAll()
for key in self.tree_node_widget_item_info.keys():
try:
self.tree_node_widget_item_info[key].setExpanded(
info[key])
except:
continue
except:
pass
expand()
print(tw.rootIndex())
return
except:
QMessageBox.information(self.main_window, "提示", "No xsd files.")
traceback.print_exc()
return
def createRoundRect(self, scene):
item = RoundRectItem(10, 10, 100, 100)
item.setBrush(QBrush(QColor(255, 0, 0)))
scene.addItem(item)
return item
def _subscribe_select_ins(self, **kwargs): # pylint: disable=unused-argument
if self.poi_trace.am_none:
return
if self.mark is not None:
for i in self.mark.childItems():
self.mark.removeFromGroup(i)
self.traceScene.removeItem(i)
self.traceScene.removeItem(self.mark)
self.mark = QGraphicsItemGroup()
self.traceScene.addItem(self.mark)
if self.selected_ins:
addr = next(iter(self.selected_ins))
positions = self.poi_trace.get_positions(addr)
if positions: #if addr is in list of positions
# handle case where insn was selected from disas view
if not self._use_precise_position:
self.curr_position = positions[0] - self.poi_trace.count
for p in positions:
color = self._get_mark_color(p, self.poi_trace.count)
y = self._get_mark_y(p)
if p == self.poi_trace.count + self.curr_position: #add thicker line for 'current' mark
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT*4,
QPen(QColor('black')), QBrush(color)))
else:
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT, QPen(color), QBrush(color)))
self.traceScene.update() #force redraw of the traceScene
self.scroll_to_position(self.curr_position)
def paintEvent(self, arg__1: PySide2.QtGui.QPaintEvent):
"""
PaintEvent draws the contents of this QFrame when called upon
:param arg__1: the QPaintEvent object that the framework provides
:return: None
"""
painter = QPainter(self)
# The QPaintEvent includes a rectangle (x, y, width, height) that tells us the area we need to draw
start_drawing_x = arg__1.rect().x()
stop_drawing_x = start_drawing_x + arg__1.rect().width()
# We have to paint the area from start_drawing_x until stop_drawing_x
# The painter uses the pen to draw the rectangle outline
painter.setPen(QPen(self.__rectangleOutlineColor, 0, Qt.NoPen))
# The painter uses the brush to fill the rectangle
painter.setBrush(QBrush(self.getAlignmentInfo().getColor()))
pixels_per_nucleotide = (
float(self.width()) /
float(self.getAlignmentInfo().getSeqPaddedLen()))
for shaded_area in self.getAlignmentInfo().getShadedAreas():
# It loops over every shaded area
# For this shaded area we should shade starting from index nucleotide_start for a width of nucleotide_width
# These are measured in nucleotides
nucleotide_start = shaded_area[0]
nucleotide_width = shaded_area[1]
logging.debug("Processing shaded area " + str(nucleotide_start) +
":" + str(nucleotide_width))
# The relative_start, _width, _end are measured in pixels
relative_start = nucleotide_start * pixels_per_nucleotide
relative_width = nucleotide_width * pixels_per_nucleotide
relative_end = relative_start + relative_width
# If the rectangle is completely to the left of the area to be painted, just skip to the next one
if relative_start < start_drawing_x and relative_end < start_drawing_x:
logging.debug("Not drawing because " + str(relative_start) +
" - " + str(relative_end) +
" is to the left of the visible area")
continue
# Elif the rectangle is completely to the right of the area to be painted, we're done
elif relative_start > stop_drawing_x and relative_end > stop_drawing_x:
logging.debug("Not drawing because " + str(relative_start) +
" - " + str(relative_end) +
" is to the right of the visible area")
break
else:
logging.debug("Drawing " + str(relative_start) + " - " +
str(relative_end) +
" because it's in the visible area")
# Start drawing from the greater of the start of the rectangle, or the start of the visible area
relative_start = max(relative_start, start_drawing_x)
# Stop drawing at the lesser of the end of the rectangle, or the end of the visible area
relative_end = min(relative_end, stop_drawing_x)
# Adjust the width (in case start/end changed above)
relative_width = relative_end - relative_start
painter.drawRect(relative_start, 0, relative_width,
self.height())
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(799, 408)
icon = QIcon()
icon.addFile(u":/newPrefix/cup.png", QSize(), QIcon.Normal, QIcon.Off)
MainWindow.setWindowIcon(icon)
MainWindow.setStyleSheet(
u"QMainWindow{background: url(:/backgrouns/backgrouns/colorful-paint-splash-hd-wallpapers-66011-1930804.png)}"
)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.centralwidget.setMinimumSize(QSize(100, 357))
self.centralwidget.setMaximumSize(QSize(800, 357))
palette = QPalette()
brush = QBrush(QColor(255, 255, 255, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.WindowText, brush)
brush1 = QBrush(QColor(37, 42, 86, 255))
brush1.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Button, brush1)
brush2 = QBrush(QColor(55, 63, 129, 255))
brush2.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Light, brush2)
brush3 = QBrush(QColor(46, 52, 107, 255))
brush3.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Midlight, brush3)
brush4 = QBrush(QColor(18, 21, 43, 255))
brush4.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Dark, brush4)
brush5 = QBrush(QColor(24, 28, 57, 255))
brush5.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Mid, brush5)
palette.setBrush(QPalette.Active, QPalette.Text, brush)
palette.setBrush(QPalette.Active, QPalette.BrightText, brush)
palette.setBrush(QPalette.Active, QPalette.ButtonText, brush)
brush6 = QBrush(QColor(0, 0, 0, 255))
brush6.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Base, brush6)
palette.setBrush(QPalette.Active, QPalette.Window, brush1)
palette.setBrush(QPalette.Active, QPalette.Shadow, brush6)
palette.setBrush(QPalette.Active, QPalette.AlternateBase, brush4)
brush7 = QBrush(QColor(255, 255, 220, 255))
brush7.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.ToolTipBase, brush7)
palette.setBrush(QPalette.Active, QPalette.ToolTipText, brush6)
brush8 = QBrush(QColor(255, 255, 255, 128))
brush8.setStyle(Qt.SolidPattern)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
palette.setBrush(QPalette.Inactive, QPalette.WindowText, brush)
palette.setBrush(QPalette.Inactive, QPalette.Button, brush1)
palette.setBrush(QPalette.Inactive, QPalette.Light, brush2)
palette.setBrush(QPalette.Inactive, QPalette.Midlight, brush3)
palette.setBrush(QPalette.Inactive, QPalette.Dark, brush4)
palette.setBrush(QPalette.Inactive, QPalette.Mid, brush5)
palette.setBrush(QPalette.Inactive, QPalette.Text, brush)
palette.setBrush(QPalette.Inactive, QPalette.BrightText, brush)
palette.setBrush(QPalette.Inactive, QPalette.ButtonText, brush)
palette.setBrush(QPalette.Inactive, QPalette.Base, brush6)
palette.setBrush(QPalette.Inactive, QPalette.Window, brush1)
palette.setBrush(QPalette.Inactive, QPalette.Shadow, brush6)
palette.setBrush(QPalette.Inactive, QPalette.AlternateBase, brush4)
palette.setBrush(QPalette.Inactive, QPalette.ToolTipBase, brush7)
palette.setBrush(QPalette.Inactive, QPalette.ToolTipText, brush6)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
palette.setBrush(QPalette.Disabled, QPalette.WindowText, brush4)
palette.setBrush(QPalette.Disabled, QPalette.Button, brush1)
palette.setBrush(QPalette.Disabled, QPalette.Light, brush2)
palette.setBrush(QPalette.Disabled, QPalette.Midlight, brush3)
palette.setBrush(QPalette.Disabled, QPalette.Dark, brush4)
palette.setBrush(QPalette.Disabled, QPalette.Mid, brush5)
palette.setBrush(QPalette.Disabled, QPalette.Text, brush4)
palette.setBrush(QPalette.Disabled, QPalette.BrightText, brush)
palette.setBrush(QPalette.Disabled, QPalette.ButtonText, brush4)
palette.setBrush(QPalette.Disabled, QPalette.Base, brush1)
palette.setBrush(QPalette.Disabled, QPalette.Window, brush1)
palette.setBrush(QPalette.Disabled, QPalette.Shadow, brush6)
palette.setBrush(QPalette.Disabled, QPalette.AlternateBase, brush1)
palette.setBrush(QPalette.Disabled, QPalette.ToolTipBase, brush7)
palette.setBrush(QPalette.Disabled, QPalette.ToolTipText, brush6)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
self.centralwidget.setPalette(palette)
self.centralwidget.setAutoFillBackground(False)
self.centralwidget.setStyleSheet(
u"centralwidget{background: url(:/backgrouns/wallpaper.jpg)}")
self.horizontalLayoutWidget = QWidget(self.centralwidget)
self.horizontalLayoutWidget.setObjectName(u"horizontalLayoutWidget")
self.horizontalLayoutWidget.setGeometry(QRect(10, 0, 781, 351))
self.horizontalLayout = QHBoxLayout(self.horizontalLayoutWidget)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setObjectName(u"verticalLayout")
self.groupBox = QGroupBox(self.horizontalLayoutWidget)
self.groupBox.setObjectName(u"groupBox")
self.groupBox.setMinimumSize(QSize(375, 0))
self.groupBox.setAutoFillBackground(False)
self.groupBox.setStyleSheet(
u"QGroupBox{background: url(:/backgrouns/Abstract_Background_with_Blue_Triangles.jpg)}"
)
self.groupBox.setFlat(False)
self.scalePortList = QComboBox(self.groupBox)
self.scalePortList.setObjectName(u"scalePortList")
self.scalePortList.setGeometry(QRect(20, 61, 111, 21))
self.pumpPortList = QComboBox(self.groupBox)
self.pumpPortList.setObjectName(u"pumpPortList")
self.pumpPortList.setGeometry(QRect(190, 61, 121, 21))
self.pumpPortList.setAutoFillBackground(True)
self.label = QLabel(self.groupBox)
self.label.setObjectName(u"label")
self.label.setGeometry(QRect(20, 30, 81, 21))
font = QFont()
font.setPointSize(10)
self.label.setFont(font)
self.label_2 = QLabel(self.groupBox)
self.label_2.setObjectName(u"label_2")
self.label_2.setGeometry(QRect(230, 30, 81, 21))
self.label_2.setFont(font)
self.label_2.setStyleSheet(u"")
self.verticalLayout.addWidget(self.groupBox)
self.groupBox_2 = QGroupBox(self.horizontalLayoutWidget)
self.groupBox_2.setObjectName(u"groupBox_2")
self.groupBox_2.setAutoFillBackground(False)
self.groupBox_2.setStyleSheet(
u"QGroupBox{background:url(:/backgrouns/fractalvisual.jpg)}")
self.groupBox_2.setFlat(False)
self.expStart = QPushButton(self.groupBox_2)
self.expStart.setObjectName(u"expStart")
self.expStart.setGeometry(QRect(250, 70, 91, 31))
icon1 = QIcon()
icon1.addFile(u":/newPrefix/resultset_next.png", QSize(), QIcon.Normal,
QIcon.Off)
self.expStart.setIcon(icon1)
self.expStart.setCheckable(True)
self.weightBox = QLineEdit(self.groupBox_2)
self.weightBox.setObjectName(u"weightBox")
self.weightBox.setGeometry(QRect(210, 30, 113, 22))
self.stopButton = QPushButton(self.groupBox_2)
self.stopButton.setObjectName(u"stopButton")
self.stopButton.setEnabled(False)
self.stopButton.setGeometry(QRect(190, 70, 51, 31))
icon2 = QIcon()
icon2.addFile(u":/newPrefix/stop.png", QSize(), QIcon.Normal,
QIcon.Off)
self.stopButton.setIcon(icon2)
self.label_3 = QLabel(self.groupBox_2)
self.label_3.setObjectName(u"label_3")
self.label_3.setGeometry(QRect(120, 30, 91, 21))
palette1 = QPalette()
brush9 = QBrush(QColor(193, 177, 55, 255))
brush9.setStyle(Qt.SolidPattern)
palette1.setBrush(QPalette.Active, QPalette.WindowText, brush9)
brush10 = QBrush(QColor(168, 162, 90, 255))
brush10.setStyle(Qt.SolidPattern)
palette1.setBrush(QPalette.Active, QPalette.Text, brush10)
brush11 = QBrush(QColor(189, 177, 47, 255))
brush11.setStyle(Qt.SolidPattern)
palette1.setBrush(QPalette.Active, QPalette.ToolTipText, brush11)
brush12 = QBrush(QColor(168, 162, 90, 128))
brush12.setStyle(Qt.SolidPattern)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
palette1.setBrush(QPalette.Inactive, QPalette.WindowText, brush9)
palette1.setBrush(QPalette.Inactive, QPalette.Text, brush10)
palette1.setBrush(QPalette.Inactive, QPalette.ToolTipText, brush11)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
brush13 = QBrush(QColor(120, 120, 120, 255))
brush13.setStyle(Qt.SolidPattern)
palette1.setBrush(QPalette.Disabled, QPalette.WindowText, brush13)
palette1.setBrush(QPalette.Disabled, QPalette.Text, brush13)
palette1.setBrush(QPalette.Disabled, QPalette.ToolTipText, brush11)
brush14 = QBrush(QColor(0, 0, 0, 128))
brush14.setStyle(Qt.SolidPattern)
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
#endif
self.label_3.setPalette(palette1)
self.label_3.setFont(font)
self.verticalLayout.addWidget(self.groupBox_2)
self.horizontalLayout.addLayout(self.verticalLayout)
self.verticalLayout_3 = QVBoxLayout()
self.verticalLayout_3.setSpacing(26)
self.verticalLayout_3.setObjectName(u"verticalLayout_3")
self.resultBox = QPlainTextEdit(self.horizontalLayoutWidget)
self.resultBox.setObjectName(u"resultBox")
self.resultBox.setMaximumSize(QSize(400, 400))
self.resultBox.setReadOnly(True)
self.verticalLayout_3.addWidget(self.resultBox)
self.progressBar = QProgressBar(self.horizontalLayoutWidget)
self.progressBar.setObjectName(u"progressBar")
self.progressBar.setMaximumSize(QSize(400, 16777215))
self.progressBar.setValue(24)
self.verticalLayout_3.addWidget(self.progressBar)
self.horizontalLayout.addLayout(self.verticalLayout_3)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setObjectName(u"menubar")
self.menubar.setGeometry(QRect(0, 0, 799, 26))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(u"statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.expStart.toggled.connect(self.stopButton.setEnabled)
self.stopButton.clicked.connect(self.expStart.setEnabled)
self.expStart.toggled.connect(self.expStart.setDisabled)
self.stopButton.clicked.connect(self.expStart.setChecked)
QMetaObject.connectSlotsByName(MainWindow)
def data_background(self, row, column):
if column == 3:
if self._data[row][self.COL_UNRECONCILED] > 15:
return QBrush(CustomColor.LightRed)
if self._data[row][self.COL_UNRECONCILED] > 7:
return QBrush(CustomColor.LightYellow)
def __init__(self, *args, **kwargs):
super(ExchangeSpiderUI, self).__init__(*args, **kwargs)
layout = QVBoxLayout()
layout.setContentsMargins(QMargins(2, 0, 2, 1))
main_splitter = QSplitter(self)
main_splitter.setHandleWidth(1)
self.tree_widget = ExchangeLibTree(self)
main_splitter.addWidget(self.tree_widget)
action_splitter = QSplitter(Qt.Vertical, self)
action_splitter.setHandleWidth(1)
spider_widget = QWidget(self)
spider_widget.setAutoFillBackground(True)
palette = QPalette()
pix = QPixmap("images/spider_bg.png")
pix = pix.scaled(QSize(700, 700), Qt.KeepAspectRatio)
palette.setBrush(QPalette.Background, QBrush(pix))
spider_widget.setPalette(palette)
spider_layout = QVBoxLayout()
tips_layout = QHBoxLayout()
tips_layout.setSpacing(1)
tips_layout.addWidget(QLabel("当前交易所:", self))
self.spider_exchange_button = QPushButton("未选择", self)
tips_layout.addWidget(self.spider_exchange_button)
tips_layout.addWidget(QLabel(self))
tips_layout.addWidget(QLabel("当前操作:", self))
self.spider_action_button = QPushButton("未选择", self)
tips_layout.addWidget(self.spider_action_button)
tips_layout.addWidget(QLabel(self))
tips_layout.addWidget(QLabel("选择日期:", self))
self.spider_date_edit = QDateEdit(QDate.currentDate(), self)
self.spider_date_edit.setCalendarPopup(True)
self.spider_date_edit.setDisplayFormat("yyyy-MM-dd")
tips_layout.addWidget(self.spider_date_edit)
tips_layout.addWidget(QLabel(self))
self.spider_start_button = QPushButton("开始", self)
tips_layout.addWidget(self.spider_start_button)
tips_layout.addStretch()
spider_layout.addLayout(tips_layout)
self.spider_status = QLabel("等待开始抓取", self)
self.spider_status.setWordWrap(True)
self.spider_status.setAlignment(Qt.AlignCenter)
spider_layout.addWidget(self.spider_status)
spider_widget.setLayout(spider_layout)
action_splitter.addWidget(spider_widget)
# 解析部分
parser_widget = QWidget(self)
parser_widget.setAutoFillBackground(True)
palette = QPalette()
pix = QPixmap("images/parser_bg.png")
pix = pix.scaled(QSize(700, 700), Qt.KeepAspectRatio)
palette.setBrush(QPalette.Background, QBrush(pix))
parser_widget.setPalette(palette)
parser_layout = QVBoxLayout()
tips_layout = QHBoxLayout()
tips_layout.setSpacing(1)
tips_layout.addWidget(QLabel("当前交易所:", self))
self.parser_exchange_button = QPushButton("未选择", self)
tips_layout.addWidget(self.parser_exchange_button)
tips_layout.addWidget(QLabel(self))
tips_layout.addWidget(QLabel("当前操作:", self))
self.parser_action_button = QPushButton("未选择", self)
tips_layout.addWidget(self.parser_action_button)
tips_layout.addWidget(QLabel(self))
tips_layout.addWidget(QLabel("选择日期:", self))
self.parser_date_edit = QDateEdit(QDate.currentDate(), self)
self.parser_date_edit.setCalendarPopup(True)
self.parser_date_edit.setDisplayFormat("yyyy-MM-dd")
tips_layout.addWidget(self.parser_date_edit)
tips_layout.addWidget(QLabel(self))
self.parser_start_button = QPushButton("开始", self)
tips_layout.addWidget(self.parser_start_button)
tips_layout.addStretch()
parser_layout.addLayout(tips_layout)
self.parser_status = QLabel("等待开始解析", self)
self.parser_status.setAlignment(Qt.AlignCenter)
parser_layout.addWidget(self.parser_status)
parser_widget.setLayout(parser_layout)
action_splitter.addWidget(parser_widget)
main_splitter.addWidget(action_splitter)
main_splitter.setStretchFactor(0, 4)
main_splitter.setStretchFactor(1, 6)
layout.addWidget(main_splitter)
self.setLayout(layout)
main_splitter.setObjectName("mainSplitter")
action_splitter.setObjectName("actionSplitter")
self.spider_exchange_button.setObjectName("tipButton")
self.spider_action_button.setObjectName("tipButton")
self.spider_status.setObjectName("spiderStatus")
self.parser_exchange_button.setObjectName("tipButton")
self.parser_action_button.setObjectName("tipButton")
self.parser_status.setObjectName("parserStatus")
self.setStyleSheet(
"#mainSplitter::handle{background-color:rgba(50,50,50,100)}"
"#actionSplitter::handle{background-color:rgba(50,50,50,100)}"
"#tipButton{border:none;color:rgb(220,100,100)}"
"#spiderStatus,#parserStatus{font-size:16px;font-weight:bold;color:rgb(230,50,50)}"
)
import itertools
from PySide2.QtGui import QPen, QBrush, QColor
colors = ["#D34C75", "#E9C13B", "#0A92AC", "#8662EA"]
pens = [QPen(QColor(color)) for color in colors]
brushes = [QBrush(QColor(color)) for color in colors]
COLOR_BKG_EMPTY = "#1D1D1D"
QCOLOR_BKG_EMPTY = QColor(COLOR_BKG_EMPTY)
BRUSH_EMPTY = QBrush(QCOLOR_BKG_EMPTY)
COLOR_EMPTY = "#4D4D4D"
QCOLOR_EMPTY = QColor(COLOR_EMPTY)
PEN_EMPTY = QPen(QCOLOR_EMPTY)
PEN_BLACK = QPen(QColor("#000"))
PEN_BCK = QPen("#2D2D2D")
PEN_LIGHT = QPen("#8A9199")
PEN_WARNING = QPen("#C3486B")
next_pen = itertools.cycle(pens)
next_brush = itertools.cycle(brushes)
dataRandomY[i] = uniform(0.0,1.0)-0.5+dataRandomY[max(0,i-1)]
rMax = max (dataRandomY)
rMin = min(dataRandomY)
rAbs = max(abs(rMax),abs(rMin))
rInt = int(round(rAbs))
x3 = [1,2,3,4]
y3 = [2.0,2.5, 4.0,1.5]
# create and configure plottables:
mainGraphCos = customPlot.addGraph(wideAxisRect.axis(QCPAxis.atBottom), wideAxisRect.axis(QCPAxis.atLeft))
mainGraphCos.setData(dataCosX, dataCosY)
mainGraphCos.valueAxis().setRange(-1, 1)
mainGraphCos.rescaleKeyAxis()
mainGraphCos.setScatterStyle(QCPScatterStyle(QCPScatterStyle.ssCircle, QPen(Qt.black), QBrush(Qt.white), 6))
mainGraphCos.setPen(QPen(QColor(120, 120, 120), 2))
mainGraphGauss = customPlot.addGraph(wideAxisRect.axis(QCPAxis.atBottom), wideAxisRect.axis(QCPAxis.atLeft, 1))
mainGraphGauss.setData(dataGaussX, dataGaussY)
mainGraphGauss.setPen(QPen(QColor("#8070B8"), 2))
mainGraphGauss.setBrush(QColor(110, 170, 110, 30))
mainGraphCos.setChannelFillGraph(mainGraphGauss)
mainGraphCos.setBrush(QColor(255, 161, 0, 50))
mainGraphGauss.valueAxis().setRange(0, 1000)
mainGraphGauss.rescaleKeyAxis()
subGraphRandom = customPlot.addGraph(subRectLeft.axis(QCPAxis.atBottom), subRectLeft.axis(QCPAxis.atLeft))
subGraphRandom.setData(dataRandomX, dataRandomY)
subGraphRandom.setLineStyle(QCPGraph.lsImpulse)
def _paint_regions(self):
cfb = self.instance.cfb_container.am_obj
if cfb is None:
return
# colors
func_color = Conf.feature_map_color_regular_function
data_color = Conf.feature_map_color_data
unknown_color = Conf.feature_map_color_unknown
delimiter_color = Conf.feature_map_color_delimiter
if self._total_size is None:
# calculate the total number of bytes
b = 0
self._addr_to_region.clear()
self._regionaddr_to_offset.clear()
for mr in cfb.regions:
self._addr_to_region[mr.addr] = mr
self._regionaddr_to_offset[mr.addr] = b
self._offset_to_regionaddr[b] = mr.addr
b += self._adjust_region_size(mr)
self._total_size = b
# iterate through all items and draw the image
offset = 0
total_width = self.width()
current_region = None
height = self.height()
print(total_width)
for addr, obj in cfb.ceiling_items():
# are we in a new region?
new_region = False
if current_region is None or not (
current_region.addr <= addr <
current_region.addr + current_region.size):
current_region_addr = next(
self._addr_to_region.irange(maximum=addr, reverse=True))
current_region = self._addr_to_region[current_region_addr]
new_region = True
# adjust size
adjusted_region_size = self._adjust_region_size(current_region)
adjusted_size = min(
obj.size, current_region.addr + adjusted_region_size - addr)
if adjusted_size <= 0:
continue
pos = offset * total_width // self._total_size
length = adjusted_size * total_width // self._total_size
offset += adjusted_size
# draw a rectangle
if isinstance(obj, Unknown):
pen = QPen(data_color)
brush = QBrush(data_color)
elif isinstance(obj, Block):
# TODO: Check if it belongs to a function or not
pen = QPen(func_color)
brush = QBrush(func_color)
else:
pen = QPen(unknown_color)
brush = QBrush(unknown_color)
rect = QRectF(pos, 0, length, height)
self.view._scene.addRect(rect, pen, brush)
# if at the beginning of a new region, draw a line
if new_region:
pen = QPen(delimiter_color)
self.view._scene.addLine(pos, 0, pos, height, pen)
def __init__(self):
CG = self.ColorGroup
CR = self.ColorRole
self._brush = {}
self._brush[CG.Active] = {
CR.Background: QBrush(QColor.fromRgb(240, 240, 240)),
CR.Base: QBrush(Qt.white),
CR.Frame: QBrush(Qt.black),
CR.Edge: QBrush(Qt.black),
CR.Text: QBrush(Qt.black)
}
self._brush[CG.Selected] = {
CR.Background: QBrush(Qt.white),
CR.Base: QBrush(QColor.fromRgb(247, 247, 255)),
CR.Frame: QBrush(QColor.fromRgb(0, 0, 200)),
CR.Edge: QBrush(QColor.fromRgb(0, 0, 200)),
CR.Text: QBrush(Qt.black)
}
self._brush[CG.Disabled] = {}
self._brush[CG.Inactive] = {}
# Copy Active group to other ones
for key in self._brush[CG.Active]:
self._brush[CG.Disabled][key] = QBrush(self._brush[CG.Active][key])
self._brush[CG.Inactive][key] = QBrush(self._brush[CG.Active][key])
self._current_color_group = CG.Active
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(1353, 736)
MainWindow.setMinimumSize(QSize(1353, 736))
MainWindow.setMaximumSize(QSize(1353, 736))
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.wave_form_group_box = QGroupBox(self.centralwidget)
self.wave_form_group_box.setObjectName(u"wave_form_group_box")
self.wave_form_group_box.setGeometry(QRect(261, 13, 841, 491))
font = QFont()
font.setFamily(u"\u9ed1\u4f53")
font.setPointSize(12)
self.wave_form_group_box.setFont(font)
self.wave_form_group_box.setAlignment(Qt.AlignCenter)
self.tabWidget = QTabWidget(self.wave_form_group_box)
self.tabWidget.setObjectName(u"tabWidget")
self.tabWidget.setGeometry(QRect(10, 20, 821, 461))
self.tabWidget.setFont(font)
self.tabWidget.setMovable(True)
self.dialysis_widget = QWidget()
self.dialysis_widget.setObjectName(u"dialysis_widget")
self.dialysis_pressure_plot_view = PlotWidget(self.dialysis_widget)
self.dialysis_pressure_plot_view.setObjectName(u"dialysis_pressure_plot_view")
self.dialysis_pressure_plot_view.setGeometry(QRect(10, 10, 801, 411))
self.tabWidget.addTab(self.dialysis_widget, "")
self.dialysis_flow_widget = QWidget()
self.dialysis_flow_widget.setObjectName(u"dialysis_flow_widget")
self.dialysis_flow_plot_view = PlotWidget(self.dialysis_flow_widget)
self.dialysis_flow_plot_view.setObjectName(u"dialysis_flow_plot_view")
self.dialysis_flow_plot_view.setGeometry(QRect(10, 10, 801, 411))
self.tabWidget.addTab(self.dialysis_flow_widget, "")
self.pluse_widget = QWidget()
self.pluse_widget.setObjectName(u"pluse_widget")
self.pluse_plot_view = PlotWidget(self.pluse_widget)
self.pluse_plot_view.setObjectName(u"pluse_plot_view")
self.pluse_plot_view.setGeometry(QRect(10, 10, 801, 411))
self.tabWidget.addTab(self.pluse_widget, "")
self.weight_view = QWidget()
self.weight_view.setObjectName(u"weight_view")
self.weight_plot_view = PlotWidget(self.weight_view)
self.weight_plot_view.setObjectName(u"weight_plot_view")
self.weight_plot_view.setGeometry(QRect(10, 10, 801, 411))
self.tabWidget.addTab(self.weight_view, "")
self.tmp_widget = QWidget()
self.tmp_widget.setObjectName(u"tmp_widget")
self.tmp_plot_view = PlotWidget(self.tmp_widget)
self.tmp_plot_view.setObjectName(u"tmp_plot_view")
self.tmp_plot_view.setGeometry(QRect(10, 10, 801, 411))
self.tabWidget.addTab(self.tmp_widget, "")
self.value_group_box = QGroupBox(self.centralwidget)
self.value_group_box.setObjectName(u"value_group_box")
self.value_group_box.setGeometry(QRect(1113, 14, 231, 681))
self.value_group_box.setFont(font)
self.gridLayoutWidget_2 = QWidget(self.value_group_box)
self.gridLayoutWidget_2.setObjectName(u"gridLayoutWidget_2")
self.gridLayoutWidget_2.setGeometry(QRect(10, 29, 211, 641))
self.gridLayout_2 = QGridLayout(self.gridLayoutWidget_2)
self.gridLayout_2.setObjectName(u"gridLayout_2")
self.gridLayout_2.setContentsMargins(0, 0, 0, 0)
self.waste_flow_label = QLabel(self.gridLayoutWidget_2)
self.waste_flow_label.setObjectName(u"waste_flow_label")
self.waste_flow_label.setFont(font)
self.waste_flow_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.waste_flow_label, 6, 0, 1, 1)
self.fresh_flow_label = QLabel(self.gridLayoutWidget_2)
self.fresh_flow_label.setObjectName(u"fresh_flow_label")
self.fresh_flow_label.setFont(font)
self.gridLayout_2.addWidget(self.fresh_flow_label, 4, 0, 1, 1)
self.waste_flow_value = QLabel(self.gridLayoutWidget_2)
self.waste_flow_value.setObjectName(u"waste_flow_value")
self.waste_flow_value.setFont(font)
self.waste_flow_value.setStyleSheet(u"background-color: rgb(255, 255, 255);\n"
"color: rgb(30, 71, 255);")
self.waste_flow_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.waste_flow_value, 6, 1, 1, 1)
self.fresh_pressure_value = QLabel(self.gridLayoutWidget_2)
self.fresh_pressure_value.setObjectName(u"fresh_pressure_value")
self.fresh_pressure_value.setFont(font)
self.fresh_pressure_value.setStyleSheet(u"background-color: rgb(255, 255, 255);")
self.fresh_pressure_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.fresh_pressure_value, 1, 1, 1, 1)
self.artery_pressure_value = QLabel(self.gridLayoutWidget_2)
self.artery_pressure_value.setObjectName(u"artery_pressure_value")
self.artery_pressure_value.setFont(font)
self.artery_pressure_value.setStyleSheet(u"background-color: rgb(255, 255, 255);")
self.artery_pressure_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.artery_pressure_value, 9, 1, 1, 1)
self.fresh_pressure_label = QLabel(self.gridLayoutWidget_2)
self.fresh_pressure_label.setObjectName(u"fresh_pressure_label")
self.fresh_pressure_label.setFont(font)
self.fresh_pressure_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.fresh_pressure_label, 1, 0, 1, 1)
self.process_temperature_label = QLabel(self.gridLayoutWidget_2)
self.process_temperature_label.setObjectName(u"process_temperature_label")
self.process_temperature_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.process_temperature_label, 16, 0, 1, 1)
self.artery_pressure_label = QLabel(self.gridLayoutWidget_2)
self.artery_pressure_label.setObjectName(u"artery_pressure_label")
self.artery_pressure_label.setFont(font)
self.artery_pressure_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.artery_pressure_label, 9, 0, 1, 1)
self.waste_pressure_vlue = QLabel(self.gridLayoutWidget_2)
self.waste_pressure_vlue.setObjectName(u"waste_pressure_vlue")
self.waste_pressure_vlue.setFont(font)
self.waste_pressure_vlue.setStyleSheet(u"background-color: rgb(255, 255, 255);\n"
"color: rgb(30, 71, 255);")
self.waste_pressure_vlue.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.waste_pressure_vlue, 3, 1, 1, 1)
self.vein_pressure_value = QLabel(self.gridLayoutWidget_2)
self.vein_pressure_value.setObjectName(u"vein_pressure_value")
self.vein_pressure_value.setFont(font)
self.vein_pressure_value.setStyleSheet(u"background-color: rgb(255, 255, 255);\n"
"color: rgb(30, 71, 255);")
self.vein_pressure_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.vein_pressure_value, 10, 1, 1, 1)
self.fresh_flow_value = QLabel(self.gridLayoutWidget_2)
self.fresh_flow_value.setObjectName(u"fresh_flow_value")
self.fresh_flow_value.setFont(font)
self.fresh_flow_value.setStyleSheet(u"background-color: rgb(255, 255, 255);")
self.fresh_flow_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.fresh_flow_value, 4, 1, 1, 1)
self.vein_pressure_label = QLabel(self.gridLayoutWidget_2)
self.vein_pressure_label.setObjectName(u"vein_pressure_label")
self.vein_pressure_label.setFont(font)
self.vein_pressure_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.vein_pressure_label, 10, 0, 1, 1)
self.waste_pressure_label = QLabel(self.gridLayoutWidget_2)
self.waste_pressure_label.setObjectName(u"waste_pressure_label")
self.waste_pressure_label.setFont(font)
self.waste_pressure_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.waste_pressure_label, 3, 0, 1, 1)
self.initial_temperature_label = QLabel(self.gridLayoutWidget_2)
self.initial_temperature_label.setObjectName(u"initial_temperature_label")
self.initial_temperature_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.initial_temperature_label, 15, 0, 1, 1)
self.ultrafiltration_show_label = QLabel(self.gridLayoutWidget_2)
self.ultrafiltration_show_label.setObjectName(u"ultrafiltration_show_label")
self.ultrafiltration_show_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.ultrafiltration_show_label, 17, 0, 1, 1)
self.initial_temperature_value = QLabel(self.gridLayoutWidget_2)
self.initial_temperature_value.setObjectName(u"initial_temperature_value")
self.initial_temperature_value.setStyleSheet(u"background-color: rgb(255, 255, 255);\n"
"color: rgb(30, 71, 255);")
self.initial_temperature_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.initial_temperature_value, 15, 1, 1, 1)
self.process_temperature_value = QLabel(self.gridLayoutWidget_2)
self.process_temperature_value.setObjectName(u"process_temperature_value")
self.process_temperature_value.setStyleSheet(u"background-color: rgb(255, 255, 255);")
self.process_temperature_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.process_temperature_value, 16, 1, 1, 1)
self.ultrafiltration_show_value = QLabel(self.gridLayoutWidget_2)
self.ultrafiltration_show_value.setObjectName(u"ultrafiltration_show_value")
self.ultrafiltration_show_value.setStyleSheet(u"background-color: rgb(255, 255, 255);\n"
"color: rgb(30, 71, 255);")
self.ultrafiltration_show_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.ultrafiltration_show_value, 17, 1, 1, 1)
self.blood_flow_label = QLabel(self.gridLayoutWidget_2)
self.blood_flow_label.setObjectName(u"blood_flow_label")
self.blood_flow_label.setFont(font)
self.blood_flow_label.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.blood_flow_label, 7, 0, 1, 1)
self.blood_flow_value = QLabel(self.gridLayoutWidget_2)
self.blood_flow_value.setObjectName(u"blood_flow_value")
self.blood_flow_value.setFont(font)
self.blood_flow_value.setStyleSheet(u"background-color: rgb(255, 255, 255);")
self.blood_flow_value.setAlignment(Qt.AlignCenter)
self.gridLayout_2.addWidget(self.blood_flow_value, 7, 1, 1, 1)
self.setting_group_box = QGroupBox(self.centralwidget)
self.setting_group_box.setObjectName(u"setting_group_box")
self.setting_group_box.setGeometry(QRect(10, 510, 1091, 181))
font1 = QFont()
font1.setFamily(u"\u9ed1\u4f53")
font1.setPointSize(12)
font1.setBold(False)
font1.setWeight(50)
self.setting_group_box.setFont(font1)
self.setting_group_box.setAlignment(Qt.AlignCenter)
self.setting_group_box.setFlat(False)
self.setting_group_box.setCheckable(False)
self.horizontalLayout = QHBoxLayout(self.setting_group_box)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.gridLayout_6 = QGridLayout()
self.gridLayout_6.setObjectName(u"gridLayout_6")
self.fresh_waste_forward_button = QPushButton(self.setting_group_box)
self.fresh_waste_forward_button.setObjectName(u"fresh_waste_forward_button")
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.fresh_waste_forward_button.sizePolicy().hasHeightForWidth())
self.fresh_waste_forward_button.setSizePolicy(sizePolicy)
self.fresh_waste_forward_button.setMinimumSize(QSize(50, 30))
self.gridLayout_6.addWidget(self.fresh_waste_forward_button, 3, 0, 1, 1)
self.fresh_waste_edit = QLineEdit(self.setting_group_box)
self.fresh_waste_edit.setObjectName(u"fresh_waste_edit")
self.fresh_waste_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_6.addWidget(self.fresh_waste_edit, 2, 0, 1, 2)
self.fresh_waste_label = QLabel(self.setting_group_box)
self.fresh_waste_label.setObjectName(u"fresh_waste_label")
self.fresh_waste_label.setFont(font1)
self.fresh_waste_label.setAlignment(Qt.AlignCenter)
self.gridLayout_6.addWidget(self.fresh_waste_label, 1, 0, 1, 2)
self.fresh_waste_reverse_button = QPushButton(self.setting_group_box)
self.fresh_waste_reverse_button.setObjectName(u"fresh_waste_reverse_button")
sizePolicy.setHeightForWidth(self.fresh_waste_reverse_button.sizePolicy().hasHeightForWidth())
self.fresh_waste_reverse_button.setSizePolicy(sizePolicy)
self.fresh_waste_reverse_button.setMinimumSize(QSize(50, 30))
self.gridLayout_6.addWidget(self.fresh_waste_reverse_button, 3, 1, 1, 1)
self.fresh_waste_stop_button = QPushButton(self.setting_group_box)
self.fresh_waste_stop_button.setObjectName(u"fresh_waste_stop_button")
sizePolicy.setHeightForWidth(self.fresh_waste_stop_button.sizePolicy().hasHeightForWidth())
self.fresh_waste_stop_button.setSizePolicy(sizePolicy)
self.fresh_waste_stop_button.setMinimumSize(QSize(50, 30))
self.gridLayout_6.addWidget(self.fresh_waste_stop_button, 4, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_6)
self.gridLayout_7 = QGridLayout()
self.gridLayout_7.setObjectName(u"gridLayout_7")
self.fresh_forward_button = QPushButton(self.setting_group_box)
self.fresh_forward_button.setObjectName(u"fresh_forward_button")
sizePolicy.setHeightForWidth(self.fresh_forward_button.sizePolicy().hasHeightForWidth())
self.fresh_forward_button.setSizePolicy(sizePolicy)
self.fresh_forward_button.setMinimumSize(QSize(50, 30))
self.gridLayout_7.addWidget(self.fresh_forward_button, 3, 0, 1, 1)
self.fresh_edit = QLineEdit(self.setting_group_box)
self.fresh_edit.setObjectName(u"fresh_edit")
self.fresh_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_7.addWidget(self.fresh_edit, 2, 0, 1, 2)
self.fresh_label = QLabel(self.setting_group_box)
self.fresh_label.setObjectName(u"fresh_label")
self.fresh_label.setFont(font1)
self.fresh_label.setAlignment(Qt.AlignCenter)
self.gridLayout_7.addWidget(self.fresh_label, 1, 0, 1, 2)
self.fresh_reverse_button = QPushButton(self.setting_group_box)
self.fresh_reverse_button.setObjectName(u"fresh_reverse_button")
sizePolicy.setHeightForWidth(self.fresh_reverse_button.sizePolicy().hasHeightForWidth())
self.fresh_reverse_button.setSizePolicy(sizePolicy)
self.fresh_reverse_button.setMinimumSize(QSize(50, 30))
self.gridLayout_7.addWidget(self.fresh_reverse_button, 3, 1, 1, 1)
self.fresh_stop_button = QPushButton(self.setting_group_box)
self.fresh_stop_button.setObjectName(u"fresh_stop_button")
sizePolicy.setHeightForWidth(self.fresh_stop_button.sizePolicy().hasHeightForWidth())
self.fresh_stop_button.setSizePolicy(sizePolicy)
self.fresh_stop_button.setMinimumSize(QSize(50, 30))
self.gridLayout_7.addWidget(self.fresh_stop_button, 4, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_7)
self.gridLayout_8 = QGridLayout()
self.gridLayout_8.setObjectName(u"gridLayout_8")
self.waste_forward_button = QPushButton(self.setting_group_box)
self.waste_forward_button.setObjectName(u"waste_forward_button")
sizePolicy.setHeightForWidth(self.waste_forward_button.sizePolicy().hasHeightForWidth())
self.waste_forward_button.setSizePolicy(sizePolicy)
self.waste_forward_button.setMinimumSize(QSize(50, 30))
self.gridLayout_8.addWidget(self.waste_forward_button, 3, 0, 1, 1)
self.waste_edit = QLineEdit(self.setting_group_box)
self.waste_edit.setObjectName(u"waste_edit")
self.waste_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_8.addWidget(self.waste_edit, 2, 0, 1, 2)
self.waste_label = QLabel(self.setting_group_box)
self.waste_label.setObjectName(u"waste_label")
self.waste_label.setFont(font1)
self.waste_label.setAlignment(Qt.AlignCenter)
self.gridLayout_8.addWidget(self.waste_label, 1, 0, 1, 2)
self.waste_reverse_button = QPushButton(self.setting_group_box)
self.waste_reverse_button.setObjectName(u"waste_reverse_button")
sizePolicy.setHeightForWidth(self.waste_reverse_button.sizePolicy().hasHeightForWidth())
self.waste_reverse_button.setSizePolicy(sizePolicy)
self.waste_reverse_button.setMinimumSize(QSize(50, 30))
self.gridLayout_8.addWidget(self.waste_reverse_button, 3, 1, 1, 1)
self.waste_stop_button = QPushButton(self.setting_group_box)
self.waste_stop_button.setObjectName(u"waste_stop_button")
sizePolicy.setHeightForWidth(self.waste_stop_button.sizePolicy().hasHeightForWidth())
self.waste_stop_button.setSizePolicy(sizePolicy)
self.waste_stop_button.setMinimumSize(QSize(50, 30))
self.gridLayout_8.addWidget(self.waste_stop_button, 4, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_8)
self.gridLayout_9 = QGridLayout()
self.gridLayout_9.setObjectName(u"gridLayout_9")
self.blood_forward_button = QPushButton(self.setting_group_box)
self.blood_forward_button.setObjectName(u"blood_forward_button")
sizePolicy.setHeightForWidth(self.blood_forward_button.sizePolicy().hasHeightForWidth())
self.blood_forward_button.setSizePolicy(sizePolicy)
self.blood_forward_button.setMinimumSize(QSize(50, 30))
self.gridLayout_9.addWidget(self.blood_forward_button, 3, 0, 1, 1)
self.blood_edit = QLineEdit(self.setting_group_box)
self.blood_edit.setObjectName(u"blood_edit")
self.blood_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_9.addWidget(self.blood_edit, 2, 0, 1, 2)
self.blood_label = QLabel(self.setting_group_box)
self.blood_label.setObjectName(u"blood_label")
self.blood_label.setFont(font1)
self.blood_label.setAlignment(Qt.AlignCenter)
self.gridLayout_9.addWidget(self.blood_label, 1, 0, 1, 2)
self.blood_reverse_button = QPushButton(self.setting_group_box)
self.blood_reverse_button.setObjectName(u"blood_reverse_button")
sizePolicy.setHeightForWidth(self.blood_reverse_button.sizePolicy().hasHeightForWidth())
self.blood_reverse_button.setSizePolicy(sizePolicy)
self.blood_reverse_button.setMinimumSize(QSize(50, 30))
self.gridLayout_9.addWidget(self.blood_reverse_button, 3, 1, 1, 1)
self.blood_stop_button = QPushButton(self.setting_group_box)
self.blood_stop_button.setObjectName(u"blood_stop_button")
sizePolicy.setHeightForWidth(self.blood_stop_button.sizePolicy().hasHeightForWidth())
self.blood_stop_button.setSizePolicy(sizePolicy)
self.blood_stop_button.setMinimumSize(QSize(50, 30))
self.gridLayout_9.addWidget(self.blood_stop_button, 4, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_9)
self.gridLayout_5 = QGridLayout()
self.gridLayout_5.setObjectName(u"gridLayout_5")
self.ultrafiltration_label = QLabel(self.setting_group_box)
self.ultrafiltration_label.setObjectName(u"ultrafiltration_label")
self.ultrafiltration_label.setAlignment(Qt.AlignCenter)
self.gridLayout_5.addWidget(self.ultrafiltration_label, 0, 0, 1, 2)
self.ultrafiltration_reverse_button = QPushButton(self.setting_group_box)
self.ultrafiltration_reverse_button.setObjectName(u"ultrafiltration_reverse_button")
sizePolicy.setHeightForWidth(self.ultrafiltration_reverse_button.sizePolicy().hasHeightForWidth())
self.ultrafiltration_reverse_button.setSizePolicy(sizePolicy)
self.ultrafiltration_reverse_button.setMinimumSize(QSize(50, 30))
self.gridLayout_5.addWidget(self.ultrafiltration_reverse_button, 2, 1, 1, 1)
self.ultrafiltration_forward_button = QPushButton(self.setting_group_box)
self.ultrafiltration_forward_button.setObjectName(u"ultrafiltration_forward_button")
sizePolicy.setHeightForWidth(self.ultrafiltration_forward_button.sizePolicy().hasHeightForWidth())
self.ultrafiltration_forward_button.setSizePolicy(sizePolicy)
self.ultrafiltration_forward_button.setMinimumSize(QSize(50, 30))
self.gridLayout_5.addWidget(self.ultrafiltration_forward_button, 2, 0, 1, 1)
self.ultrafiltration_edit = QLineEdit(self.setting_group_box)
self.ultrafiltration_edit.setObjectName(u"ultrafiltration_edit")
self.ultrafiltration_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_5.addWidget(self.ultrafiltration_edit, 1, 0, 1, 2)
self.ultrafiltration_stop_button = QPushButton(self.setting_group_box)
self.ultrafiltration_stop_button.setObjectName(u"ultrafiltration_stop_button")
sizePolicy.setHeightForWidth(self.ultrafiltration_stop_button.sizePolicy().hasHeightForWidth())
self.ultrafiltration_stop_button.setSizePolicy(sizePolicy)
self.ultrafiltration_stop_button.setMinimumSize(QSize(50, 30))
self.gridLayout_5.addWidget(self.ultrafiltration_stop_button, 3, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_5)
self.gridLayout_3 = QGridLayout()
self.gridLayout_3.setObjectName(u"gridLayout_3")
self.debug_send_button = QPushButton(self.setting_group_box)
self.debug_send_button.setObjectName(u"debug_send_button")
sizePolicy1 = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy1.setHorizontalStretch(0)
sizePolicy1.setVerticalStretch(0)
sizePolicy1.setHeightForWidth(self.debug_send_button.sizePolicy().hasHeightForWidth())
self.debug_send_button.setSizePolicy(sizePolicy1)
self.debug_send_button.setMinimumSize(QSize(50, 25))
self.gridLayout_3.addWidget(self.debug_send_button, 2, 0, 1, 2)
self.debug_send_label = QLabel(self.setting_group_box)
self.debug_send_label.setObjectName(u"debug_send_label")
self.debug_send_label.setAlignment(Qt.AlignCenter)
self.gridLayout_3.addWidget(self.debug_send_label, 0, 0, 1, 2)
self.debug_send_edit = QLineEdit(self.setting_group_box)
self.debug_send_edit.setObjectName(u"debug_send_edit")
self.debug_send_edit.setAlignment(Qt.AlignCenter)
self.gridLayout_3.addWidget(self.debug_send_edit, 1, 0, 1, 2)
self.horizontalLayout.addLayout(self.gridLayout_3)
self.serial_group_box = QGroupBox(self.centralwidget)
self.serial_group_box.setObjectName(u"serial_group_box")
self.serial_group_box.setGeometry(QRect(10, 12, 241, 491))
self.serial_group_box.setFont(font)
self.gridLayoutWidget = QWidget(self.serial_group_box)
self.gridLayoutWidget.setObjectName(u"gridLayoutWidget")
self.gridLayoutWidget.setGeometry(QRect(7, 26, 231, 461))
self.gridLayout = QGridLayout(self.gridLayoutWidget)
self.gridLayout.setObjectName(u"gridLayout")
self.gridLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
self.gridLayout.setHorizontalSpacing(3)
self.gridLayout.setVerticalSpacing(10)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.all_send_button = QPushButton(self.gridLayoutWidget)
self.all_send_button.setObjectName(u"all_send_button")
self.all_send_button.setFont(font)
self.gridLayout.addWidget(self.all_send_button, 3, 1, 1, 2)
self.open_serial_button = QPushButton(self.gridLayoutWidget)
self.open_serial_button.setObjectName(u"open_serial_button")
self.open_serial_button.setFont(font)
self.open_serial_button.setIconSize(QSize(20, 40))
self.gridLayout.addWidget(self.open_serial_button, 1, 2, 1, 1)
self.find_port_button = QPushButton(self.gridLayoutWidget)
self.find_port_button.setObjectName(u"find_port_button")
self.find_port_button.setFont(font)
self.gridLayout.addWidget(self.find_port_button, 2, 1, 1, 2)
self.system_status_label = QLabel(self.gridLayoutWidget)
self.system_status_label.setObjectName(u"system_status_label")
palette = QPalette()
brush = QBrush(QColor(128, 128, 128, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Button, brush)
palette.setBrush(QPalette.Active, QPalette.Base, brush)
palette.setBrush(QPalette.Active, QPalette.Window, brush)
palette.setBrush(QPalette.Inactive, QPalette.Button, brush)
palette.setBrush(QPalette.Inactive, QPalette.Base, brush)
palette.setBrush(QPalette.Inactive, QPalette.Window, brush)
palette.setBrush(QPalette.Disabled, QPalette.Button, brush)
palette.setBrush(QPalette.Disabled, QPalette.Base, brush)
palette.setBrush(QPalette.Disabled, QPalette.Window, brush)
self.system_status_label.setPalette(palette)
self.system_status_label.setStyleSheet(u"background-color: gray;")
self.system_status_label.setProperty("isOn", True)
self.gridLayout.addWidget(self.system_status_label, 5, 1, 1, 1)
self.port_combo_box = QComboBox(self.gridLayoutWidget)
self.port_combo_box.setObjectName(u"port_combo_box")
font2 = QFont()
font2.setFamily(u"\u5b8b\u4f53")
font2.setPointSize(11)
self.port_combo_box.setFont(font2)
self.port_combo_box.setIconSize(QSize(30, 20))
self.gridLayout.addWidget(self.port_combo_box, 0, 2, 1, 1)
self.port_status_label = QLabel(self.gridLayoutWidget)
self.port_status_label.setObjectName(u"port_status_label")
palette1 = QPalette()
palette1.setBrush(QPalette.Active, QPalette.Button, brush)
palette1.setBrush(QPalette.Active, QPalette.Base, brush)
palette1.setBrush(QPalette.Active, QPalette.Window, brush)
palette1.setBrush(QPalette.Inactive, QPalette.Button, brush)
palette1.setBrush(QPalette.Inactive, QPalette.Base, brush)
palette1.setBrush(QPalette.Inactive, QPalette.Window, brush)
palette1.setBrush(QPalette.Disabled, QPalette.Button, brush)
palette1.setBrush(QPalette.Disabled, QPalette.Base, brush)
palette1.setBrush(QPalette.Disabled, QPalette.Window, brush)
self.port_status_label.setPalette(palette1)
self.port_status_label.setStyleSheet(u"background-color: gray;")
self.port_status_label.setProperty("isOn", True)
self.gridLayout.addWidget(self.port_status_label, 1, 1, 1, 1)
self.start_stop_button = QPushButton(self.gridLayoutWidget)
self.start_stop_button.setObjectName(u"start_stop_button")
self.start_stop_button.setFont(font)
self.gridLayout.addWidget(self.start_stop_button, 5, 2, 1, 1)
self.port_label = QLabel(self.gridLayoutWidget)
self.port_label.setObjectName(u"port_label")
self.port_label.setFont(font)
self.gridLayout.addWidget(self.port_label, 0, 1, 1, 1)
self.receive_button = QPushButton(self.gridLayoutWidget)
self.receive_button.setObjectName(u"receive_button")
self.receive_button.setFont(font)
self.receive_button.setIconSize(QSize(16, 16))
self.gridLayout.addWidget(self.receive_button, 4, 1, 1, 2)
self.quit_button = QPushButton(self.gridLayoutWidget)
self.quit_button.setObjectName(u"quit_button")
self.quit_button.setFont(font)
self.gridLayout.addWidget(self.quit_button, 14, 1, 2, 2)
self.verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.gridLayout.addItem(self.verticalSpacer, 13, 1, 1, 2)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setObjectName(u"menubar")
self.menubar.setGeometry(QRect(0, 0, 1353, 26))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(u"statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QMetaObject.connectSlotsByName(MainWindow)
def __setBrushColor(self, item): ##设置填充颜色
color = item.brush().__color()
color = QColorDialog.getColor(color, self,
self._tr("MainWindow", "选择填充颜色"))
if color.isValid():
item.setBrush(QBrush(color))
def paintEvent(self, e):
"""
Overrides QLabel paintEvent().
Displays the presentation layer of a vImage object,
with its current offset and zooming coefficient.
@param e: paint event
@type e:
"""
mimg = self.img
if mimg is None:
return
r = mimg.resize_coeff(self)
qp = self.qp
window = self.window
qp.begin(self)
# smooth painting
qp.setRenderHint(QPainter.SmoothPixmapTransform) # TODO may be useless
# fill background
qp.fillRect(QRect(0, 0, self.width(), self.height()),
vImage.defaultBgColor)
# draw presentation layer.
# As offsets can be float numbers, we use a QRectF instead of a QRect.
# r is relative to the full resolution image, so we use mimg width and height
w, h = mimg.width() * r, mimg.height() * r
rectF = QRectF(mimg.xOffset, mimg.yOffset, w, h)
# draw a checker background to view (semi-)transparent images
qp.fillRect(rectF, imageLabel.checkerBrush)
px = mimg.prLayer.qPixmap
if px is not None:
qp.drawPixmap(rectF, px, px.rect())
else:
currentImage = mimg.prLayer.getCurrentImage()
qp.drawImage(
rectF, currentImage, QImage.rect(currentImage)
) # CAUTION : vImage.rect() is overwritten by the attribute rect
# draw selection rectangle and cloning marker of the active layer, if any
layer = mimg.getActiveLayer()
rect, mark = layer.rect, layer.marker
if layer.visible:
if rect is not None:
qp.setPen(Qt.green)
qp.drawRect(rect.left() * r + mimg.xOffset,
rect.top() * r + mimg.yOffset,
rect.width() * r,
rect.height() * r)
if not (mark is None or layer.sourceFromFile):
qp.setPen(Qt.white)
qp.drawEllipse(mark.x() * r + mimg.xOffset,
mark.y() * r + mimg.yOffset, 10, 10)
# draw the cropping marks
lm, rm, tm, bm = 0, 0, 0, 0
if mimg.isCropped:
c = QColor(128, 128, 128, 192)
lm = window.cropTool.btnDict['left'].margin * r
rm = window.cropTool.btnDict['right'].margin * r
tm = window.cropTool.btnDict['top'].margin * r
bm = window.cropTool.btnDict['bottom'].margin * r
qp.fillRect(QRectF(mimg.xOffset, mimg.yOffset, lm, h), c) # left
qp.fillRect(QRectF(mimg.xOffset + lm, mimg.yOffset, w - lm, tm),
c) # top
qp.fillRect(
QRectF(mimg.xOffset + w - rm, mimg.yOffset + tm, rm, h - tm),
c) # right
qp.fillRect(
QRectF(mimg.xOffset + lm, mimg.yOffset + h - bm, w - lm - rm,
bm), c) # bottom
# draw rulers
if mimg.isRuled:
deltaX, deltaY = (w - lm - rm) // 3, (h - tm - bm) // 3
qp.drawLine(lm + mimg.xOffset, deltaY + tm + mimg.yOffset,
w - rm + mimg.xOffset, deltaY + tm + mimg.yOffset)
qp.drawLine(lm + mimg.xOffset, 2 * deltaY + tm + mimg.yOffset,
w - rm + mimg.xOffset, 2 * deltaY + tm + mimg.yOffset)
qp.drawLine(deltaX + lm + mimg.xOffset, tm + mimg.yOffset,
deltaX + lm + mimg.xOffset, h - bm + mimg.yOffset)
qp.drawLine(2 * deltaX + lm + mimg.xOffset, tm + mimg.yOffset,
2 * deltaX + lm + mimg.xOffset, h - bm + mimg.yOffset)
# tag before/after views
name = self.objectName()
if name == "label_2" or name == "label_3":
# draw filled rect
qp.fillPath(qp.markPath, QBrush(Qt.gray))
# draw text
qp.setPen(Qt.white)
qp.setFont(qp.font)
qp.drawText(qp.markRect, Qt.AlignCenter | Qt.AlignVCenter,
"Before" if name == "label_2" else "After")
qp.end()
def addSubtitle(self, index):
subtitlePath = QFileDialog.getOpenFileName(self, "请选择字幕", None, "字幕文件 (*.srt *.vtt *.ass *.ssa)")[0]
if subtitlePath:
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
if subtitlePath.endswith('.ass') or subtitlePath.endswith('.ssa'):
p = subprocess.Popen(['utils/ffmpeg.exe', '-y', '-i', subtitlePath, 'temp_sub.srt'])
p.wait()
subtitlePath = 'temp_sub.srt'
subData = {}
with open(subtitlePath, 'r', encoding='utf-8') as f:
f = f.readlines()
subText = ''
YoutubeAutoSub = False
for l in f:
if '<c>' in l:
YoutubeAutoSub = True
break
for cnt, l in enumerate(f):
if '<c>' in l:
lineData = l.split('c>')
if len(lineData) > 3:
subText, start, _ = lineData[0].split('<')
start = calSubTime(start[:-1]) // self.globalInterval * self.globalInterval
if start not in self.subtitleDict[index]:
end = calSubTime(lineData[-3][1:-2]) // self.globalInterval * self.globalInterval
for i in range(len(lineData) // 2):
subText += lineData[i * 2 + 1][:-2]
subData[start] = [end - start, subText]
else:
subText, start, _ = lineData[0].split('<')
start = calSubTime(start[:-1]) // self.globalInterval * self.globalInterval
if start not in self.subtitleDict[index]:
subText += lineData[1][:-2]
subData[start] = [self.globalInterval, subText]
elif '-->' in l and f[cnt + 2].strip() and '<c>' not in f[cnt + 2]:
subText = f[cnt + 2][:-1]
start = calSubTime(l[:12]) // self.globalInterval * self.globalInterval
if start not in self.subtitleDict[index]:
end = calSubTime(l[17:29]) // self.globalInterval * self.globalInterval
subData[start] = [end - start, subText]
if '-->' in l and f[cnt + 1].strip() and not YoutubeAutoSub:
start = calSubTime(l[:12]) // self.globalInterval * self.globalInterval
if start not in self.subtitleDict[index]:
end = calSubTime(l[17:29]) // self.globalInterval * self.globalInterval
delta = end - start
if delta > 10:
if '<b>' in f[cnt + 1]:
subData[start] = [delta, f[cnt + 1].split('<b>')[1].split('<')[0]]
else:
subData[start] = [delta, f[cnt + 1][:-1]]
self.subtitleDict[index].update(subData)
maxRow = 0
for _, v in self.subtitleDict.items():
startMax = max(v.keys())
rowCount = (startMax + v[startMax][0]) // self.globalInterval
if rowCount > maxRow:
maxRow = rowCount
if maxRow < self.duration // self.globalInterval + 1:
maxRow = self.duration // self.globalInterval
else:
self.duration = maxRow * self.globalInterval
self.subtitle.setRowCount(maxRow)
self.subtitle.setVerticalHeaderLabels([cnt2Time2(i, self.globalInterval) for i in range(self.subtitle.rowCount())])
for start, rowData in subData.items():
startRow = start // self.globalInterval
endRow = startRow + rowData[0] // self.globalInterval
for row in range(startRow, endRow):
self.subtitle.setItem(row, index, QTableWidgetItem(rowData[1]))
self.subtitle.item(row, index).setBackground(QBrush(QColor('#35545d')))
self.subtitle.setSpan(startRow, index, endRow - startRow, 1)
self.refreshComboBox()
self.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
class imageLabel(QLabel):
qp = QPainter()
qp.font = QFont("Arial", 8)
qp.markPath = QPainterPath()
qp.markRect = QRect(0, 0, 50, 20)
qp.markPath.addRoundedRect(qp.markRect, 5, 5)
checkerBrush = QBrush(checkeredImage())
def brushUpdate(self):
"""
Sync the current brush/eraser with self.State
and update the current brush sample.
"""
bSpacing, bJitter, bOrientation = 1.0, 0.0, 0
current = self.State.get('brush', None)
if current is not None:
bSpacing = current['spacing']
bJitter = current['jitter']
bOrientation = current['orientation']
s = self.sender()
if s is not None:
name = s.objectName()
if name == 'spacingSlider':
bSpacing = s.value() / 10
elif name == 'jitterSlider':
bJitter = s.value() / 10
elif name == 'orientationSlider':
bOrientation = s.value() - 180
window = self.window
bSize = window.verticalSlider1.value()
bOpacity = window.verticalSlider2.value() / 100
bHardness = window.verticalSlider3.value() / 100
bFlow = window.verticalSlider4.value() / 100
if getattr(window, 'colorChooser', None):
bColor = window.colorChooser.selectedColor()
else:
bColor = Qt.black
if window.btnValues['eraserButton']:
self.State[''] = window.brushes[-1].getBrush(
bSize, bOpacity, bColor, bHardness, bFlow)
else:
pattern = window.patternCombo.currentData()
self.State['brush'] = window.brushCombo.currentData().getBrush(
bSize,
bOpacity,
bColor,
bHardness,
bFlow,
spacing=bSpacing,
jitter=bJitter,
orientation=bOrientation,
pattern=pattern)
# record current brush into layer brushDict
if self.img is not None:
layer = self.img.getActiveLayer()
if layer.isDrawLayer():
layer.brushDict = self.State['brush'].copy()
grForm = layer.getGraphicsForm()
if grForm is not None:
grForm.updateSample()
def syncBrush(self, zooming):
"""
Sync current brush with tool bar and zoom coeff.
Overrides or changes the application cursor.
@param zooming:
@type zooming: float
"""
minSize = 16
# bSize = self.brushUpdate()
bSize = self.State['brush']['size'] # TODO modified 26/01/20 validate
w = bSize * zooming
if w >= minSize:
cursor = QCursor(self.State['brush']['cursor'].scaled(w, w),
hotX=w / 2,
hotY=w / 2)
else:
d = int((minSize - w) / 2)
cursor = QCursor(self.State['brush']['cursor'].scaled(
minSize, minSize),
hotX=d,
hotY=d)
if QApplication.overrideCursor():
QApplication.changeOverrideCursor(cursor)
else:
QApplication.setOverrideCursor(cursor)
def __init__(self,
mainForm=None,
splitWin=None,
enterAndLeave=False,
parent=None):
super().__init__(parent=parent)
self.window = mainForm
self.splitWin = splitWin
self.enterAndLeave = enterAndLeave
# global state variables used in mouseEvent.
self.pressed = False
self.clicked = True
self.State = {
'ix': 0,
'iy': 0,
'ix_begin': 0,
'iy_begin': 0,
'cloning': ''
}
self.img = None
def paintEvent(self, e):
"""
Overrides QLabel paintEvent().
Displays the presentation layer of a vImage object,
with its current offset and zooming coefficient.
@param e: paint event
@type e:
"""
mimg = self.img
if mimg is None:
return
r = mimg.resize_coeff(self)
qp = self.qp
window = self.window
qp.begin(self)
# smooth painting
qp.setRenderHint(QPainter.SmoothPixmapTransform) # TODO may be useless
# fill background
qp.fillRect(QRect(0, 0, self.width(), self.height()),
vImage.defaultBgColor)
# draw presentation layer.
# As offsets can be float numbers, we use a QRectF instead of a QRect.
# r is relative to the full resolution image, so we use mimg width and height
w, h = mimg.width() * r, mimg.height() * r
rectF = QRectF(mimg.xOffset, mimg.yOffset, w, h)
# draw a checker background to view (semi-)transparent images
qp.fillRect(rectF, imageLabel.checkerBrush)
px = mimg.prLayer.qPixmap
if px is not None:
qp.drawPixmap(rectF, px, px.rect())
else:
currentImage = mimg.prLayer.getCurrentImage()
qp.drawImage(
rectF, currentImage, QImage.rect(currentImage)
) # CAUTION : vImage.rect() is overwritten by the attribute rect
# draw selection rectangle and cloning marker of the active layer, if any
layer = mimg.getActiveLayer()
rect, mark = layer.rect, layer.marker
if layer.visible:
if rect is not None:
qp.setPen(Qt.green)
qp.drawRect(rect.left() * r + mimg.xOffset,
rect.top() * r + mimg.yOffset,
rect.width() * r,
rect.height() * r)
if not (mark is None or layer.sourceFromFile):
qp.setPen(Qt.white)
qp.drawEllipse(mark.x() * r + mimg.xOffset,
mark.y() * r + mimg.yOffset, 10, 10)
# draw the cropping marks
lm, rm, tm, bm = 0, 0, 0, 0
if mimg.isCropped:
c = QColor(128, 128, 128, 192)
lm = window.cropTool.btnDict['left'].margin * r
rm = window.cropTool.btnDict['right'].margin * r
tm = window.cropTool.btnDict['top'].margin * r
bm = window.cropTool.btnDict['bottom'].margin * r
qp.fillRect(QRectF(mimg.xOffset, mimg.yOffset, lm, h), c) # left
qp.fillRect(QRectF(mimg.xOffset + lm, mimg.yOffset, w - lm, tm),
c) # top
qp.fillRect(
QRectF(mimg.xOffset + w - rm, mimg.yOffset + tm, rm, h - tm),
c) # right
qp.fillRect(
QRectF(mimg.xOffset + lm, mimg.yOffset + h - bm, w - lm - rm,
bm), c) # bottom
# draw rulers
if mimg.isRuled:
deltaX, deltaY = (w - lm - rm) // 3, (h - tm - bm) // 3
qp.drawLine(lm + mimg.xOffset, deltaY + tm + mimg.yOffset,
w - rm + mimg.xOffset, deltaY + tm + mimg.yOffset)
qp.drawLine(lm + mimg.xOffset, 2 * deltaY + tm + mimg.yOffset,
w - rm + mimg.xOffset, 2 * deltaY + tm + mimg.yOffset)
qp.drawLine(deltaX + lm + mimg.xOffset, tm + mimg.yOffset,
deltaX + lm + mimg.xOffset, h - bm + mimg.yOffset)
qp.drawLine(2 * deltaX + lm + mimg.xOffset, tm + mimg.yOffset,
2 * deltaX + lm + mimg.xOffset, h - bm + mimg.yOffset)
# tag before/after views
name = self.objectName()
if name == "label_2" or name == "label_3":
# draw filled rect
qp.fillPath(qp.markPath, QBrush(Qt.gray))
# draw text
qp.setPen(Qt.white)
qp.setFont(qp.font)
qp.drawText(qp.markRect, Qt.AlignCenter | Qt.AlignVCenter,
"Before" if name == "label_2" else "After")
qp.end()
def mousePressEvent(self, event):
"""
Mouse event handlers.
The handlers implement mouse actions on an imImage displayed in a QLabel.
It handles image positioning, zooming, and
tool actions.
NOTE. Due to wheeelEvent, xOffset and yOffset are float numbers
@param event: mouse event
@type event: QMouseEvent
"""
State = self.State
window = self.window
eventType = event.type()
# no context menu
if eventType == QContextMenuEvent:
return
# get image and active layer
img = self.img
layer = img.getActiveLayer()
r = img.resize_coeff(self)
############################################################
# get mouse x, y coordinates (relative to widget).
# The mouse coordinates relative to the (full size) image are
# (x - img.xOffset) / r, (y - img.yOffset) / r
#############################################################
x, y = event.x(), event.y()
modifiers = event.modifiers()
# Mouse hover generates mouse move events,
# so, we set pressed to select only non hovering events
self.pressed = True
if event.button() == Qt.LeftButton:
# no move yet
self.clicked = True
State['ix'], State['iy'] = x, y
State['ix_begin'], State['iy_begin'] = x, y
State['x_imagePrecPos'], State['y_imagePrecPos'] = (
x - img.xOffset) // r, (y - img.yOffset) // r
if layer.isDrawLayer():
layer.history.addItem(layer.sourceImg.copy())
if window.btnValues['brushButton'] or window.btnValues['bucket']:
# starting a new stroke : save initial image for atomic stroke painting and init intermediate layer
layer.strokeDest = layer.sourceImg.copy()
layer.stroke.fill(QColor(0, 0, 0, 0))
if window.btnValues['brushButton']:
self.syncBrush(r)
# add current mask to history
if window.btnValues['drawFG'] or window.btnValues['drawBG']:
if layer.maskIsEnabled:
layer.historyListMask.addItem(layer.mask.copy())
# dragBtn or arrow
if layer.isCloningLayer():
if not (window.btnValues['drawFG'] or window.btnValues['drawBG']):
if modifiers == Qt.ControlModifier | Qt.AltModifier: # prevent unwanted clicks
if layer.cloningState == 'continue':
dlgWarn(
'Layer already cloned',
'To start a new cloning operation, add another cloning layer'
)
return
# set source starting point (coordinates are relative to full size image)
layer.sourceX, layer.sourceY = (x - img.xOffset) / r, (
y - img.yOffset) / r
layer.cloningState = 'start'
elif layer.cloningState == 'start':
# set the virtual layer translation (relative to full size image)
layer.xAltOffset, layer.yAltOffset = (x - img.xOffset) / r - layer.sourceX,\
(y - img.yOffset) / r - layer.sourceY
layer.cloningState = 'continue'
layer.updateCloningMask()
layer.updateSourcePixmap()
def mouseMoveEvent(self, event):
"""
Mouse event handlers.
The handlers implement mouse actions on an imImage displayed in a QLabel.
It handles image positioning, zooming, and
tool actions.
NOTE 1. Mouse hover generates mouse move events
NOTE 2. Due to wheeelEvent, xOffset and yOffset are float numbers
@param event: mouse event
@type event: QMouseEvent
"""
window = self.window
State = self.State
qp = self.qp
eventType = event.type()
# no context menu
if eventType == QContextMenuEvent:
return
# get image and active layer
img = self.img
layer = img.getActiveLayer()
r = img.resize_coeff(self)
############################################################
# get mouse x, y coordinates (relative to widget).
# The mouse coordinates relative to the (full size) image are
# (x - img.xOffset) / r, (y - img.yOffset) / r
#############################################################
x, y = event.x(), event.y()
modifiers = event.modifiers()
# hover event
if not self.pressed:
x_img, y_img = (x - img.xOffset) / r, (y - img.yOffset) / r
# read input and current colors from active layer (coordinates are relative to the full-sized image)
clr = img.getActivePixel(x_img, y_img, qcolor=True)
clrC = img.getActivePixel(x_img,
y_img,
fromInputImg=False,
qcolor=True)
window.infoView.setText(clr, clrC)
if layer.isCloningLayer():
if layer.cloningState == 'continue':
mx, my = x_img - layer.xAltOffset, y_img - layer.yAltOffset
elif layer.cloningState == 'start':
mx, my = layer.sourceX, layer.sourceY
else:
mx, my = x_img, y_img
if layer.sourceFromFile:
pxmp = layer.getGraphicsForm().sourcePixmap
mx, my = mx * pxmp.width() / layer.width(
), my * pxmp.height() / layer.height()
layer.marker = QPointF(mx, my)
window.label.repaint()
if layer.sourceFromFile:
layer.getGraphicsForm().widgetImg.repaint()
return
self.clicked = False
if img.isMouseSelectable:
# don't draw on a non visible layer
if window.btnValues['rectangle'] or window.btnValues[
'drawFG'] or window.btnValues['drawBG']:
if not layer.visible:
dlgWarn('Select a visible layer for drawing or painting')
self.pressed = False
return
elif not window.btnValues[
'rectangle'] and not layer.maskIsEnabled:
dlgWarn('Enable the mask before painting')
self.pressed = False
return
# marquee tool
if window.btnValues['rectangle']:
# rectangle coordinates are relative to full image
x_img = (min(State['ix_begin'], x) - img.xOffset) // r
y_img = (min(State['iy_begin'], y) - img.yOffset) // r
w = abs(State['ix_begin'] - x) // r
h = abs(State['iy_begin'] - y) // r
layer.rect = QRect(x_img, y_img, w, h)
# drawing
elif layer.isDrawLayer() and (window.btnValues['brushButton']
or window.btnValues['eraserButton']):
self.__strokePaint(layer, x, y, r)
# mask
elif window.btnValues['drawFG'] or window.btnValues['drawBG']:
if layer.maskIsEnabled:
if layer.isCloningLayer:
layer.vlChanged = True # TODO added 16/12/19
# layer.setMaskEnabled(color=True) # set mask to color mask
toolOpacity = window.verticalSlider2.value() / 100
if modifiers == Qt.NoModifier:
if layer.isSegmentLayer():
color = vImage.defaultColor_UnMasked_SM if \
window.btnValues['drawFG'] else vImage.defaultColor_Masked_SM
else:
color = vImage.defaultColor_UnMasked if \
window.btnValues['drawFG'] else vImage.defaultColor_Masked
else:
color = vImage.defaultColor_UnMasked_Invalid
qp.begin(layer.mask)
# get pen width (relative to image)
w_pen = window.verticalSlider1.value() // r
# mode source : result is source (=pen) pixel color and opacity
qp.setCompositionMode(qp.CompositionMode_Source)
tmp_x = (x - img.xOffset) // r
tmp_y = (y - img.yOffset) // r
qp.setPen(QPen(color, w_pen))
qp.setOpacity(toolOpacity)
# paint the brush tips spaced by 0.25 * w_pen
# use 1-norm for performance
a_x, a_y = tmp_x - State['x_imagePrecPos'], tmp_y - State[
'y_imagePrecPos']
d = abs(a_x) + abs(a_y)
x, y = State['x_imagePrecPos'], State['y_imagePrecPos']
radius = w_pen / 2
if d == 0:
qp.drawEllipse(
QPointF(x, y), radius, radius
) # center, radius : QPointF mandatory, else bounding rect topleft and size
else:
step = w_pen * 0.25 / d
for i in range(int(1 / step) + 1):
qp.drawEllipse(
QPointF(x, y), radius, radius
) # center, radius : QPointF mandatory, else bounding rect topleft and size
x, y = x + a_x * step, y + a_y * step
qp.end()
if layer.isCloningLayer():
if not layer.sourceFromFile:
layer.marker = QPointF(tmp_x - layer.xAltOffset,
tmp_y - layer.yAltOffset)
else:
pxmp = layer.getGraphicsForm().sourcePixmap
layer.marker = QPointF(
(tmp_x - layer.xAltOffset) * pxmp.width() /
layer.width(), (tmp_y - layer.yAltOffset) *
pxmp.height() / layer.height())
layer.getGraphicsForm().widgetImg.repaint()
State['x_imagePrecPos'], State[
'y_imagePrecPos'] = tmp_x, tmp_y
############################
# update upper stack
# should be layer.applyToStack() if any upper layer visible : too slow
# layer.applyToStack()
layer.updatePixmap()
img.prLayer.update() # =applyNone()
#############################
window.label.repaint()
# dragBtn or arrow
else:
# drag image
if modifiers == Qt.NoModifier:
img.xOffset += x - State['ix']
img.yOffset += y - State['iy']
if window.btnValues['Crop_Button']:
window.cropTool.drawCropTool(img)
# drag active layer only
elif modifiers == Qt.ControlModifier:
layer.xOffset += (x - State['ix'])
layer.yOffset += (y - State['iy'])
layer.updatePixmap()
img.prLayer.update() # =applyNone()
# drag cloning virtual layer
elif modifiers == Qt.ControlModifier | Qt.AltModifier:
if layer.isCloningLayer():
layer.xAltOffset += (x - State['ix'])
layer.yAltOffset += (y - State['iy'])
layer.vlChanged = True
if layer.maskIsSelected or not layer.maskIsEnabled:
layer.setMaskEnabled(
color=False) # set to opacity mask
layer.applyCloning(seamless=False,
showTranslated=True,
moving=True)
# not mouse selectable widget : probably before window alone !
else:
if modifiers == Qt.NoModifier:
img.xOffset += (x - State['ix'])
img.yOffset += (y - State['iy'])
elif modifiers == Qt.ControlModifier:
layer.xOffset += (x - State['ix'])
layer.yOffset += (y - State['iy'])
layer.updatePixmap()
# update current coordinates
State['ix'], State['iy'] = x, y
if layer.isGeomLayer():
layer.tool.moveRotatingTool()
# updates
self.repaint()
# sync split views
linked = True
if self.objectName() == 'label_2':
self.splitWin.syncSplitView(window.label_3, window.label_2, linked)
window.label_3.repaint()
elif self.objectName() == 'label_3':
self.splitWin.syncSplitView(window.label_2, window.label_3, linked)
window.label_2.repaint()
def mouseReleaseEvent(self, event):
"""
Mouse event handlers.
The handlers implement mouse actions on an imImage displayed in a QLabel.
It handles image positioning, zooming, and
tool actions.
@param event: mouse event
@type event: QMouseEvent
"""
window = self.window
eventType = event.type()
# no context menu
if eventType == QContextMenuEvent:
return
# get image and active layer
img = self.img
layer = img.getActiveLayer()
r = img.resize_coeff(self)
############################################################
# get mouse x, y coordinates (relative to widget).
# The mouse coordinates relative to the (full size) image are
# (x - img.xOffset) / r, (y - img.yOffset) / r
#############################################################
x, y = event.x(), event.y()
modifiers = event.modifiers()
self.pressed = False
if event.button() == Qt.LeftButton:
if layer.maskIsEnabled \
and layer.getUpperVisibleStackIndex() != -1 \
and (window.btnValues['drawFG'] or window.btnValues['drawBG']):
layer.applyToStack()
if img.isMouseSelectable:
# click event
if self.clicked:
x_img, y_img = (x - img.xOffset) / r, (y - img.yOffset) / r
# read input and current colors from active layer (coordinates are relative to the full-sized image)
clr = img.getActivePixel(x_img, y_img, qcolor=True)
clrC = img.getActivePixel(x_img,
y_img,
fromInputImg=False,
qcolor=True)
red, green, blue = clr.red(), clr.green(), clr.blue()
# read color from presentation layer
redP, greenP, blueP = img.getPrPixel(x_img, y_img)
# color chooser : when visible the colorPicked signal is not emitted
if getattr(window, 'colorChooser',
None) and window.colorChooser.isVisible():
if modifiers == Qt.ControlModifier | Qt.ShiftModifier: # (modifiers & Qt.ControlModifier) and (modifiers & Qt.ShiftModifier):
window.colorChooser.setCurrentColor(clr)
elif modifiers == Qt.ControlModifier: # modifiers & Qt.ControlModifier:
window.colorChooser.setCurrentColor(clrC)
else:
window.colorChooser.setCurrentColor(
QColor(redP, greenP, blueP))
else:
# emit colorPicked signal
layer.colorPicked.sig.emit(x_img, y_img, modifiers)
# select grid node for 3DLUT form
if layer.is3DLUTLayer():
movedNodes = layer.getGraphicsForm(
).selectGridNode(red, green, blue)
if movedNodes:
layer.applyToStack()
# rectangle selection
if window.btnValues['rectangle'] and (
modifiers == Qt.ControlModifier):
layer.rect = None
layer.selectionChanged.sig.emit()
# Flood fill tool
if layer.isDrawLayer() and window.btnValues['bucket']:
if getattr(window, 'colorChooser', None):
bucketColor = window.colorChooser.selectedColor(
)
else:
bucketColor = Qt.black
bLUeFloodFill(layer, int(x_img), int(y_img),
bucketColor)
layer.applyToStack()
"""
# for raw layer, set multipliers to get selected pixel as White Point : NOT USED YET
if layer.isRawLayer() and window.btnValues['colorPicker']:
# get demosaic buffer and sample raw pixels
bufRaw = layer.parentImage.demosaic
nb = QRect(x_img-2, y_img-2, 4, 4)
r = QImage.rect(layer.parentImage).intersected(nb)
if not r.isEmpty():
color = np.sum(bufRaw[r.top():r.bottom()+1, r.left():r.right()+1], axis=(0, 1))/(r.width()*r.height())
else:
color = bufRaw[y_img, x_img, :]
color = [color[i] - layer.parentImage.rawImage.black_level_per_channel[i] for i in range(3)]
form = layer.getGraphicsForm()
if form.sampleMultipliers:
row, col = 3*y_img//layer.height(), 3*x_img//layer.width()
if form.samples:
form.setRawMultipliers(*form.samples[3*row + col], sampling=False)
else:
form.setRawMultipliers(1/color[0], 1/color[1], 1/color[2], sampling=True)
"""
else: # not clicked
if window.btnValues['rectangle']:
layer.selectionChanged.sig.emit()
# cloning layer
elif layer.isCloningLayer():
if layer.vlChanged:
# the virtual layer was moved : clone
layer.applyCloning(seamless=True,
showTranslated=True,
moving=True)
layer.vlChanged = False
# updates
self.repaint()
# sync split views
linked = True
if self.objectName() == 'label_2':
self.splitWin.syncSplitView(window.label_3, window.label_2, linked)
window.label_3.repaint()
elif self.objectName() == 'label_3':
self.splitWin.syncSplitView(window.label_2, window.label_3, linked)
window.label_2.repaint()
def wheelEvent(self, event):
"""
Mouse wheel event handler : zooming
for imImage objects.
@param event: mouse wheel event
@type event: QWheelEvent
"""
img = self.img
window = self.window
pos = event.pos()
modifiers = event.modifiers()
# delta unit is 1/8 of degree
# Most mice have a resolution of 15 degrees
numSteps = event.delta() / 1200.0
layer = img.getActiveLayer()
if modifiers == Qt.NoModifier:
img.Zoom_coeff *= (1.0 + numSteps)
# max Zoom for previews
if img.Zoom_coeff > MAX_ZOOM:
img.Zoom_coeff /= (1.0 + numSteps)
return
# correct image offset to keep unchanged the image point
# under the cursor : (pos - offset) / resize_coeff is invariant
img.xOffset = -pos.x() * numSteps + (1.0 + numSteps) * img.xOffset
img.yOffset = -pos.y() * numSteps + (1.0 + numSteps) * img.yOffset
if layer.isDrawLayer() and (window.btnValues['brushButton']
or window.btnValues['eraserButton']):
self.syncBrush(img.resize_coeff(self))
if window.btnValues['Crop_Button']:
window.cropTool.drawCropTool(img)
if layer.isGeomLayer():
# layer.view.widget().tool.moveRotatingTool()
layer.tool.moveRotatingTool()
elif modifiers == Qt.ControlModifier:
layer.Zoom_coeff *= (1.0 + numSteps)
layer.updatePixmap()
# cloning layer zoom
elif layer.isCloningLayer(
) and modifiers == Qt.ControlModifier | Qt.AltModifier:
layer.AltZoom_coeff *= (1.0 + numSteps)
layer.applyCloning(
seamless=False, showTranslated=True,
moving=True) # autocloning (seamless=true) too slow
self.repaint()
# sync split views
linked = True
if self.objectName() == 'label_2':
self.splitWin.syncSplitView(window.label_3, window.label_2, linked)
window.label_3.repaint()
elif self.objectName() == 'label_3':
self.splitWin.syncSplitView(window.label_2, window.label_3, linked)
window.label_2.repaint()
def enterEvent(self, event):
"""
Mouse enter event handler
@param event:
@type event
"""
if not self.enterAndLeave:
return
window = self.window
if QApplication.overrideCursor():
# don't stack multiple cursors
return
# tool cursors
w = window.verticalSlider1.value()
layer = window.label.img.getActiveLayer()
if window.btnValues['drawFG'] or window.btnValues['drawBG']:
if w > 10:
QApplication.setOverrideCursor(
QCursor(window.cursor_Circle_Pixmap.scaled(
w * 2.0, w * 2.0),
hotX=w,
hotY=w))
else:
QApplication.setOverrideCursor(Qt.CrossCursor)
elif layer.isDrawLayer() and (window.btnValues['brushButton']
or window.btnValues['eraserButton']):
self.syncBrush(self.img.resize_coeff(self))
elif window.btnValues['drag']:
QApplication.setOverrideCursor(Qt.OpenHandCursor)
elif window.btnValues['colorPicker']:
if layer.isAdjustLayer():
if layer.view.isVisible():
QApplication.setOverrideCursor(window.cursor_EyeDropper)
def leaveEvent(self, event):
if not self.enterAndLeave:
return
QApplication.restoreOverrideCursor()
"""
def __movePaint(self, x, y, r, radius, pxmp=None):
Private drawing function.
Base function for painting tools. The radius and pixmap
of the tool are passed by the parameters radius and pxmp.
Starting coordinates of the move are recorded in State, ending coordinates
are passed by parameters x, y.
Brush tips are drawn on the intermediate layer self.stroke,
using self.qp.
Successive brush tips, spaced by 0.25 * radius, are paint on qp.
Note that self.qp must have been previously activated.
@param x: move event x-coord
@type x: float
@param y: move event y-coord
@type y: float
@param r: image resizing coeff
@type r: float
@param radius: tool radius
@type radius: float
@param pxmp: brush pixmap
@type pxmp: QPixmap
@return: last painted position
@rtype: 2-uple of float
img = self.img
State = self.State
qp = self.qp
tmp_x = (x - img.xOffset) // r
tmp_y = (y - img.yOffset) // r
# vector of the move
a_x, a_y = tmp_x - State['x_imagePrecPos'], tmp_y - State['y_imagePrecPos']
# move length : use 1-norm for performance
d = sqrt(a_x * a_x + a_y * a_y)
spacing, jitter = State['brush']['spacing'], State['brush']['jitter']
step = 1 if d == 0 else radius * 0.3 * spacing / d # 0.25
if jitter != 0.0:
step *= (1.0 + choice(brushFamily.jitterRange) * jitter / 100.0)
p_x, p_y = State['x_imagePrecPos'], State['y_imagePrecPos']
if d != 0.0:
cosTheta, sinTheta = a_x / d, a_y / d
transform = QTransform(cosTheta, sinTheta, -sinTheta, cosTheta, 0, 0) # Caution: angles > 0 correspond to counterclockwise rotations of pxmp
pxmp = pxmp.transformed(transform)
count = 0
maxCount = int( 1.0 / step)
while count < maxCount:
count += 1
if pxmp is None:
qp.drawEllipse(QPointF(p_x, p_y), radius, radius)
else:
qp.drawPixmap(QPointF(p_x - radius, p_y - radius), pxmp) # TODO radius added 19/03/20 validate
p_x, p_y = p_x + a_x * step, p_y + a_y * step
# return last painted position
return p_x, p_y
"""
def __strokePaint(self, layer, x, y, r):
"""
Private drawing function. Should be called only by the mouse event handler
@param layer:
@type layer:
@param x:
@type x:
@param y:
@type y:
@param r:
@type r:
"""
img = self.img
State = self.State
qp = self.qp
# get image coordinates
x_img = (x - img.xOffset) // r
y_img = (y - img.yOffset) // r
# draw the stroke
if self.window.btnValues['brushButton']:
# drawing onto stroke intermediate layer
qp.begin(layer.stroke)
qp.setCompositionMode(qp.CompositionMode_SourceOver)
# draw move
State['x_imagePrecPos'], State[
'y_imagePrecPos'] = brushFamily.brushStrokeSeg(
qp, State['x_imagePrecPos'], State['y_imagePrecPos'],
x_img, y_img, State['brush'])
qp.end()
# draw texture aligned with image
strokeTex = layer.stroke
p = State['brush']['pattern']
if p is not None:
if p.pxmp is not None:
strokeTex = layer.stroke.copy()
qp1 = QPainter(strokeTex)
qp1.setCompositionMode(qp.CompositionMode_DestinationIn)
qp1.setBrush(QBrush(p.pxmp))
qp1.fillRect(
QRect(0, 0, strokeTex.width(), strokeTex.height()),
QBrush(p.pxmp))
qp1.end()
# restore source image and paint
# the whole stroke with current brush opacity.
# Restoring source image enables iterative calls showing
# stroke progress
qp.begin(layer.sourceImg)
qp.setCompositionMode(qp.CompositionMode_Source)
qp.drawImage(QPointF(), layer.strokeDest)
qp.setOpacity(State['brush']['opacity'])
qp.setCompositionMode(qp.CompositionMode_SourceOver)
qp.drawImage(QPointF(), strokeTex) # layer.stroke)
qp.end()
elif self.window.btnValues['eraserButton']:
qp.begin(layer.sourceImg)
qp.setCompositionMode(qp.CompositionMode_DestinationIn)
State['x_imagePrecPos'], State[
'y_imagePrecPos'] = brushFamily.brushStrokeSeg(
qp, State['x_imagePrecPos'], State['y_imagePrecPos'],
x_img, y_img, State['brush'])
qp.end()
# update layer - should be layer.applyToStack() if any upper layer visible : too slow !
layer.execute()
img.prLayer.update()
self.window.label.repaint()
class RegisterView(QWidget, DockContextHandler):
dirty_color = QBrush(QColor(255, 153, 51))
symbolic_color = QBrush(QColor(245, 66, 72))
no_color = QBrush(QColor(255, 255, 255))
def __init__(self, parent, name, data):
QWidget.__init__(self, parent)
DockContextHandler.__init__(self, self, name)
self.parent = parent
self.arch = None
self.current_state = None
self.symb_idx = 0
self.reg_to_index = dict()
self.index_to_reg = dict()
self.reg_cache = dict()
self.data = data
self.tab_name = None
self.actionHandler = UIActionHandler()
self.actionHandler.setupActionHandler(self)
self._layout = QVBoxLayout()
# Set up register table
self._table = QTableWidget()
self._table.setColumnCount(2)
self._table.setHorizontalHeaderLabels(['Register', 'Value'])
self._table.horizontalHeader().setStretchLastSection(True)
self._table.verticalHeader().setVisible(False)
self._table.setContextMenuPolicy(Qt.CustomContextMenu)
self._table.customContextMenuRequested.connect(
self.on_customContextMenuRequested)
self._table.doubleClicked.connect(self.on_doubleClick)
self._layout.addWidget(self._table)
self.setLayout(self._layout)
def reset(self):
self.tab_name = None
self.arch = None
self.reg_to_index = dict()
self.symb_idx = 0
self._table.setRowCount(0)
def init(self, arch, state):
self.arch = arch
self.tab_name = _normalize_tab_name(self.parent.getTabName())
regs = self.arch.reg_names()
self._table.setRowCount(len(regs))
for i, reg in enumerate(regs):
self.reg_to_index[reg] = i
self.index_to_reg[i] = reg
self._table.setItem(i, 0, _makewidget(self, reg))
self._table.setItem(i, 1, _makewidget(self, ""))
self.set_reg_values(state)
def set_reg_value(self, reg, value, color=None):
assert self.arch is not None
idx = self.reg_to_index[reg]
if symbolic(value):
if isinstance(value, BVS):
val_str = value.name
else:
val_str = "< symbolic expression >"
if color is None:
color = RegisterView.symbolic_color
else:
val_str = "0x{obj:0{width}x}".format(obj=value.value,
width=(value.size + 3) // 4)
self.reg_cache[reg] = val_str
table_item = self._table.item(idx, 1)
table_item.setText(val_str)
if color is not None:
table_item.setForeground(color)
else:
table_item.setForeground(self.no_color)
def set_reg_values(self, state):
self.current_state = state
for reg in self.reg_to_index:
val = getattr(state.regs, reg)
self.set_reg_value(reg, val)
# right click menu
def on_customContextMenuRequested(self, pos):
item = self._table.itemAt(pos)
if item is None:
return
row_idx = item.row()
if self.index_to_reg[row_idx] == self.arch.getip_reg():
return
expr = getattr(self.current_state.regs, self.index_to_reg[row_idx])
menu = QMenu()
show_reg_expr = menu.addAction(
"Show reg expression") if not isinstance(expr, BVV) else None
make_reg_symb = menu.addAction("Make reg symbolic") if isinstance(
expr, BVV) else None
set_reg_value = menu.addAction("Set reg value")
eval_with_sol = menu.addAction(
"Evaluate with solver") if not isinstance(expr, BVV) else None
eval_upto_with_sol = menu.addAction(
"Evaluate upto with solver") if not isinstance(expr, BVV) else None
concretize = menu.addAction("Concretize") if not isinstance(
expr, BVV) else None
copy = menu.addAction("Copy to clipboard") if not isinstance(
expr, BVS) else None
bind_to_buffer = menu.addAction("Bind to symbolic buffer")
action = menu.exec_(self._table.viewport().mapToGlobal(pos))
if action is None:
return
if action == bind_to_buffer:
buffer_names = [
b[0].name for b in self.current_state.symbolic_buffers
]
if len(buffer_names) == 0:
return
buff_id = get_choice_input("Select a buffer", "choices",
buffer_names)
address = self.current_state.symbolic_buffers[buff_id][1]
buff_p = BVV(address, self.current_state.arch.bits())
setattr(self.current_state.regs, self.index_to_reg[row_idx],
buff_p)
self.set_reg_value(self.index_to_reg[row_idx], buff_p,
RegisterView.dirty_color)
if action == show_reg_expr:
show_message_box("Reg Expression", str(expr.z3obj.sexpr()))
if action == make_reg_symb:
new_expr = BVS('symb_injected_through_ui_%d' % self.symb_idx,
expr.size)
setattr(self.current_state.regs, self.index_to_reg[row_idx],
new_expr)
self.set_reg_value(self.index_to_reg[row_idx], new_expr,
RegisterView.dirty_color)
self.symb_idx += 1
if action == set_reg_value:
self.on_doubleClick(item)
if action == eval_with_sol:
expr = getattr(self.current_state.regs, self.index_to_reg[row_idx])
if not self.current_state.solver.symbolic(expr):
new_expr = self.current_state.solver.evaluate(expr)
setattr(self.current_state.regs, self.index_to_reg[row_idx],
new_expr)
self.set_reg_value(self.index_to_reg[row_idx], new_expr,
RegisterView.dirty_color)
show_message_box(
"Reg Value (with solver)",
"The value was indeed concrete! State modified")
else:
show_message_box(
"Reg Value (with solver)",
hex(self.current_state.solver.evaluate(expr).value))
if action == eval_upto_with_sol:
expr = getattr(self.current_state.regs, self.index_to_reg[row_idx])
if not self.current_state.solver.symbolic(expr):
new_expr = self.current_state.solver.evaluate(expr)
setattr(self.current_state.regs, self.index_to_reg[row_idx],
new_expr)
self.set_reg_value(self.index_to_reg[row_idx], new_expr,
RegisterView.dirty_color)
show_message_box(
"Reg Value (with solver)",
"The value was indeed concrete! State modified")
else:
n_eval = get_int_input("How many values (upto) ?",
"Number of distinct values")
r = ""
for i, v in enumerate(
self.current_state.solver.evaluate_upto(expr, n_eval)):
r += "solution %d: %s\n" % (i, hex(v.value))
show_message_box("Reg Value (with solver)", r)
if action == concretize:
expr = getattr(self.current_state.regs, self.index_to_reg[row_idx])
new_expr = self.current_state.solver.evaluate(expr)
res = get_choice_input(
"Concretize %s to %s?" %
(self.index_to_reg[row_idx], hex(new_expr.value)),
"Concretize", ["Yes", "No"])
if res == 0:
setattr(self.current_state.regs, self.index_to_reg[row_idx],
new_expr)
self.current_state.solver.add_constraints(expr == new_expr)
self.set_reg_value(self.index_to_reg[row_idx], new_expr,
RegisterView.dirty_color)
if action == copy:
mime = QMimeData()
if isinstance(expr, BVV):
mime.setText(hex(expr.value))
else:
mime.setText(str(expr.z3obj.sexpr()))
QApplication.clipboard().setMimeData(mime)
# double click event
def on_doubleClick(self, item):
row_idx = item.row()
if self.index_to_reg[row_idx] == self.arch.getip_reg():
return
old_expr = getattr(self.current_state.regs, self.index_to_reg[row_idx])
new_val = get_int_input("value for %s" % self.index_to_reg[row_idx],
"Set Reg")
if new_val is None:
return
new_expr = BVV(new_val, old_expr.size)
setattr(self.current_state.regs, self.index_to_reg[row_idx], new_expr)
self.set_reg_value(self.index_to_reg[row_idx], new_expr,
RegisterView.dirty_color)
def notifyOffsetChanged(self, offset):
pass
def shouldBeVisible(self, view_frame):
if view_frame is None:
return False
elif self.tab_name is None:
return False
elif _normalize_tab_name(view_frame.getTabName()) != self.tab_name:
return False
return True
def notifyViewChanged(self, view_frame):
if view_frame is None:
pass
else:
pass
def contextMenuEvent(self, event):
self.m_contextMenuManager.show(self.m_menu, self.actionHandler)
def __strokePaint(self, layer, x, y, r):
"""
Private drawing function. Should be called only by the mouse event handler
@param layer:
@type layer:
@param x:
@type x:
@param y:
@type y:
@param r:
@type r:
"""
img = self.img
State = self.State
qp = self.qp
# get image coordinates
x_img = (x - img.xOffset) // r
y_img = (y - img.yOffset) // r
# draw the stroke
if self.window.btnValues['brushButton']:
# drawing onto stroke intermediate layer
qp.begin(layer.stroke)
qp.setCompositionMode(qp.CompositionMode_SourceOver)
# draw move
State['x_imagePrecPos'], State[
'y_imagePrecPos'] = brushFamily.brushStrokeSeg(
qp, State['x_imagePrecPos'], State['y_imagePrecPos'],
x_img, y_img, State['brush'])
qp.end()
# draw texture aligned with image
strokeTex = layer.stroke
p = State['brush']['pattern']
if p is not None:
if p.pxmp is not None:
strokeTex = layer.stroke.copy()
qp1 = QPainter(strokeTex)
qp1.setCompositionMode(qp.CompositionMode_DestinationIn)
qp1.setBrush(QBrush(p.pxmp))
qp1.fillRect(
QRect(0, 0, strokeTex.width(), strokeTex.height()),
QBrush(p.pxmp))
qp1.end()
# restore source image and paint
# the whole stroke with current brush opacity.
# Restoring source image enables iterative calls showing
# stroke progress
qp.begin(layer.sourceImg)
qp.setCompositionMode(qp.CompositionMode_Source)
qp.drawImage(QPointF(), layer.strokeDest)
qp.setOpacity(State['brush']['opacity'])
qp.setCompositionMode(qp.CompositionMode_SourceOver)
qp.drawImage(QPointF(), strokeTex) # layer.stroke)
qp.end()
elif self.window.btnValues['eraserButton']:
qp.begin(layer.sourceImg)
qp.setCompositionMode(qp.CompositionMode_DestinationIn)
State['x_imagePrecPos'], State[
'y_imagePrecPos'] = brushFamily.brushStrokeSeg(
qp, State['x_imagePrecPos'], State['y_imagePrecPos'],
x_img, y_img, State['brush'])
qp.end()
# update layer - should be layer.applyToStack() if any upper layer visible : too slow !
layer.execute()
img.prLayer.update()
self.window.label.repaint()
app = QApplication(sys.argv)
customPlot = QCustomPlot()
customPlot.resize(800, 600)
customPlot.setWindowTitle('Scatter Pixmap Demo')
customPlot.axisRect().setBackground(QPixmap("./solarpanels.jpg"))
customPlot.addGraph()
customPlot.graph().setLineStyle(QCPGraph.lsLine)
pen = QPen()
pen.setColor(QColor(255, 200, 20, 200))
pen.setStyle(Qt.DashLine)
pen.setWidthF(2.5)
customPlot.graph().setPen(pen)
customPlot.graph().setBrush(QBrush(QColor(255, 200, 20, 70)))
customPlot.graph().setScatterStyle(QCPScatterStyle(QPixmap("./sun.png")))
# set graph name, will show up in legend next to icon:
customPlot.graph().setName("Data from Photovoltaic\nenergy barometer 2011")
# set data:
year = [2005, 2006, 2007, 2008, 2009, 2010, 2011]
value = [2.17, 3.42, 4.94, 10.38, 15.86, 29.33, 52.1]
customPlot.graph().setData(year, value)
font = QFont("sans", 12, QFont.Bold)
text = QCPTextElement(customPlot, "Regenerative Energies", font)
# set title of plot:
customPlot.plotLayout().insertRow(0)
customPlot.plotLayout().addElement(0, 0, text)
# axis configurations:
customPlot.xAxis.setLabel("Year")
def draw(self, qp, fps, objs, x0, y0, image):
#qp.setWindow(x0, y0, self.w_,self.h_) # 设置窗口
# 画框架背景
qp.setBrush(QColor('#cecece')) # 框架背景色
qp.setPen(Qt.NoPen)
rect = QRect(x0, y0, self.w_, self.h_)
qp.drawRect(rect)
sw, sh = self.w_, self.h_ # 图像窗口宽高
sh -= 40
pw, ph = 0, 0 # 缩放后的QPixmap大小
# 画图
yh = 0
if image is not None:
ih, iw, _ = image.shape
self.scale = sw / iw if sw / iw < sh / ih else sh / ih # 缩放比例
yh = round((self.h_ - 40 - ih * self.scale) / 2)
#print(yh)
qimage = QImage(image.data, iw, ih, 3 * iw,
QImage.Format_RGB888) # 转QImage
qpixmap = QPixmap.fromImage(
qimage.scaled(self.w_, self.h_ - 40,
Qt.KeepAspectRatio)) # 转QPixmap
pw, ph = qpixmap.width(), qpixmap.height()
#print(pw,ph)
qp.drawPixmap(0 + x0, y0 + yh + 40, qpixmap)
font = QFont()
font.setFamily('Microsoft YaHei')
if fps > 0:
font.setPointSize(14)
qp.setFont(font)
pen = QPen()
pen.setColor(Qt.white)
qp.setPen(pen)
qp.drawText(self.w_ - 150 + x0, y0 + 20,
'FPS: ' + str(round(fps, 2)))
# 画目标框
pen = QPen()
pen.setWidth(2) # 边框宽度
person = 0
hat = 0
for obj in objs:
if obj["class"] == "person":
person += 1
else:
hat += 1
font.setPointSize(10)
qp.setFont(font)
rgb = [round(c) for c in obj['color']]
pen.setColor(QColor(rgb[0], rgb[1], rgb[2])) # 边框颜色
brush1 = QBrush(Qt.NoBrush) # 内部不填充
qp.setBrush(brush1)
qp.setPen(pen)
# 坐标 宽高
tx, ty = round(pw * obj['x']), yh + round(ph * obj['y'])
tw, th = round(pw * obj['w']), round(ph * obj['h'])
obj_rect = QRect(tx + x0, y0 + ty + 40, tw, th)
qp.drawRect(obj_rect) # 画矩形框
# 画 类别 和 置信度
qp.drawText(x0 + tx, y0 + ty + 40 - 5,
str(obj['class']) + str(round(obj['confidence'], 2)))
if fps > 0:
pen = QPen()
pen.setColor(Qt.red)
font.setPointSize(14)
qp.setFont(font)
qp.setPen(pen)
qp.drawText(0 + x0, y0 + 20,
"there are {0} person".format(person + hat))
qp.drawText(
x0 + 0, y0 + 40,
"{0} people did not wear safety helmets".format(person))
