def main(argv):
app = QApplication(argv)
scene = QGraphicsScene(0, 0, 500, 500)
scene.setItemIndexMethod(QGraphicsScene.NoIndex)
brush = QBrush(Qt.red)
brush_brics = QBrush(QPixmap('brick_texture.jpg'))
brush_brics.setStyle(Qt.TexturePattern)
pen = QPen()
pen.setWidth(5)
pen.setStyle(Qt.DashLine)
rectItem = RectItem('r1', 20, 10, 200, 100)
rectItem.setBrush(brush)
rectItem2 = RectItem('r2', 20, 10, 150, 250)
rectItem2.setPen(pen)
rectItem2.setBrush(brush_brics)
rectItem2.setOpacity(70)
arrowItem = ArrowItem(QLine(50, 200, 300, 400))
scene.addItem(arrowItem)
scene.addItem(rectItem)
scene.addItem(rectItem2)
view = QGraphicsView(scene)
view.show()
return app.exec_()
def testCustomScene(self): # For PYSIDE-868, see above
scene = CustomScene()
view = QGraphicsView(scene)
view.show()
while scene.dpi == 0:
QApplication.instance().processEvents()
view.hide()
class Main_Window(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.image = QPixmap("sec_shield.png")
self.item = QGraphicsPixmapItem(self.image)
self.scene = QGraphicsScene()
self.scene.addItem(self.item)
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.view.show()
def test_setParentItem(self):
global qgraphics_item_painted
scene = QGraphicsScene()
scene.addText("test")
view = QGraphicsView(scene)
rect = self.createRoundRect(scene)
view.show()
QTimer.singleShot(1000, self.quit_app)
self.app.exec_()
self.assertTrue(qgraphics_item_painted)
def test_setParentItem(self):
global qgraphics_item_painted
scene = QGraphicsScene()
scene.addText("test")
view = QGraphicsView(scene)
rect = self.createRoundRect(scene)
view.show()
QTimer.singleShot(1000, self.quit_app)
self.app.exec_()
self.assert_(qgraphics_item_painted)
def testIt(self):
scene = QGraphicsScene()
minSize = QSizeF(30, 100)
prefSize = QSizeF(210, 100)
maxSize = QSizeF(300, 100)
a = createItem(minSize, prefSize, maxSize, "A")
b = createItem(minSize, prefSize, maxSize, "B")
c = createItem(minSize, prefSize, maxSize, "C")
d = createItem(minSize, prefSize, maxSize, "D")
view = QGraphicsView(scene)
view.show()
self.app.exec_()
def testIt(self):
scene = QGraphicsScene()
minSize = QSizeF(30, 100)
prefSize = QSizeF(210, 100)
maxSize = QSizeF(300, 100)
a = createItem(minSize, prefSize, maxSize, "A")
b = createItem(minSize, prefSize, maxSize, "B")
c = createItem(minSize, prefSize, maxSize, "C")
d = createItem(minSize, prefSize, maxSize, "D")
view = QGraphicsView(scene)
view.show()
self.app.exec_()
def testQGraphicsProxyWidget(self):
scene = QGraphicsScene()
proxy = QGraphicsProxyWidget(None, Qt.Window)
widget = QLabel('Widget')
proxy.setWidget(widget)
proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
scene.addItem(proxy)
scene.setSceneRect(scene.itemsBoundingRect())
view = QGraphicsView(scene)
view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.show()
timer = QTimer.singleShot(100, self.app.quit)
self.app.exec_()
def testQGraphicsProxyWidget(self):
scene = QGraphicsScene()
proxy = QGraphicsProxyWidget(None, Qt.Window)
widget = QLabel('Widget')
proxy.setWidget(widget)
proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
scene.addItem(proxy)
scene.setSceneRect(scene.itemsBoundingRect())
view = QGraphicsView(scene)
view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.show()
timer = QTimer.singleShot(100, self.app.quit)
self.app.exec_()
class CroppingImageWidget(QtWidgets.QWidget):
def __init__(self, cam_item, parent=None):
super(CroppingImageWidget, self).__init__(parent)
self._set_layout()
self._camera_item = cam_item
if DARK_THEME:
self._set_dark_theme()
self._create_items(cam_item)
self.scene.setSceneRect(cam_item.boundingRect())
def _create_items(self, cam_item):
l = 0.2 * cam_item.boundingRect().width()
r = 0.8 * cam_item.boundingRect().width()
t = 0.2 * cam_item.boundingRect().height()
b = 0.8 * cam_item.boundingRect().height()
cropper = CropperGraphicsItem(cam_item, l, r, t, b)
offset = 1000
self.line_left = CroppingLineGraphicsItem(
l,
-offset,
cam_item.boundingRect().height() + 2 * offset,
0,
r,
vertical=True)
self.line_right = CroppingLineGraphicsItem(
r,
-offset,
cam_item.boundingRect().height() + 2 * offset,
l,
cam_item.boundingRect().width(),
vertical=True)
self.line_top = CroppingLineGraphicsItem(
t, -offset,
cam_item.boundingRect().width() + 2 * offset, 0, b)
self.line_bottom = CroppingLineGraphicsItem(
b, -offset,
cam_item.boundingRect().width() + 2 * offset, t,
cam_item.boundingRect().height())
self.line_left.changed_pos_sig.changed_pos_sig.connect(
cropper.on_left_changed)
self.line_right.changed_pos_sig.changed_pos_sig.connect(
cropper.on_right_changed)
self.line_top.changed_pos_sig.changed_pos_sig.connect(
cropper.on_top_changed)
self.line_bottom.changed_pos_sig.changed_pos_sig.connect(
cropper.on_bottom_changed)
for line in [
self.line_left, self.line_right, self.line_top,
self.line_bottom
]:
line.changed_pos_sig.changed_pos_sig.connect(self.scene.update)
for item in [
cam_item, cropper, self.line_left, self.line_right,
self.line_top, self.line_bottom
]:
self.scene.addItem(item)
self.line_left.changed_pos_sig.changed_pos_sig.connect(
self.line_right.set_min)
self.line_right.changed_pos_sig.changed_pos_sig.connect(
self.line_left.set_max)
self.line_top.changed_pos_sig.changed_pos_sig.connect(
self.line_bottom.set_min)
self.line_bottom.changed_pos_sig.changed_pos_sig.connect(
self.line_top.set_max)
def resizeEvent(self, event):
"""
ResiczeEvent do nadpisania w qgraphicsView
"""
self.graphics_view.fitInView(self._camera_item.boundingRect(),
Qt.KeepAspectRatio)
QGraphicsView.resizeEvent(self.graphics_view, event)
def _set_layout(self):
"""
tworzy layout okna i tyle
"""
self.layout = QGridLayout()
self.scene = QGraphicsScene(self)
self.graphics_view = QGraphicsView(self)
self.graphics_view.setScene(self.scene)
self.graphics_view.show()
self.layout.addWidget(self.graphics_view, 0, 0)
self.setLayout(self.layout)
self.graphics_view.resizeEvent = self.resizeEvent
def _set_dark_theme(self):
"""
ustawia piekny ciemny motyw
"""
qApp = QtWidgets.qApp
qApp.setStyle("Fusion")
default_font = QtWidgets.qApp.font()
default_font.setPointSize(default_font.pointSize() + 2)
qApp.setFont(default_font)
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(30, 30, 30))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
qApp.setPalette(dark_palette)
qApp.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }"
)
def get_border(self):
"""
zwraca zaznaczony/skrojony prostokat
"""
return (self.line_left.get_pos(), self.line_right.get_pos(),
self.line_top.get_pos(), self.line_bottom.get_pos())
class MainWindow(QMainWindow): # Main window
def __init__(self):
super().__init__()
self.setWindowTitle = 'DD烤肉机'
self.resize(1870, 820)
self.mainWidget = QWidget()
self.mainLayout = QGridLayout() # Grid layout
self.mainLayout.setSpacing(10)
self.mainWidget.setLayout(self.mainLayout)
self.duration = 60000
self.bitrate = 2000
self.fps = 60
self.initProcess = InitProcess()
self.previewSubtitle = PreviewSubtitle()
self.dnldWindow = YoutubeDnld()
self.exportWindow = exportSubtitle()
self.videoDecoder = VideoDecoder()
self.exportWindow.exportArgs.connect(self.exportSubtitle)
self.stack = QStackedWidget()
self.stack.setFixedWidth(1300)
self.mainLayout.addWidget(self.stack, 0, 0, 10, 8)
buttonWidget = QWidget()
buttonLayout = QHBoxLayout()
buttonWidget.setLayout(buttonLayout)
self.playButton = QPushButton('从本地打开')
self.playButton.clicked.connect(self.open)
self.playButton.setFixedWidth(400)
self.playButton.setFixedHeight(75)
self.dnldButton = QPushButton('Youtube下载器')
self.dnldButton.clicked.connect(self.popDnld)
self.dnldButton.setFixedWidth(400)
self.dnldButton.setFixedHeight(75)
buttonLayout.addWidget(self.playButton)
buttonLayout.addWidget(self.dnldButton)
self.stack.addWidget(buttonWidget)
self.videoPath = ''
self.videoWidth = 1920
self.videoHeight = 1080
self.globalInterval = 200
self.setPlayer()
self.setSubtitle()
self.setToolBar()
self.setCentralWidget(self.mainWidget)
self.playStatus = False
self.volumeStatus = True
self.volumeValue = 100
self.subSelectedTxt = ''
self.subReplayTime = 1
self.clipBoard = []
self.grabKeyboard()
self.show()
def setPlayer(self):
self.playerWidget = QGraphicsVideoItem()
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.resize(1280, 730)
self.scene.addItem(self.playerWidget)
self.stack.addWidget(self.view)
self.player = QMediaPlayer(self, QMediaPlayer.VideoSurface)
self.player.setVideoOutput(self.playerWidget)
self.view.installEventFilter(self)
self.view.show()
self.srtTextItemDict = {0: QGraphicsTextItem(), 1: QGraphicsTextItem(), 2: QGraphicsTextItem(), 3: QGraphicsTextItem(), 4: QGraphicsTextItem()}
for _, srtTextItem in self.srtTextItemDict.items():
self.scene.addItem(srtTextItem)
def setSubtitle(self):
self.subtitleDict = {x: {-1: [100, '']} for x in range(5)}
self.subTimer = QTimer()
self.subTimer.setInterval(100)
self.subtitle = QTableWidget()
self.subtitle.setAutoScroll(False)
self.subtitle.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.mainLayout.addWidget(self.subtitle, 0, 8, 10, 12)
self.subtitle.setColumnCount(5)
self.subtitle.selectRow(0)
self.subtitle.setHorizontalHeaderLabels(['%s' % (i + 1) for i in range(5)])
self.subtitle.setVerticalHeaderLabels([cnt2Time2(i, self.globalInterval) for i in range(self.subtitle.rowCount())])
for index in range(5):
self.subtitle.setColumnWidth(index, 130)
self.subtitle.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.subtitle.setEditTriggers(QAbstractItemView.DoubleClicked)
self.subtitle.horizontalHeader().sectionClicked.connect(self.addSubtitle)
self.subtitle.doubleClicked.connect(self.releaseKeyboard)
self.subtitle.cellChanged.connect(self.subEdit)
self.subtitle.verticalHeader().sectionClicked.connect(self.subHeaderClick)
self.subtitle.setContextMenuPolicy(Qt.CustomContextMenu)
self.subtitle.customContextMenuRequested.connect(self.popTableMenu)
self.initSubtitle()
def initSubtitle(self):
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
for x in range(self.subtitle.columnCount()):
for y in range(self.subtitle.rowCount()):
self.subtitle.setSpan(y, x, 1, 1)
self.subtitle.setRowCount(self.duration // self.globalInterval + 1)
for x in range(self.subtitle.columnCount()):
for y in range(self.subtitle.rowCount()):
self.subtitle.setItem(y, x, QTableWidgetItem(''))
self.subtitle.item(y, x).setBackground(QBrush(QColor('#232629')))
self.subtitle.setVerticalHeaderLabels([cnt2Time2(i, self.globalInterval) for i in range(self.subtitle.rowCount())])
self.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
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()
def subTimeOut(self):
fontColor = self.previewSubtitle.fontColor
fontSize = (self.previewSubtitle.fontSize + 5) / 2.5
fontBold = self.previewSubtitle.bold
fontItalic = self.previewSubtitle.italic
fontShadowOffset = self.previewSubtitle.shadowOffset
for _, srtTextItem in self.srtTextItemDict.items():
srtTextItem.setDefaultTextColor(fontColor)
font = QFont()
font.setFamily("微软雅黑")
font.setPointSize(fontSize)
font.setBold(fontBold)
font.setItalic(fontItalic)
srtTextItem.setFont(font)
srtTextShadow = QGraphicsDropShadowEffect()
srtTextShadow.setOffset(fontShadowOffset)
srtTextItem.setGraphicsEffect(srtTextShadow)
try:
selected = self.subtitle.selectionModel().selection().indexes()
for x, i in enumerate(selected):
if self.subtitle.item(i.row(), x):
txt = self.subtitle.item(i.row(), x).text()
if txt:
self.srtTextItemDict[x].setPlainText('#%s：' % (x + 1) + txt)
txtSize = self.srtTextItemDict[x].boundingRect().size()
posY = self.playerWidget.size().height() - txtSize.height() * (x + 1)
posX = (self.playerWidget.size().width() - txtSize.width()) / 2
self.srtTextItemDict[x].setPos(posX, posY)
else:
self.srtTextItemDict[x].setPlainText('')
else:
self.srtTextItemDict[x].setPlainText('')
except:
pass
def subHeaderClick(self, index):
if self.player.duration():
position = index * self.globalInterval
self.player.setPosition(position)
self.videoSlider.setValue(position * 1000 // self.player.duration())
self.setTimeLabel()
def subEdit(self, row, index):
repeat = self.subtitle.rowSpan(row, index)
self.setSubtitleDict(row, index, repeat, self.subtitle.item(row, index).text())
self.subtitle.cellChanged.disconnect(self.subEdit)
for cnt in range(repeat):
if self.subtitle.item(row + cnt, index).text():
self.subtitle.item(row, index).setBackground(QBrush(QColor('#35545d')))
else:
self.subtitle.item(row, index).setBackground(QBrush(QColor('#232629')))
self.subtitle.cellChanged.connect(self.subEdit)
def setSubtitleDict(self, row, index, num, text):
self.subtitleDict[index][row * self.globalInterval] = [num * self.globalInterval, text]
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 setToolBar(self):
'''
menu bar, file menu, play menu, tool bar.
'''
toolBar = QToolBar()
self.setContextMenuPolicy(Qt.NoContextMenu)
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu('&文件')
openAction = QAction(QIcon.fromTheme('document-open'), '&打开...', self, shortcut=QKeySequence.Open, triggered=self.open)
fileMenu.addAction(openAction)
downloadAction = QAction(QIcon.fromTheme('document-open'), '&Youtube下载器', self, triggered=self.popDnld)
fileMenu.addAction(downloadAction)
exitAction = QAction(QIcon.fromTheme('application-exit'), '&退出', self, shortcut='Ctrl+Q', triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu('&功能')
self.playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.playAction = toolBar.addAction(self.playIcon, '播放')
self.playAction.triggered.connect(self.mediaPlay)
self.volumeIcon = self.style().standardIcon(QStyle.SP_MediaVolume)
self.volumeMuteIcon = self.style().standardIcon(QStyle.SP_MediaVolumeMuted)
self.volumeAction = toolBar.addAction(self.volumeIcon, '静音')
self.volumeAction.triggered.connect(self.volumeMute)
previewAction = QAction(QIcon.fromTheme('document-open'), '&设置预览字幕', self, triggered=self.popPreview)
playMenu.addAction(previewAction)
decodeMenu = self.menuBar().addMenu('&输出')
decodeAction = QAction(QIcon.fromTheme('document-open'), '&输出字幕及视频', self, triggered=self.decode)
decodeMenu.addAction(decodeAction)
self.volSlider = Slider()
self.volSlider.setOrientation(Qt.Horizontal)
self.volSlider.setMinimum(0)
self.volSlider.setMaximum(100)
self.volSlider.setFixedWidth(120)
self.volSlider.setValue(self.player.volume())
self.volSlider.setToolTip(str(self.volSlider.value()))
self.volSlider.pointClicked.connect(self.setVolume)
toolBar.addWidget(self.volSlider)
self.videoPositionEdit = LineEdit('00:00')
self.videoPositionEdit.setAlignment(Qt.AlignRight)
self.videoPositionEdit.setFixedWidth(75)
self.videoPositionEdit.setFont(QFont('Timers', 14))
self.videoPositionEdit.clicked.connect(self.mediaPauseOnly)
self.videoPositionEdit.editingFinished.connect(self.mediaPlayOnly)
self.videoPositionLabel = QLabel(' / 00:00 ')
self.videoPositionLabel.setFont(QFont('Timers', 14))
toolBar.addWidget(QLabel(' '))
toolBar.addWidget(self.videoPositionEdit)
toolBar.addWidget(self.videoPositionLabel)
self.timer = QTimer()
self.timer.setInterval(100)
self.videoSlider = Slider()
self.videoSlider.setEnabled(False)
self.videoSlider.setOrientation(Qt.Horizontal)
self.videoSlider.setMinimum(0)
self.videoSlider.setMaximum(1000)
self.videoSlider.setFixedWidth(1000)
self.videoSlider.sliderMoved.connect(self.timeStop)
self.videoSlider.sliderReleased.connect(self.timeStart)
self.videoSlider.pointClicked.connect(self.videoSliderClick)
toolBar.addWidget(self.videoSlider)
toolBar.addWidget(QLabel(' '))
self.globalIntervalComBox = QComboBox()
self.globalIntervalComBox.addItems(['间隔 100ms', '间隔 200ms', '间隔 500ms', '间隔 1s'])
self.globalIntervalComBox.setCurrentIndex(1)
self.globalIntervalComBox.currentIndexChanged.connect(self.setGlobalInterval)
toolBar.addWidget(self.globalIntervalComBox)
toolBar.addWidget(QLabel(' '))
self.subEditComBox = QComboBox()
self.refreshComboBox()
toolBar.addWidget(self.subEditComBox)
toolBar.addWidget(QLabel(' '))
moveForward = QPushButton('- 1')
moveForward.setFixedWidth(50)
toolBar.addWidget(moveForward)
toolBar.addWidget(QLabel(' '))
moveAfterward = QPushButton('+ 1')
moveAfterward.setFixedWidth(50)
toolBar.addWidget(moveAfterward)
toolBar.addWidget(QLabel(' '))
clearSub = QPushButton('清空')
clearSub.setFixedWidth(50)
toolBar.addWidget(clearSub)
toolBar.addWidget(QLabel(' '))
outputSub = QPushButton('裁剪')
outputSub.setFixedWidth(50)
toolBar.addWidget(outputSub)
moveForward.clicked.connect(self.moveForward)
moveAfterward.clicked.connect(self.moveAfterward)
clearSub.clicked.connect(self.clearSub)
outputSub.clicked.connect(self.exportSubWindow)
def setGlobalInterval(self, index):
if not self.playStatus:
self.mediaPlay()
self.globalInterval = {0: 100, 1: 200, 2: 500, 3: 1000}[index]
self.initSubtitle()
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
for index, subData in self.subtitleDict.items():
for start, rowData in subData.items():
startRow = start // self.globalInterval
deltaRow = rowData[0] // self.globalInterval
if deltaRow:
endRow = startRow + deltaRow
for row in range(startRow, endRow):
self.subtitle.setItem(row, index, QTableWidgetItem(rowData[1]))
if row >= 0:
self.subtitle.item(row, index).setBackground(QBrush(QColor('#35545d')))
self.subtitle.setSpan(startRow, index, endRow - startRow, 1)
self.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
def moveForward(self):
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
index = self.subEditComBox.currentIndex()
for y in range(self.subtitle.rowCount()):
self.subtitle.setSpan(y, index, 1, 1)
self.subtitle.setItem(y, index, QTableWidgetItem(''))
self.subtitle.item(y, index).setBackground(QBrush(QColor('#232629')))
tmpDict = self.subtitleDict[index]
self.subtitleDict[index] = {}
for start, rowData in tmpDict.items():
self.subtitleDict[index][start - self.globalInterval] = rowData
for start, rowData in self.subtitleDict[index].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.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
def moveAfterward(self):
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
index = self.subEditComBox.currentIndex()
for y in range(self.subtitle.rowCount()):
self.subtitle.setSpan(y, index, 1, 1)
self.subtitle.setItem(y, index, QTableWidgetItem(''))
self.subtitle.item(y, index).setBackground(QBrush(QColor('#232629')))
tmpDict = self.subtitleDict[index]
self.subtitleDict[index] = {}
for start, rowData in tmpDict.items():
self.subtitleDict[index][start + self.globalInterval] = rowData
for start, rowData in self.subtitleDict[index].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.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
def clearSub(self):
index = self.subEditComBox.currentIndex()
reply = QMessageBox.information(self, '清空字幕', '清空第 %s 列字幕条？' % (index + 1), QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
self.subtitleDict[index] = {0: [self.globalInterval, '']}
for i in range(self.subtitle.rowCount()):
self.subtitle.setSpan(i, index, 1, 1)
self.subtitle.setItem(i, index, QTableWidgetItem(''))
self.subtitle.item(i, index).setBackground(QBrush(QColor('#232629')))
self.subtitle.setHorizontalHeaderItem(index, QTableWidgetItem('%s' % (index + 1)))
self.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
def exportSubWindow(self, start=0, end=0, index=None):
self.releaseKeyboard()
self.exportWindow.hide()
self.exportWindow.show()
start = '00:00.0' if not start else self.splitTime(start)
end = self.splitTime(self.duration) if not end else self.splitTime(end)
if not index:
index = self.subEditComBox.currentIndex() + 1
self.exportWindow.setDefault(start, end, index)
def exportSubtitle(self, exportArgs):
start = calSubTime2(exportArgs[0])
end = calSubTime2(exportArgs[1])
subStart = calSubTime2(exportArgs[2])
index = exportArgs[3] - 1
subData = self.subtitleDict[index]
rowList = sorted(subData.keys())
exportRange = []
for t in rowList:
if t >= start and t <= end:
exportRange.append(t)
subNumber = 1
with open(exportArgs[-1], 'w', encoding='utf-8') as exportFile:
for t in exportRange:
text = subData[t][1]
if text:
start = ms2Time(t + subStart)
end = ms2Time(t + subStart + subData[t][0])
exportFile.write('%s\n%s --> %s\n%s\n\n' % (subNumber, start, end, text))
subNumber += 1
QMessageBox.information(self, '导出字幕', '导出完成', QMessageBox.Yes)
self.exportWindow.hide()
def refreshComboBox(self):
self.subEditComBox.clear()
for i in range(self.subtitle.columnCount()):
self.subEditComBox.addItem('字幕 ' + str(i + 1))
def open(self):
self.videoPath = QFileDialog.getOpenFileName(self, "请选择视频文件", None, "MP4格式 (*.mp4);;所有文件(*.*)")[0]
if self.videoPath:
cmd = ['utils/ffmpeg.exe', '-i', self.videoPath]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
p.wait()
for l in p.stdout.readlines():
l = l.decode('utf8')
if 'Duration' in l:
self.duration = calSubTime(l.split(' ')[3][:-1])
if 'Stream' in l and 'DAR' in l:
self.videoWidth, self.videoHeight = map(int, l.split(' [')[0].split(' ')[-1].split('x'))
args = l.split(',')
for cnt, arg in enumerate(args):
if 'kb' in arg:
self.bitrate = int(arg.split('kb')[0])
self.fps = int(args[cnt + 1].split('fps')[0])
break
break
self.initProcess.show()
self.subtitle.cellChanged.disconnect(self.subEdit)
self.subtitle.setRowCount(self.duration // self.globalInterval + 1)
self.subtitle.setVerticalHeaderLabels([cnt2Time2(i, self.globalInterval) for i in range(self.subtitle.rowCount())])
self.subtitle.cellChanged.connect(self.subEdit)
self.initProcess.hide()
url = QUrl.fromLocalFile(self.videoPath)
self.stack.setCurrentIndex(1)
self.playerWidget.setSize(QSizeF(1280, 720))
self.player.setMedia(url)
self.playStatus = True
self.videoSlider.setEnabled(True)
self.mediaPlay()
self.timer.start()
self.timer.timeout.connect(self.timeOut)
self.subTimer.start()
self.subTimer.timeout.connect(self.subTimeOut)
def popDnld(self):
self.releaseKeyboard()
self.dnldWindow.hide()
self.dnldWindow.show()
def popPreview(self):
self.releaseKeyboard()
self.previewSubtitle.hide()
self.previewSubtitle.show()
def decode(self):
self.releaseKeyboard()
self.videoDecoder.setDefault(self.videoPath, self.videoWidth, self.videoHeight, self.duration, self.bitrate, self.fps, self.subtitleDict)
self.videoDecoder.hide()
self.videoDecoder.show()
def mediaPlay(self):
if self.playStatus:
self.player.play()
self.grabKeyboard()
self.timeStart()
self.playStatus = False
self.playAction.setIcon(self.pauseIcon)
self.playAction.setText('暂停')
else:
self.player.pause()
self.timeStop()
self.playStatus = True
self.playAction.setIcon(self.playIcon)
self.playAction.setText('播放')
def mediaPlayOnly(self):
self.grabKeyboard()
try:
timeText = self.videoPositionEdit.text().split(':')
m, s = timeText[:2]
if not m:
m = '00'
if not s:
s = '00'
if len(m) > 3:
m = m[:3]
if len(s) > 2:
s = s[:2]
if m.isdigit():
m = int(m)
if s.isdigit():
s = int(s)
if s > 60:
s = 60
total_m = self.player.duration() // 60000
if m > total_m:
m = total_m
self.player.setPosition(m * 60000 + s * 1000)
self.videoSlider.setValue(self.player.position() * 1000 / self.player.duration())
except:
pass
self.videoPositionEdit.setReadOnly(True)
self.timeStart()
def mediaPauseOnly(self):
self.releaseKeyboard()
self.videoPositionEdit.setReadOnly(False)
self.player.pause()
self.timeStop()
self.playStatus = True
self.playAction.setIcon(self.playIcon)
self.playAction.setText('播放')
def splitTime(self, playTime):
playTime = playTime // 1000
m = str(playTime // 60)
s = playTime % 60
s = ('0%s' % s)[-2:]
if len(m) > 2:
t = '%3s:%2s' % (m, s)
else:
t = '%2s:%2s' % (m, s)
return t
def timeOut(self):
row = self.player.position() // self.globalInterval
self.subtitle.selectRow(row)
self.subtitle.verticalScrollBar().setValue(row - 10)
if self.dnldWindow.isHidden() or self.exportWindow.isHidden() or self.videoDecoder.isHidden():
self.grabKeyboard()
try:
self.videoSlider.setValue(self.player.position() * 1000 / self.player.duration())
self.setTimeLabel()
except:
pass
def timeStop(self):
self.timer.stop()
def timeStart(self):
self.timer.start()
def videoSliderClick(self, p):
self.videoSlider.setValue(p.x())
self.player.setPosition(p.x() * self.player.duration() // 1000)
self.setTimeLabel()
def setVolume(self, p):
self.volumeValue = p.x()
if self.volumeValue > 100:
self.volumeValue = 100
if self.volumeValue < 0:
self.volumeValue = 0
self.volSlider.setValue(self.volumeValue)
self.player.setVolume(self.volumeValue)
self.volSlider.setToolTip(str(self.volSlider.value()))
if self.volumeValue:
self.volumeStatus = True
self.volumeAction.setIcon(self.volumeIcon)
else:
self.volumeStatus = False
self.volumeAction.setIcon(self.volumeMuteIcon)
def volumeMute(self):
if self.volumeStatus:
self.volumeStatus = False
self.old_volumeValue = self.player.volume()
self.player.setVolume(0)
self.volSlider.setValue(0)
self.volumeAction.setIcon(self.volumeMuteIcon)
else:
self.volumeStatus = True
self.player.setVolume(self.old_volumeValue)
self.volSlider.setValue(self.old_volumeValue)
self.volumeAction.setIcon(self.volumeIcon)
def setTimeLabel(self):
now = self.player.position()
total = self.player.duration()
now = self.splitTime(now)
total = self.splitTime(total)
self.videoPositionEdit.setText(now)
self.videoPositionLabel.setText(' / %s ' % total)
def eventFilter(self, obj, event):
if obj == self.view:
if event.type() == QEvent.MouseButtonPress:
self.mediaPlay()
return QMainWindow.eventFilter(self, obj, event)
def keyPressEvent(self, QKeyEvent):
key = QKeyEvent.key()
if key == Qt.Key_Left:
if self.videoSlider.isEnabled():
self.player.setPosition(self.player.position() - 5000)
self.videoSlider.setValue(self.player.position() * 1000 / self.player.duration())
self.setTimeLabel()
elif key == Qt.Key_Right:
if self.videoSlider.isEnabled():
self.player.setPosition(self.player.position() + 5000)
self.videoSlider.setValue(self.player.position() * 1000 / self.player.duration())
self.setTimeLabel()
elif key == Qt.Key_Up:
self.volumeValue += 10
if self.volumeValue > 100:
self.volumeValue = 100
self.volSlider.setValue(self.volumeValue)
self.player.setVolume(self.volumeValue)
elif key == Qt.Key_Down:
self.volumeValue -= 10
if self.volumeValue < 0:
self.volumeValue = 0
self.volSlider.setValue(self.volumeValue)
self.player.setVolume(self.volumeValue)
elif key == Qt.Key_Space:
self.mediaPlay()
print(f'Rect Pos: {rectItem.pos()}')
textItem = QGraphicsSimpleTextItem("Foundation of Qt")
scene.addItem(textItem)
print(f'Text Pos: {textItem.pos()}')
textItem.setPos(50, 0)
print(f'Text Pos: {textItem.pos()}')
ellipseItem = QGraphicsEllipseItem(QRectF(170, 20, 100, 75))
ellipseItem.setPen(QPen(Qt.darkBlue))
ellipseItem.setBrush(Qt.blue)
scene.addItem(ellipseItem)
points = [
QPointF(10, 10),
QPointF(0, 90),
QPointF(40, 70),
QPointF(80, 110),
QPointF(70, 20)
]
polygonItem = QGraphicsPolygonItem(QPolygonF(points))
polygonItem.setPen(QPen(Qt.darkGreen))
polygonItem.setBrush(Qt.yellow)
scene.addItem(polygonItem)
view = QGraphicsView()
view.setScene(scene)
view.show()
sys.exit(app.exec_())
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.index_districts = index_districts
self.x1 = ""
self.x3 = ""
self.y1 = ""
self.y3 = ""
self.scene = QGraphicsScene()
self.image = QGraphicsView(self.scene)
self.image.show()
self.submitButton = QPushButton("Submit")
self.undoButton = QPushButton("Undo")
self.nextReport = QPushButton("Next Report")
self.badButton = QPushButton("BAD")
self.goodButton = QPushButton("Good")
self.noDataButton = QPushButton("No Data")
self.districtText = QLineEdit("")
self.cattleLabel = QLineEdit("Cattle:")
self.top = QHBoxLayout()
self.top.addWidget(self.cattleLabel)
self.prevPageButton = QPushButton("Previous Page")
self.nextPageButton = QPushButton("Next Page")
self.middle = QVBoxLayout()
self.left = QHBoxLayout()
self.middle.setMargin(10)
self.middle.addWidget(self.image)
self.middle.addLayout(self.top)
self.middle.addLayout(self.left)
self.bottom = QHBoxLayout()
self.left.addWidget(self.prevPageButton)
self.left.addWidget(self.nextPageButton)
self.middle.addWidget(self.districtText)
self.bottom.addWidget(self.badButton)
self.bottom.addWidget(self.noDataButton)
self.bottom.addWidget(self.goodButton)
self.bottom.addWidget(self.nextReport)
self.bottom.addWidget(self.undoButton)
self.bottom.addWidget(self.submitButton)
self.middle.addLayout(self.bottom)
# QWidget Layout
self.layout = QHBoxLayout()
self.layout.addLayout(self.middle)
# Set the layout to the QWidget
self.setLayout(self.layout)
# second
# self.data_path = "../Crop_Reports/Manual Check Crop Reports/crop_reports_verified.csv"
# self.data = pd.read_csv(self.data_path)
self.dir_path = "../Crop_Reports/Bengal Crop Reports PNG/"
# connect functions
self.nextReport.clicked.connect(self.ignore)
self.submitButton.clicked.connect(self.submit)
self.undoButton.clicked.connect(self.undo)
self.nextPageButton.clicked.connect(self.nextImage)
self.prevPageButton.clicked.connect(self.prevImage)
self.crop_index = 0
self.page_index = 0
self.zoom = .2
self.out_folder = "../Crop_Reports/Bengal Famine Data/"
self.finished = os.listdir(self.out_folder)
self.data = pd.read_csv("../Crop_Reports/Manual Check Crop Reports/crop_reports_verified_cleaned_is_good.csv")
self.data.Date = pd.to_datetime(self.data.Date)
self.data = self.data[(self.data.Date > start_date) & (self.data.Date < end_date)]
self.columns = ["District","Date","famine_code"]
self.bound_data = pd.DataFrame(columns = self.columns)
self.bound_data_text = ""
self.ocr_data_list = list()
data = self.data
for string in self.finished:
string = string.split(".")[0]
data = data[data.Path != string]
self.reports = list(data.Path)
self.dates = list(data.Date)
print(u"Data index:",data.index)
self.remain_string = "remaining folders " + str(len(self.reports))
self.remainingLabel = QLabel(self.remain_string)
self.left.addWidget(self.remainingLabel)
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
self.report = os.listdir(temp_path)
#self.forceLastImage()
self.postImage()
# Sets up drawing capabilities:
self.image.setMouseTracking(True)
self.image.viewport().installEventFilter(self)
self.start = None
self.end = None
#something
#self.draw_boxes()
# error here, disregarded bc why not? :)
def eventFilter(self, source, event):
if event.type() == QtCore.QEvent.MouseButtonRelease and source is self.image.viewport():
if event.button() == Qt.RightButton:
self.nextImage()
if event.button() == Qt.MidButton:
self.ignore()
if event.button() == Qt.LeftButton:
self.draw_bounding_box()
#print(event.pos())
#print(self.image.mapToScene(event.pos()))
@Slot()
def submit(self, famine_code):
self.postImage()
["District", "x1", "y1", "x3", "y3", "Date", "Raw_Text"]
row = {'District':self.districtText.text(),'Date':self.date,'famine_code': famine_code}
self.bound_data = self.bound_data.append(row, ignore_index= True)
print(self.bound_data)
self.districtText.setText("")
cattle_label_text = "Length: " + str(len(self.bound_data.famine_code)) + ". " + str(list(self.bound_data.famine_code))
self.cattleLabel.setText(cattle_label_text)
@Slot()
def undo(self):
print(self.bound_data)
self.bound_data.drop(self.bound_data.tail(1).index, inplace=True)
cattle_label_text = "Length: " + str(len(self.bound_data.famine_code)) + ". " + str(list(self.bound_data.famine_code))
self.cattleLabel.setText(cattle_label_text)
print(self.bound_data)
@Slot()
def ignore(self):
self.remain_string = "remaining folders " + str(len(self.reports)-self.crop_index-1)
self.remainingLabel.setText(self.remain_string)
path = self.out_folder + self.reports[self.crop_index] + ".csv"
print(u"out path:",path)
self.bound_data.District = self.index_districts
self.bound_data.to_csv(path, index= False)
self.bound_data = pd.DataFrame(columns = self.columns)
self.crop_index = self.crop_index + 1
self.page_index = 0
self.postImage()
#self.forceLastImage()
self.postImage()
@Slot()
def nextImage(self):
if ((len(self.report) - 1) > self.page_index):
self.page_index = self.page_index + 1
else:
self.page_index = 0
self.postImage()
@Slot()
def forceLastImage(self):
self.page_index = (len(self.report) - 1)
@Slot()
def prevImage(self):
if (1 > self.page_index):
self.page_index = len(self.report) - 1
else:
self.page_index = self.page_index - 1
self.postImage()
def postImage(self):
self.date = self.dates[self.crop_index]
print(u"Date:",self.date)
print(self.dates)
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
report = os.listdir(temp_path)
dt.sort_nicely(report)
self.report = report
self.ocr_data_list = dt.report_to_data(self.reports[self.crop_index])
if (len(self.report) > 0):
self.page = self.report[self.page_index]
self.page_df = self.ocr_data_list[self.page_index]
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index], self.page)
self.scene.clear()
self.pixmap = QPixmap(temp_path)
# adjusts zoom
self.pixmap = self.pixmap.scaled(self.pixmap.size().width() * self.zoom,
self.pixmap.size().height() * self.zoom,
Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
self.draw_bounding_box()
# def draw_bounding_box(self, x1, y1, x3, y3):
#
# start = self.image.mapToScene(x1,y1)
# end = self.image.mapToScene(x3,y3)
# len_x = end.x()-start.x()
# len_y = end.y()-start.y()
# rectItem = QGraphicsRectItem(start.x(), start.y(), len_x, len_y)
# self.scene.addItem(rectItem)
def draw_bounding_box(self):
df = self.page_df
scale = self.zoom
no_df = df[df.word=="redroverr2"]
tle_df = df[df.word.str.contains("suf", na = False)]
catt_df = df[df.word.str.contains("insuf", na=False)]
rinder_df = df[df.word.str.contains("ind1111er", na=False)]
for index, row in no_df.iterrows():
print(row)
x1 = row.x1*scale
y1 = row.y1*scale
x3= row.x3*scale
y3 = row.y3*scale
diff_x = x3-x1
diff_y = y3-y1
rectItem = QGraphicsRectItem(x1,y1,diff_x,diff_y)
rectItem.setBrush(QBrush(Qt.green))
#rectItem = QGraphicsRectItem(0, 0, 100, 100)
self.scene.addItem(rectItem)
for index, row in tle_df.iterrows():
print(row)
x1 = row.x1 * scale
y1 = row.y1 * scale
x3 = row.x3 * scale
y3 = row.y3 * scale
diff_x = x3 - x1
diff_y = y3 - y1
rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
rectItem.setBrush(QBrush(Qt.green))
# rectItem = QGraphicsRectItem(0, 0, 100, 100)
self.scene.addItem(rectItem)
for index, row in rinder_df.iterrows():
print(row)
x1 = row.x1 * scale
y1 = row.y1 * scale
x3 = row.x3 * scale
y3 = row.y3 * scale
diff_x = x3 - x1
diff_y = y3 - y1
rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
rectItem.setBrush(QBrush(Qt.red))
# rectItem = QGraphicsRectItem(0, 0, 100, 100)
self.scene.addItem(rectItem)
for index, row in catt_df.iterrows():
print(row)
x1 = row.x1 * scale
y1 = row.y1 * scale
x3 = row.x3 * scale
y3 = row.y3 * scale
diff_x = x3 - x1
diff_y = y3 - y1
rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
rectItem.setBrush(QBrush(Qt.red))
# rectItem = QGraphicsRectItem(0, 0, 100, 100)
self.scene.addItem(rectItem)
# divider_x = (max(df.x3)-min(df.x1))/2
# week_df = df[df.word.str.contains("icient", na=False)]
# for index, row in week_df.iterrows():
# week_anchor = row
#
# x1 = week_anchor.x1 * scale
# y1 = week_anchor.y1 * scale
# x3 = week_anchor.x3 * scale
# y3 = week_anchor.y3 * scale
# diff_x = x3 - x1
# diff_y = y3 - y1
# rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
# rectItem.setBrush(QBrush(Qt.blue))
# self.scene.addItem(rectItem)
# right_df = df[df.x1 > divider_x]
# right_df = right_df[right_df.y1 > week_anchor.y3]
# for index, row in right_df.iterrows():
# x1 = row.x1 * scale
# y1 = row.y1 * scale
# x3 = row.x3 * scale
# y3 = row.y3 * scale
# diff_x = x3 - x1
# diff_y = y3 - y1
#
# rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
# rectItem.setBrush(QBrush(Qt.red))
#
# self.scene.addItem(rectItem)
# for district in self.index_districts:
# print(district)
# row = df[df.word.str.contains(district, na=False)]
#
# if (len(row.word) != 0):
# x1 = row.x1 * scale
# y1 = row.y1 * scale
# x3 = row.x3 * scale
# y3 = row.y3 * scale
# diff_x = x3 - x1
# diff_y = y3 - y1
#
# rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
# rectItem.setBrush(QBrush(Qt.red))
#
# self.scene.addItem(rectItem)
# def write_to_csv(self):
# new_row = {'ocr_report_path': self.reports[self.crop_index], 'date': self.districtText.text()}
# self.data = self.data.append(new_row, ignore_index=True)
# self.data.to_csv(self.data_path, index=False)
# reformat first half of year 1910 before 10/6
def keyPressEvent(self, event):
if event.key() == Qt.Key_A:
#disease
self.submit("bad")
if event.key() == Qt.Key_W:
# no mention
self.submit("NR")
if event.key() == Qt.Key_D:
##not bad
self.submit("not_bad")
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
#Paths
self.folderPath = "../Crop_Reports/Bengal Crop Reports PNG/"
self.index = 0
self.page_index = 0
self.crop_report = ""
self.pixmap = QPixmap()
self.data = pd.read_csv("../Crop_Reports/Manual Check Crop Reports/crop_reports_verified.csv")
#choices
self.choices = listdir(self.folderPath)
self.scene = QGraphicsScene()
self.image = QGraphicsView(self.scene)
self.image.show()
self.submitButton = QPushButton("Submit")
self.dateText = QLineEdit("")
self.middle = QVBoxLayout()
self.middle.setMargin(10)
self.middle.addWidget(self.image)
self.middle.addWidget(self.dateText)
self.middle.addWidget(self.submitButton)
# QWidget Layout
self.layout = QHBoxLayout()
self.layout.addLayout(self.middle)
# Set the layout to the QWidget
self.setLayout(self.layout)
# Here we connect widgets to functions
self.submitButton.clicked.connect(self.submit)
# Here we add functions
@Slot()
def submit(self):
self.index = self.index+1
self.scene.clear()
temp_path = self.choices[self.index]
self.crop_report_pages = os.listdir(temp_path)
self.pixmap = QPixmap(temp_path)
self.scene.addPixmap(self.pixmap)
@Slot()
def nextPage(self):
self.page_index = self.page_index + 1
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.scene = QGraphicsScene()
self.image = QGraphicsView(self.scene)
self.image.show()
self.submitButton = QPushButton("Submit")
self.dateText = QLineEdit("")
self.prevPageButton = QPushButton("Previous Page")
self.nextPageButton = QPushButton("Next Page")
self.middle = QVBoxLayout()
self.left = QHBoxLayout()
self.middle.setMargin(10)
self.middle.addWidget(self.image)
self.middle.addLayout(self.left)
self.left.addWidget(self.prevPageButton)
self.left.addWidget(self.nextPageButton)
self.middle.addWidget(self.dateText)
self.middle.addWidget(self.submitButton)
# QWidget Layout
self.layout = QHBoxLayout()
self.layout.addLayout(self.middle)
# Set the layout to the QWidget
self.setLayout(self.layout)
#second
self.data_path = "../Crop_Reports/Manual Check Crop Reports/crop_reports_verified.csv"
self.data = pd.read_csv(self.data_path)
self.dir_path = "../Crop_Reports/Bengal Crop Reports PNG/"
#connect functions
self.submitButton.clicked.connect(self.submit)
self.nextPageButton.clicked.connect(self.nextImage)
self.prevPageButton.clicked.connect(self.prevImage)
self.crop_index = 0
self.page_index = 0
self.zoom = .2
self.reports = os.listdir(self.dir_path)
reports_already_done = set(self.data.ocr_report_path)
lst = self.reports
for finished in reports_already_done:
lst.remove(finished)
self.reports = lst
remain_string = "remaining folders " + str(len(self.reports))
self.remainingLabel = QLabel(remain_string)
self.left.addWidget(self.remainingLabel)
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
self.report = os.listdir(temp_path)
if (len(self.report) > 0):
self.page = self.report[self.page_index]
temp_path = os.path.join(self.dir_path,
self.reports[self.crop_index], self.page)
print(temp_path)
self.pixmap = QPixmap(temp_path)
self.scene.clear()
self.pixmap = QPixmap(temp_path)
#adjusts zoom
self.pixmap = self.pixmap.scaled(
self.pixmap.size().width() * self.zoom,
self.pixmap.size().height() * self.zoom, Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
#key bindings
def key_press(event):
key = event.char
print(key, 'is pressed')
@Slot()
def submit(self):
self.write_to_csv()
self.page_index = 0
self.crop_index = self.crop_index + 1
self.postImage()
self.dateText.setText("")
remain_string = "remaining folders " + str(
len(self.reports) - self.crop_index)
self.remainingLabel.setText(remain_string)
@Slot()
def nextImage(self):
if ((len(self.report) - 1) > self.page_index):
self.page_index = self.page_index + 1
else:
self.page_index = 0
self.postImage()
@Slot()
def prevImage(self):
if (1 > self.page_index):
self.page_index = len(self.report) - 1
else:
self.page_index = self.page_index - 1
self.postImage()
def postImage(self):
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
self.report = os.listdir(temp_path)
if (len(self.report) > 0):
print(self.page_index)
self.page = self.report[self.page_index]
temp_path = os.path.join(self.dir_path,
self.reports[self.crop_index], self.page)
print(temp_path)
self.scene.clear()
self.pixmap = QPixmap(temp_path)
#adjusts zoom
self.pixmap = self.pixmap.scaled(
self.pixmap.size().width() * self.zoom,
self.pixmap.size().height() * self.zoom, Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
def write_to_csv(self):
new_row = {
'ocr_report_path': self.reports[self.crop_index],
'date': self.dateText.text()
}
self.data = self.data.append(new_row, ignore_index=True)
self.data.to_csv(self.data_path, index=False)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Return:
self.submit()
class MainWindow(QMainWindow):
kill_thread = Signal()
def __init__(self, app):
self.app = app
# self.qmp = QMP('localhost', 55555)
self.qmp = QMP()
self.qmp.stateChanged.connect(self.handle_pause_button)
self.qmp.connectionChange.connect(self.handle_connect_button)
self.paused = False
super().__init__()
self.init_ui()
self.qmp.timeUpdate.connect(self.update_time)
self.t = TimeThread(self.qmp)
self.time_mult = TimeMultiplier(self.qmp, self.kill_thread)
self.window = []
self.default_theme = QGuiApplication.palette()
def init_ui(self):
# Window Setup
self.setWindowTitle("QEMU Control")
self.setGeometry(100, 100, 275, 225)
self.setFixedSize(self.size())
# App Icon
icon = QIcon('package/icons/qemu-official.png')
self.setWindowIcon(icon)
# User Interface
self.menu_bar()
self.grid_layout()
self.show()
def menu_bar(self):
bar = self.menuBar()
# Menu Bar Actions
file_ = bar.addMenu("File")
edit = bar.addMenu("Edit")
run = bar.addMenu("Run")
tools = bar.addMenu("Tools")
help_ = bar.addMenu("Help")
# File Menu Options
open_ = QAction("Open Image", self)
file_.addAction(open_)
exit_ = QAction("Exit", self)
exit_.triggered.connect(self.close)
exit_.setShortcut('Ctrl+W')
file_.addAction(exit_)
# Edit Menu Options
prefs = QAction("Preferences", self, triggered=lambda:self.open_new_window(Preferences(self.app, self.default_theme, self.qmp, self.t)))
edit.addAction(prefs)
# Run Menu Options
pause = QAction("Pause", self, triggered=lambda:self.qmp.command('stop'))
run.addAction(pause)
play = QAction("Play", self, triggered=lambda:self.qmp.command('cont'))
run.addAction(play)
# Debug Menu Options
hexdmp = QAction("Memory Dump", self, triggered=(lambda: self.open_new_window(MemDumpWindow(self.qmp)) if self.qmp.isSockValid() else None))
tools.addAction(hexdmp)
asm = QAction("Assembly View", self, triggered=(lambda: self.open_new_window(AssemblyWindow(self.qmp)) if self.qmp.isSockValid() else None))
tools.addAction(asm)
registers = QAction("CPU Register View", self, triggered=(lambda: self.open_new_window(RegisterView(self.qmp)) if self.qmp.isSockValid() else None))
tools.addAction(registers)
errors = QAction("Logging View", self, triggered=lambda:self.open_new_window(LoggingWindow(self.qmp)))
tools.addAction(errors)
tree = QAction("Memory Tree", self, triggered=(lambda: self.open_new_window(MemTree(self.qmp, self)) if self.qmp.isSockValid() else None))
tools.addAction(tree)
mult = QAction("Time Multiplier", self, triggered=(lambda: self.time_mult.show() if self.qmp.isSockValid() else None))
tools.addAction(mult)
trace = QAction("Trace Event Viewer", self, triggered=lambda: self.open_new_window(TraceWindow(self.qmp)))
tools.addAction(trace)
self.addPlugins(tools)
# Help Menu Options
usage = QAction("Usage Guide", self)
help_.addAction(usage)
def addPlugins(self, menu):
plugins = menu.addMenu('Plugins')
self.manager = PluginManager()
self.manager.setPluginPlaces(['plugins'])
self.manager.locatePlugins()
self.manager.loadPlugins()
for plugin in self.manager.getAllPlugins():
plugins.addAction(QAction(plugin.name, self, triggered=(lambda: self.open_new_window(plugin.plugin_object.display(self.qmp)) if self.qmp.isSockValid() else None)))
def grid_layout(self):
grid = QVBoxLayout()
grid.setSpacing(15)
self.pause_button = QPushButton('■')
self.running_state = QLabel('Current State: <font color="grey">Inactive</font>')
def cont_sim():
self.pause_button.setText('■')
self.running_state.setText('Current State: <font color="green">Running</font>')
self.qmp.command('cont')
def stop_sim():
self.pause_button.setText('▶')
self.running_state.setText('Current State: <font color="red">Paused</font>')
self.qmp.command('stop')
subgrid = QHBoxLayout()
self.pause_button.clicked.connect(lambda: stop_sim() if not self.paused else cont_sim())
self.pause_button.setFixedSize(QSize(50, 50))
subgrid.addWidget(self.pause_button, 0)
# self.pause_button.setCheckable(True)
# self.handle_pause_button(False)
self.pause_button.setEnabled(False)
meatball = QLabel(self)
logo = QPixmap('package/icons/nasa.png')
logo = logo.scaled(75, 75, Qt.KeepAspectRatio)
meatball.setPixmap(logo)
subgrid.addWidget(meatball, 1)
grid.addLayout(subgrid, 0)
self.time = QLabel('Time: 00:00:00')
self.time.setFont(QFont('Courier New'))
grid.addWidget(self.time, 1)
grid.addWidget(self.running_state, 2)
self.banner = QLabel('<font color="grey">Connect to QMP to get started!</font>')
grid.addWidget(self.banner, 3)
conn_grid = QHBoxLayout()
self.connect_button = QPushButton("Connect")
self.connect_button.setCheckable(True)
self.connect_button.clicked.connect(self.qmp_start)
self.host = QLineEdit()
self.host.returnPressed.connect(lambda: self.connect_button.click() if not self.connect_button.isChecked() else None)
self.port = QLineEdit()
self.port.returnPressed.connect(lambda: self.connect_button.click() if not self.connect_button.isChecked() else None)
conn_grid.addWidget(self.host)
conn_grid.addWidget(self.port)
conn_grid.addWidget(self.connect_button)
grid.addLayout(conn_grid)
center = QWidget()
center.setLayout(grid)
self.setCentralWidget(center)
def throwError(self):
msgBox = QMessageBox(self)
msgBox.setText('Lost Connection to QMP!')
msgBox.show()
@Slot(bool)
def handle_pause_button(self, value):
# Catches signals from QMPWrapper
#print('recieved: ', value)
# time.sleep(0.05) # fix race condition
if value:
self.paused = False
self.pause_button.setText('■')
self.running_state.setText('Current State: <font color="green">Running</font>')
elif not value and value is not None:
self.paused = True
self.pause_button.setText('▶')
self.running_state.setText('Current State: <font color="red">Paused</font>')
def handle_connect_button(self, value):
self.connect_button.setChecked(value)
self.host.setReadOnly(value)
self.port.setReadOnly(value)
def open_new_window(self, new_window):
if self.qmp.isSockValid():
self.window.append(new_window)
def update_time(self, time):
date = datetime.fromtimestamp(time / 1000000000, timezone.utc)
self.time.setText(f'Time: {date.day - 1:02}:{date.hour:02}:{date.minute:02}:{date.second:02}') # -1 for day because it starts from 1
def qmp_start(self):
if self.qmp.isSockValid():
self.qmp.sock_disconnect()
self.kill_thread.emit()
self.banner.setText('<font color="grey">Connect to QMP to get started!</font>')
self.pause_button.setText('■')
self.running_state.setText('Current State: <font color="grey">Inactive</font>')
self.pause_button.setEnabled(False)
return
else:
s = self.port.text()
if s.isnumeric():
self.qmp.sock_connect(self.host.text(), int(s))
if self.qmp.isSockValid():
self.time_mult.start()
self.banner.setText('QEMU Version ' + str(self.qmp.banner['QMP']['version']['package']))
self.pause_button.setEnabled(True)
else:
self.host.setText('127.0.0.1')
self.port.setText('55555')
self.qmp.sock_connect('127.0.0.1', 55555)
if self.qmp.isSockValid():
self.time_mult.start()
self.banner.setText('QEMU Version ' + str(self.qmp.banner['QMP']['version']['package']))
self.pause_button.setEnabled(True)
# check if running initally
if self.qmp.running:
self.paused = False
self.pause_button.setText('■')
self.running_state.setText('Current State: <font color="green">Running</font>')
else:
self.paused = True
self.pause_button.setText('▶')
self.running_state.setText('Current State: <font color="red">Paused</font>')
if not self.qmp.isAlive():
self.qmp.start()
if not self.t.isAlive():
self.t.start()
def closeEvent(self, event):
self.kill_thread.emit()
event.accept()
def show_time_mult(self):
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.scene.addItem(self.time_mult.chart)
self.view.show()
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.layout = QVBoxLayout()
#fix this
self.scale = 4.16
self.zoom = 2
self.anchor_list = []
self.top_anchor = []
self.bottom_anchor = []
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
# fix this
#self.filenames = ["../Other Data/Medical Data/nls-data-indiaPapers/91541450/image/" + x for x in os.listdir("../Other Data/Medical Data/nls-data-indiaPapers/91541450/image/")]
#"91541967.3",
# use write table no number
#self.filenames = ["91540775.3","91540907.3","91541048.3","91541159.3","91541336.3"]
self.filenames = ["91541574.3"]
self.filenames_full = [
"../Other Data/Medical Data/nls-data-indiaPapers/91541450/image/" +
x + ".jpg" for x in self.filenames
]
self.index = 0
self.jpg_path = self.filenames_full[self.index]
print(self.jpg_path)
self.xml = self.jpg_path.split(
"/image")[0] + "/alto/" + self.jpg_path.split("/image/")[1].split(
".")[0] + ".34.xml"
self.pixmap = QPixmap(self.jpg_path)
print(u"pixmap width height", self.pixmap.width())
self.pixmap = self.pixmap.scaled(
self.pixmap.size().width() * self.zoom,
self.pixmap.size().height() * self.zoom, Qt.KeepAspectRatio)
#only for images that need rotate
self.view.rotate(90)
self.data = self.getData()
self.scene.addPixmap(self.pixmap)
self.layout.addWidget(self.view)
self.b1 = QHBoxLayout()
self.b2 = QHBoxLayout()
self.b3 = QHBoxLayout()
self.yearLabel = QLabel("Year:")
self.yearEdit = QLineEdit()
self.yearSubmit = QPushButton("Submit Year")
self.b1.addWidget(self.yearLabel)
self.b1.addWidget(self.yearEdit)
self.b1.addWidget(self.yearSubmit)
self.topAnchorLabel = QLabel("Top Anchor: ")
self.topAnchorButton = QPushButton("Top Anchor")
self.b2.addWidget(self.topAnchorLabel)
self.b2.addWidget(self.topAnchorButton)
self.bottomAnchorLabel = QLabel("Bottom Anchor: ")
self.bottomAnchorButton = QPushButton("Bottom Anchor")
self.b3.addWidget(self.bottomAnchorLabel)
self.b3.addWidget(self.bottomAnchorButton)
self.layout.addLayout(self.b1)
self.layout.addLayout(self.b2)
self.layout.addLayout(self.b3)
self.submitButton = QPushButton("Submit")
self.layout.addWidget(self.submitButton)
self.setLayout(self.layout)
self.view.show()
# Sets up drawing capabilities:
self.view.setMouseTracking(True)
self.view.viewport().installEventFilter(self)
self.start = None
self.end = None
#connects to function
self.topAnchorButton.clicked.connect(self.topAnchorFunction)
self.bottomAnchorButton.clicked.connect(self.bottomAnchorFunction)
self.submitButton.clicked.connect(self.table_to_csv)
def eventFilter(self, source, event):
if event.type(
) == QtCore.QEvent.MouseButtonPress and source is self.view.viewport():
self.start = event.pos()
self.start = self.view.mapToScene(self.start)
print(u"mouse", self.start)
if event.type(
) == QtCore.QEvent.MouseButtonRelease and source is self.view.viewport(
):
self.end = event.pos()
self.end = self.view.mapToScene(self.end)
self.drawBox()
self.select_table()
def select_table(self):
data = self.data
data.HPOS = data.HPOS.astype(int)
data.VPOS = data.VPOS.astype(int)
x1 = self.start.x() * self.scale * (1 / self.zoom)
y1 = self.start.y() * self.scale * (1 / self.zoom)
x3 = self.end.x() * self.scale * (1 / self.zoom)
y3 = self.end.y() * self.scale * (1 / self.zoom)
table = data[(data.HPOS > x1) & (data.HPOS < x3) & (data.VPOS > y1) &
(data.VPOS < y3)]
my_list = self.anchor_list
my_list.append(table.CONTENT[0])
self.anchor_list = self.anchor_list
print(self.anchor_list)
@Slot()
def topAnchorFunction(self):
self.top_anchor = self.anchor_list
self.topAnchorLabel.setText(str(self.top_anchor))
self.anchor_list = []
@Slot()
def bottomAnchorFunction(self):
self.bottom_anchor = self.anchor_list
self.bottomAnchorLabel.setText(str(self.bottom_anchor))
self.anchor_list = []
@Slot()
def table_to_csv(self):
my.write_table_2(self.xml, self.top_anchor, self.bottom_anchor,
self.yearEdit.text(), self.jpg_path)
def drawBox(self):
x1 = self.start.x()
y1 = self.start.y()
x3 = self.end.x()
y3 = self.end.y()
diff_x = x3 - x1
diff_y = y3 - y1
rectItem = QGraphicsRectItem(x1, y1, diff_x, diff_y)
#rectItem.setBrush(QBrush(Qt.green))
self.scene.addItem(rectItem)
def getData(self):
# will replace with one
tree = ET.parse(self.xml)
root = tree.getroot()
NSMAP = {'mw': 'http://www.loc.gov/standards/alto/v3/alto.xsd'}
pass
all_name_elements = tree.findall('.//mw:TextLine', NSMAP)
base = list(all_name_elements[0].getchildren()[0].attrib.items())
column_names = pd.DataFrame(base,
columns=['key',
'value']).transpose().iloc[0]
master_df = pd.DataFrame()
i = 0
while i < len(all_name_elements):
data_list = list(
all_name_elements[i].getchildren()[0].attrib.items())
if len(column_names) == len(data_list):
df = pd.DataFrame(data_list, columns=['key', 'value'])
row = df.transpose().iloc[1]
master_df = master_df.append(row)
else:
print("Something wrong")
print(data_list)
i = i + 1
master_df = master_df.rename(columns=column_names)
return (master_df)
return
spread(-self._height / 2, self._inputPortGraphics)
spread(self._height / 2, self._outputPortGraphics)
def getHeight(self):
self.updateActionRect()
return self._height
def getWidth(self):
self.updateActionRect()
return self._width
if __name__ == "__main__":
app = QApplication()
v = QGraphicsView()
s = QGraphicsScene()
v.setScene(s)
action = ComponentAction()
p1 = Port()
p2 = Port()
p3 = Port()
action.addInputPort(p1)
action.addInputPort(p2)
action.addOutputPort(p3)
A = ActionGraphics(action)
s.addItem(A)
v.show()
sys.exit(app.exec_())
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.x1 = ""
self.x3 = ""
self.y1 = ""
self.y3 = ""
self.scene = QGraphicsScene()
self.image = QGraphicsView(self.scene)
self.image.show()
self.submitButton = QPushButton("Submit")
self.undoButton = QPushButton("Undo")
self.nextReport = QPushButton("Next Report")
self.districtText = QLineEdit("")
self.prevPageButton = QPushButton("Previous Page")
self.nextPageButton = QPushButton("Next Page")
self.middle = QVBoxLayout()
self.left = QHBoxLayout()
self.middle.setMargin(10)
self.middle.addWidget(self.image)
self.middle.addLayout(self.left)
self.bottom = QHBoxLayout()
self.left.addWidget(self.prevPageButton)
self.left.addWidget(self.nextPageButton)
self.middle.addWidget(self.districtText)
self.bottom.addWidget(self.nextReport)
self.bottom.addWidget(self.undoButton)
self.bottom.addWidget(self.submitButton)
self.middle.addLayout(self.bottom)
# QWidget Layout
self.layout = QHBoxLayout()
self.layout.addLayout(self.middle)
# Set the layout to the QWidget
self.setLayout(self.layout)
# second
# self.data_path = "../Crop_Reports/Manual Check Crop Reports/crop_reports_verified.csv"
# self.data = pd.read_csv(self.data_path)
self.dir_path = "../Crop_Reports/Bengal Crop Reports PNG/"
# connect functions
self.nextReport.clicked.connect(self.ignore)
self.submitButton.clicked.connect(self.submit)
self.undoButton.clicked.connect(self.undo)
self.nextPageButton.clicked.connect(self.nextImage)
self.prevPageButton.clicked.connect(self.prevImage)
self.crop_index = 0
self.page_index = 0
self.zoom = .125
self.out_folder = "../Crop_Reports/Bengal Crop Reports OCR Bounds/"
self.finished = os.listdir(self.out_folder)
self.data = pd.read_csv(
"../Crop_Reports/Manual Check Crop Reports/crop_reports_verified_cleaned_is_good.csv"
)
self.data.Date = pd.to_datetime(self.data.Date)
self.data = self.data[(self.data.Date > start_date)
& (self.data.Date < end_date)]
self.columns = ["District", "x1", "y1", "x3", "y3", "Date", "Raw_Text"]
self.bound_data = pd.DataFrame(columns=self.columns)
self.bound_data_text = ""
self.ocr_data_list = list()
data = self.data
for string in self.finished:
string = string.split(".")[0]
data = data[data.Path != string]
self.reports = list(data.Path)
self.dates = list(data.Date)
print(u"Data index:", data.index)
self.remain_string = "remaining folders " + str(len(self.reports))
self.remainingLabel = QLabel(self.remain_string)
self.left.addWidget(self.remainingLabel)
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
self.report = os.listdir(temp_path)
self.postImage()
# Sets up drawing capabilities:
self.image.setMouseTracking(True)
self.image.viewport().installEventFilter(self)
self.start = None
self.end = None
# error here, disregarded bc why not? :)
def eventFilter(self, source, event):
if event.type(
) == QtCore.QEvent.MouseButtonPress and source is self.image.viewport(
):
if self.start is None:
self.start = event.pos()
elif self.end is None:
self.end = event.pos()
self.draw_bounding_box()
else:
print("ERROR!")
#print(event.pos())
#print(self.image.mapToScene(event.pos()))
@Slot()
def submit(self):
self.postImage()
["District", "x1", "y1", "x3", "y3", "Date", "Raw_Text"]
row = {
'District': self.districtText.text(),
'x1': self.x1,
'y1': self.y1,
'x3': self.x3,
'y3': self.y3,
'Date': self.date,
'Raw_Text': self.bound_data_text
}
self.bound_data = self.bound_data.append(row, ignore_index=True)
print(self.bound_data)
self.districtText.setText("")
@Slot()
def undo(self):
print(self.bound_data)
self.bound_data.drop(self.bound_data.tail(1).index, inplace=True)
print(self.bound_data)
@Slot()
def ignore(self):
self.remain_string = "remaining folders " + str(
len(self.reports) - self.crop_index - 1)
self.remainingLabel.setText(self.remain_string)
path = self.out_folder + self.reports[self.crop_index] + ".csv"
print(u"out path:", path)
self.bound_data.to_csv(path, index=False)
self.bound_data = pd.DataFrame(columns=self.columns)
self.crop_index = self.crop_index + 1
self.page_index = 0
self.postImage()
@Slot()
def nextImage(self):
if ((len(self.report) - 1) > self.page_index):
self.page_index = self.page_index + 1
else:
self.page_index = 0
self.postImage()
@Slot()
def prevImage(self):
if (1 > self.page_index):
self.page_index = len(self.report) - 1
else:
self.page_index = self.page_index - 1
self.postImage()
def postImage(self):
self.date = self.dates[self.crop_index]
print(u"Date:", self.date)
print(self.dates)
temp_path = os.path.join(self.dir_path, self.reports[self.crop_index])
report = os.listdir(temp_path)
dt.sort_nicely(report)
self.report = report
self.ocr_data_list = dt.report_to_data(self.reports[self.crop_index])
if (len(self.report) > 0):
self.page = self.report[self.page_index]
self.page_df = self.ocr_data_list[self.page_index]
temp_path = os.path.join(self.dir_path,
self.reports[self.crop_index], self.page)
self.scene.clear()
self.pixmap = QPixmap(temp_path)
# adjusts zoom
self.pixmap = self.pixmap.scaled(
self.pixmap.size().width() * self.zoom,
self.pixmap.size().height() * self.zoom, Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
# def draw_bounding_box(self, x1, y1, x3, y3):
#
# start = self.image.mapToScene(x1,y1)
# end = self.image.mapToScene(x3,y3)
# len_x = end.x()-start.x()
# len_y = end.y()-start.y()
# rectItem = QGraphicsRectItem(start.x(), start.y(), len_x, len_y)
# self.scene.addItem(rectItem)
def draw_bounding_box(self):
#self.item = QGraphicsPixmapItem(QPixmap(self.df["image"].iloc[self.index]))
#self.scene.addItem(self.item)
start = self.image.mapToScene(self.start)
end = self.image.mapToScene(self.end)
self.startSceneLoc = start
self.endSceneLoc = end
df = self.page_df
scale = (1 / self.zoom)
self.x1 = start.x() * scale
#self.x3 = end.x()*scale
#Fixed x length
self.x3 = self.x1 + 250 * scale
self.y1 = start.y() * scale
self.y3 = end.y() * scale
df = df[(df.x1 > self.x1) & (df.x3 < self.x3) & (df.y1 > self.y1) &
(df.y3 < self.y3)]
print(u"x1:", self.x1, u" x3:", self.x3, u" y1:", self.y1, u" y3:",
self.y3, u" Scale:", scale)
print(u"Current image:", self.report[self.page_index],
u" Current df image:", df.image.unique())
print(df.word)
self.bound_data_text = " ".join(df.word.to_list())
diff_x = (self.x1 - self.x3) * self.zoom
diff_y = (self.y1 - self.y3) * self.zoom
rectItem = QGraphicsRectItem(start.x(), start.y(), -diff_x, -diff_y)
self.scene.addItem(rectItem)
self.start = None
self.end = None
# def write_to_csv(self):
# new_row = {'ocr_report_path': self.reports[self.crop_index], 'date': self.districtText.text()}
# self.data = self.data.append(new_row, ignore_index=True)
# self.data.to_csv(self.data_path, index=False)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Return:
self.submit()
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
#Paths
self.folderPath = "../Crop_Reports/Bengal Crop Reports PNG/"
self.pixmap = QPixmap()
#Creates Combobox Choice options
self.choices = listdir(self.folderPath)
#Creating widgets
#Left
self.choiceCombo = QComboBox()
self.choiceCombo.addItems(self.choices)
self.insertionsLabel = QLabel("Insertions")
self.insertions = QLineEdit("2")
self.substitutionsLabel = QLabel("Substitutions")
self.substitutions = QLineEdit("2")
self.deletionsLabel = QLabel("Deletions")
self.deletions = QLineEdit("2")
self.errorsLabel = QLabel("Errors")
self.errors = QLineEdit("2")
self.searchTextOutputLabel = QLabel("Search Results")
self.searchTextOutput = QTextEdit()
self.searchTextOutput.setReadOnly(True)
self.searchStringLabel = QLabel("Search for a word")
self.searchString = QLineEdit()
self.searchStringButton = QPushButton("Search")
#middle
self.nextImage = QPushButton("Next Image")
self.previousImage = QPushButton("Previous Image")
self.scene = QGraphicsScene()
self.image = QGraphicsView(self.scene)
self.image.show()
self.zoomIn = QPushButton("Zoom In")
self.zoomOut = QPushButton("Zoom Out")
self.left = QVBoxLayout()
self.left.setMargin(10)
self.left.addWidget(self.choiceCombo)
self.left.addWidget(self.insertionsLabel)
self.left.addWidget(self.insertions)
self.left.addWidget(self.substitutionsLabel)
self.left.addWidget(self.substitutions)
self.left.addWidget(self.deletionsLabel)
self.left.addWidget(self.deletions)
self.left.addWidget(self.errorsLabel)
self.left.addWidget(self.errors)
self.left.addWidget(self.searchTextOutputLabel)
self.left.addWidget(self.searchTextOutput)
self.left.addWidget(self.searchStringLabel)
self.left.addWidget(self.searchString)
self.left.addWidget(self.searchStringButton)
self.middle = QVBoxLayout()
self.middle.setMargin(10)
self.middle.addWidget(self.image)
self.middle.addWidget(self.nextImage)
self.middle.addWidget(self.previousImage)
self.middle.addWidget(self.zoomIn)
self.middle.addWidget(self.zoomOut)
# QWidget Layout
self.layout = QHBoxLayout()
self.layout.addLayout(self.left)
self.layout.addLayout(self.middle)
# Set the layout to the QWidget
self.setLayout(self.layout)
# Here we connect widgets to functions
self.searchStringButton.clicked.connect(self.search_data)
self.nextImage.clicked.connect(self.next_image)
self.previousImage.clicked.connect(self.previous_image)
self.zoomIn.clicked.connect(self.zoom_in)
self.zoomOut.clicked.connect(self.zoom_out)
# Here we add functions
@Slot()
def search_data(self):
mydata = self.data
results = (mydata[mydata["word"] == self.searchString.text()])
output = [
"(" + word + ", " + img + ") "
for word, img in zip(results["word"], results["shortName"])
]
print(output)
#resets search index to 0
self.searchIndex = 0
self.searchOutput = results
print(self.searchOutput)
self.searchTextOutput.setText(str(output))
@Slot()
def next_image(self):
self.searchIndex += 1
if self.searchIndex > len(self.searchOutput) - 1:
self.searchIndex = 0
@Slot()
def previous_image(self):
self.searchIndex -= 1
if self.searchIndex < 0:
self.searchIndex = len(self.searchOutput) - 1
@Slot()
def zoom_in(self):
self.scene.clear()
self.pixmap = self.pixmap.scaled(self.pixmap.size().width() * 1.25,
self.pixmap.size().height() * 1.25,
Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
@Slot()
def zoom_out(self):
self.scene.clear()
self.pixmap = self.pixmap.scaled(self.pixmap.size().width() * 0.8,
self.pixmap.size().height() * 0.8,
Qt.KeepAspectRatio)
self.scene.addPixmap(self.pixmap)
@Slot()
def post_image(self):
print("filler")
