class SessionParamWidget(Qt.QWidget): def __init__(self, parent=None): Qt.QWidget.__init__(self, parent) self.file_model = QFileSystemModel() def set_directory(self,directory): self.directory = directory self.file_model.setRootPath(directory) def setup_tree(self): self.folder_select_tree.setModel(self.file_model) self.folder_select_tree.setRootIndex(self.file_model.index(self.directory)); def connect_tree(self): self.folder_select_tree.clicked.connect(self.set_session_folder) def set_session_folder(self, index): indexItem = self.file_model.index(index.row(), 0, index.parent()) fileName = self.file_model.fileName(indexItem) filePath = self.file_model.filePath(indexItem) print(fileName) print(filePath)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'PyQt5 file system view - pythonspot.com'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.model = QFileSystemModel()
r_inx = self.model.setRootPath(".")
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setAnimated(False)
self.tree.setIndentation(15)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.resize(640, 480)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
print(self.model.rootPath())
print(self.model.filePath(self.model.parent(r_inx)))
index_temp = self.model.index(0, 0, QModelIndex())
print(self.model.fileName(index_temp))
self.show()
class QmyMainWindow(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.model = QFileSystemModel(self)
self.model.setRootPath(QDir.currentPath())
self.ui.qTreeView.setModel(self.model)
self.ui.qListView.setModel(self.model)
self.ui.qTableView.setModel(self.model)
self.ui.qTreeView.clicked.connect(self.ui.qListView.setRootIndex)
self.ui.qTreeView.clicked.connect(self.ui.qTableView.setRootIndex)
def on_qTreeView_clicked(self, index):
self.ui.qCheckBox.setChecked(self.model.isDir(index))
self.ui.qLabel1.setText(self.model.filePath(index))
self.ui.qLabel4.setText(self.model.type(index))
self.ui.qLabel2.setText(self.model.fileName(index))
fileSize = self.model.size(index)/1024
if(fileSize<1024):
self.ui.qLabel3.setText("%d KB" % fileSize)
else:
self.ui.qLabel3.setText("%.2f MB" % (fileSize/1024))
class QmyMainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui = Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
self.__buildModelView()
## ==============自定义功能函数============
def __buildModelView(self): ##构造Model/View 系统
self.model = QFileSystemModel(self)
self.model.setRootPath(QDir.currentPath())
self.ui.treeView.setModel(self.model) #设置数据模型
self.ui.listView.setModel(self.model)
self.ui.tableView.setModel(self.model)
self.ui.treeView.clicked.connect(self.ui.listView.setRootIndex)
self.ui.treeView.clicked.connect(self.ui.tableView.setRootIndex)
## ==========由connectSlotsByName() 自动连接的槽函数==================
def on_treeView_clicked(self, index): ##treeView单击
self.ui.chkBox_IsDir.setChecked(self.model.isDir(index)) #是否是目录
self.ui.LabPath.setText(self.model.filePath(index)) #目录名
self.ui.LabType.setText(self.model.type(index)) #节点类型
self.ui.LabFileName.setText(self.model.fileName(index)) #文件名
fileSize = self.model.size(index) / 1024
if (fileSize < 1024):
self.ui.LabFileSize.setText("%d KB" % fileSize)
else:
self.ui.LabFileSize.setText("%.2f MB" % (fileSize / 1024.0))
class FileTree(QWidget):
def __init__(self, defaultfolder=r'c:\Zen_Output'):
super(QWidget, self).__init__()
filter = ['*.czi', '*.ome.tiff', '*ome.tif' '*.tiff' '*.tif']
# define the style for the FileTree via s style sheet
self.setStyleSheet("""
QTreeView::item {
background-color: rgb(38, 41, 48);
font-weight: bold;
}
QTreeView::item::selected {
background-color: rgb(38, 41, 48);
color: rgb(0, 255, 0);
}
QTreeView QHeaderView:section {
background-color: rgb(38, 41, 48);
color: rgb(255, 255, 255);
}
""")
self.model = QFileSystemModel()
self.model.setRootPath(defaultfolder)
self.model.setFilter(QtCore.QDir.AllDirs | QDir.Files | QtCore.QDir.NoDotAndDotDot)
self.model.setNameFilterDisables(False)
self.model.setNameFilters(filter)
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setRootIndex(self.model.index(defaultfolder))
self.tree.setAnimated(True)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(False)
header = self.tree.header()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
windowLayout = QVBoxLayout()
windowLayout.addWidget(self.tree)
self.setLayout(windowLayout)
self.tree.clicked.connect(self.on_treeView_clicked)
@pyqtSlot()
def on_treeView_clicked(self, index):
indexItem = self.model.index(index.row(), 0, index.parent())
filename = self.model.fileName(indexItem)
filepath = self.model.filePath(indexItem)
# open the file when clicked
print('Opening ImageFile : ', filepath)
open_image_stack(filepath)
class SelectFolderWindow(QtGui.QDialog, Ui_Session_Dialog):
def __init__(self, directory, parent=None):
super(SelectFolderWindow, self).__init__(parent)
self.setupUi(self)
self.folder_name = None
self.folder_path = None
self.file_model = QFileSystemModel()
self.directory = directory
self.file_model.setRootPath(directory)
self.folder_tree.setModel(self.file_model)
self.folder_tree.setRootIndex(self.file_model.index(self.directory))
self.folder_tree.clicked.connect(self.set_session_folder)
def update_file_model(self, new_dir):
self.directory = new_dir
self.file_model.setRootPath(new_dir)
def set_session_folder(self, index):
indexItem = self.file_model.index(index.row(), 0, index.parent())
self.folder_name = self.file_model.fileName(indexItem)
self.folder_path = self.file_model.filePath(indexItem)
self.selected_session.setText(self.folder_path)
class QmyMainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数,创建窗体
self.ui = Ui_MainWindow() #创建Ui对象
self.ui.setupUi(self) #构造UI
self.LabPath = QLabel(self)
self.ui.statusBar.addWidget(self.LabPath)
self.__buildModelView()
##==========自定义功能函数==========
def __buildModelView(self):
self.model = QFileSystemModel(self) #定义数据模型
self.model.setRootPath(QDir.currentPath()) #获取当前路径,并设置为model的根目录
self.ui.treeView.setModel(self.model) #将self.model设置为自己的数据模型
self.ui.listView.setModel(self.model)
self.ui.tableView.setModel(self.model)
#将treeView的cilcked信号与listView与tableView的槽函数setRootIndex相关联
self.ui.treeView.clicked.connect(self.ui.listView.setRootIndex)
self.ui.treeView.clicked.connect(self.ui.tableView.setRootIndex)
##==========事件处理函数===========
##==========由connectSlotsByName()自动关联的槽函数====
def on_treeView_clicked(self, index): #index是模型索引
print(index)
self.ui.checkBox.setChecked(self.model.isDir(index))
self.LabPath.setText(self.model.filePath(index))
self.ui.LabType.setText(self.model.type(index))
self.ui.LabFileName.setText(self.model.fileName(index))
fileSize = self.model.size(index) / 1024
# print(fileSize)
if fileSize < 1024:
self.ui.LabFileSize.setText("%d KB" % fileSize)
else:
self.ui.LabFileSize.setText(".2f MB" % (fileSize / 1024.0))
class Mtpfs(QWidget, Ui_mtpfs):
def __init__(self):
super(Mtpfs, self).__init__()
self.setupUi(self)
# connect arrow icons for buttons from resources.py
self.MoveFileBackward.setIcon(
QIcon(':button_arrows/ButtonIcons/left-arrow.png'))
self.MoveFileForward.setIcon(
QIcon(':button_arrows/ButtonIcons/right-arrow.png'))
self.Unmount.setEnabled(False)
self.MoveFileForward.setEnabled(False)
self.MoveFileBackward.setEnabled(False)
self.MoveFileForward.setDown(True)
self.MoveFileBackward.setDown(True)
self.Unmount.setDown(True)
self.ComputerTreeModel = QFileSystemModel()
path = self.ComputerTreeModel.setRootPath(os.path.expanduser('~'))
self.ComputerTree.setModel(self.ComputerTreeModel)
self.ComputerTree.expand(path)
self.ComputerTree.scrollTo(path)
self.ComputerTree.setColumnWidth(0, 350)
self.ComputerTree.setColumnWidth(1, 50)
self.ComputerTree.setColumnWidth(2, 50)
self.ComputerTree.setColumnWidth(3, 50)
self.ComputerTree.setCurrentIndex(path)
self.AndroidPath.setText(os.path.expanduser('~'))
# setting up shortcuts for copying files
self.copy_android_computer = QShortcut(
QKeySequence('Right'), self, self.CopyShortcutAndroidComputer)
self.copy_computer_android = QShortcut(
QKeySequence('Left'), self, self.CopyShortcutComputerAndroid)
self.Mount.clicked.connect(self.MountFileSystem)
self.Unmount.clicked.connect(self.UnmountFileSystem)
self.ChoosePathAndroid.clicked.connect(self.GetDeviceDirectory)
self.MoveFileForward.clicked.connect(
self.CopyFileFromAndroidToComputer)
self.MoveFileBackward.clicked.connect(
self.CopyFileFromComputerToAndroid)
def CopyFileFromAndroidToComputer(self):
index_android = self.AndroidTree.currentIndex()
file_path_android = self.AndroidTreeModel.filePath(index_android)
file_name_android = self.AndroidTreeModel.fileName(index_android)
index_computer = self.ComputerTree.currentIndex()
file_path_computer = self.ComputerTreeModel.filePath(index_computer)
file_name_computer = self.ComputerTreeModel.fileName(index_computer)
file_type_computer = self.ComputerTreeModel.type(index_computer)
file_name_computer_length = len(file_name_computer)
if file_type_computer == 'Folder':
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
# the next command allows to show Output while a file is copying, it's useful when files are large and thus we notify a user to wait
QApplication.processEvents()
command_copy = ['cp', '-R', file_path_android, file_path_computer]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append('<html><b>' + file_name_android + '</b</html>' +
' has been successfully copied to ' +
'<html><b>' + file_path_computer + '</b</html>')
else:
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
# "in file_path_computer" we delete the name of the file at the end of the path
command_copy = [
'cp', '-R', file_path_android,
file_path_computer[:-file_name_computer_length]
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append(
'<html><b>' + file_name_android + '</b</html>' +
' has been successfully copied to ' + '<html><b>' +
file_path_computer[:-file_name_computer_length] + '</b</html>')
def CopyFileFromComputerToAndroid(self):
index_computer = self.ComputerTree.currentIndex()
file_path_computer = self.ComputerTreeModel.filePath(index_computer)
file_name_computer = self.ComputerTreeModel.fileName(index_computer)
index_android = self.AndroidTree.currentIndex()
file_path_android = self.AndroidTreeModel.filePath(index_android)
file_name_android = self.AndroidTreeModel.fileName(index_android)
file_type_android = self.AndroidTreeModel.type(index_android)
file_name_android_length = len(file_name_android)
if file_type_android == 'Folder':
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
command_copy = ['cp', '-R', file_path_computer, file_path_android]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append('<html><b>' + file_name_computer +
'</b</html>' +
' has been successfully copied to ' +
'<html><b>' + file_path_android + '</b</html>')
else:
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
command_copy = [
'cp', '-R', file_path_computer,
file_path_android[:-file_name_android_length]
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append('<html><b>' + file_name_computer +
'</b</html>' +
' has been successfully copied to ' +
'<html><b>' +
file_path_android[:-file_name_android_length] +
'</b</html>')
def GetDeviceDirectory(self):
path_dialog = QFileDialog()
path_dialog.setFileMode(QFileDialog.DirectoryOnly)
self.AndroidPath.setText(
path_dialog.getExistingDirectory(self, 'Open Folder'))
if not len(self.AndroidPath.text()):
self.AndroidPath.setText(os.path.expanduser('~'))
def MountFileSystem(self):
# Check if a device connected via USB to the computer
if self.isDeviceMounted():
# set the name of the connected device
self.AndroidLabel.setText(self.androidDeviceName)
#Check if a folder is empty
if len(os.listdir(self.AndroidPath.text())) != 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle('Warning')
msg.setText(
'The folder doesn\'t have to contain any files in order to mount the device'
)
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
else:
self.Mount.setEnabled(False)
self.Unmount.setEnabled(True)
self.AndroidPath.setDisabled(True)
self.ChoosePathAndroid.setEnabled(False)
self.MoveFileForward.setEnabled(True)
self.MoveFileBackward.setEnabled(True)
self.Mount.setText('Mounted')
self.Mount.setDown(True)
self.Unmount.setDown(False)
self.ChoosePathAndroid.setDown(True)
self.MoveFileForward.setDown(False)
self.MoveFileBackward.setDown(False)
#create a folder for Android
self.aditionalAndroidPath = self.AndroidPath.text(
) + '/Android'
command_mkdir = ['mkdir', self.aditionalAndroidPath]
mkdir = subprocess.Popen(command_mkdir,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
command_go_mtpfs = ['mtpfs', self.aditionalAndroidPath]
mount_go_mtpfs = subprocess.Popen(command_go_mtpfs,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.AndroidTreeModel = QFileSystemModel()
path = self.AndroidTreeModel.setRootPath(
self.AndroidPath.text())
self.AndroidTree.setModel(self.AndroidTreeModel)
self.AndroidTree.expand(path)
self.AndroidTree.scrollTo(path)
self.AndroidTree.setColumnWidth(0, 350)
self.AndroidTree.setColumnWidth(1, 60)
self.AndroidTree.setColumnWidth(2, 50)
self.AndroidTree.setColumnWidth(3, 50)
self.AndroidTree.setCurrentIndex(path)
self.Output.append(
'You\'re using the <html><b>[mtpfs]</b</html> library')
self.Output.append('Your Android Device mounted at ' +
'<html><b>' + self.aditionalAndroidPath +
'</b</html>')
else:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle('Warning')
msg.setText(
'It seems the Device hasn\'t mounted yet. Please, connect your Android Device to the computer'
)
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def isDeviceMounted(self):
command_usb_devices = ['usb-devices']
usb_devices = subprocess.Popen(command_usb_devices,
stdout=subprocess.PIPE)
command_grep = ['grep', '-E', 'Manufacturer|Product']
grep = subprocess.Popen(command_grep,
stdin=usb_devices.stdout,
stdout=subprocess.PIPE)
output_grep = grep.communicate()[0].decode('utf-8')
pattern = re.compile('Manufacturer=Android')
listDevices = output_grep.split('\n')
self.androidDeviceName = ''
for index, line in enumerate(listDevices):
matchedline = pattern.search(line)
if matchedline is not None:
#parsing the name of the device from the line
self.androidDeviceName = listDevices[index + 1]
self.androidDeviceName = self.androidDeviceName.split()
self.androidDeviceName = self.androidDeviceName[1].replace(
'Product=', '')
return True
return False
def UnmountFileSystem(self):
self.AndroidTree.setModel(None)
#get back the android label
self.AndroidLabel.setText('Android Device')
command_unmount = ['fusermount', '-uz', self.aditionalAndroidPath]
fusermount = subprocess.Popen(command_unmount,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
command_rm_folder = ['rm', '-rf', self.aditionalAndroidPath]
remove_folder = subprocess.Popen(command_rm_folder,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.Unmount.setEnabled(False)
self.Mount.setEnabled(True)
self.AndroidPath.setDisabled(False)
self.ChoosePathAndroid.setEnabled(True)
self.MoveFileForward.setEnabled(False)
self.MoveFileBackward.setEnabled(False)
self.Mount.setText('Mount')
self.Unmount.setDown(True)
self.Mount.setDown(False)
self.ChoosePathAndroid.setDown(False)
self.MoveFileForward.setDown(True)
self.MoveFileBackward.setDown(True)
self.Output.append('The Android Device successfully unmounted!')
self.Output.clear()
def CopyShortcutAndroidComputer(self):
# if system is mounted we can use shortcuts
if self.Unmount.isEnabled():
index_android = self.AndroidTree.currentIndex()
file_path_android = self.AndroidTreeModel.filePath(index_android)
file_name_android = self.AndroidTreeModel.fileName(index_android)
index_computer = self.ComputerTree.currentIndex()
file_path_computer = self.ComputerTreeModel.filePath(
index_computer)
file_name_computer = self.ComputerTreeModel.fileName(
index_computer)
file_type_computer = self.ComputerTreeModel.type(index_computer)
file_name_computer_length = len(file_name_computer)
if file_type_computer == 'Folder':
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
# the next command allows to show Output while a file is copying, it's useful when files are large and thus we notify a user to wait
QApplication.processEvents()
command_copy = [
'cp', '-R', file_path_android, file_path_computer
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append('<html><b>' + file_name_android +
'</b</html>' +
' has been successfully copied to ' +
'<html><b>' + file_path_computer +
'</b</html>')
else:
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
# "in file_path_computer" we delete the name of the file at the end of the path
command_copy = [
'cp', '-R', file_path_android,
file_path_computer[:-file_name_computer_length]
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append(
'<html><b>' + file_name_android + '</b</html>' +
' has been successfully copied to ' + '<html><b>' +
file_path_computer[:-file_name_computer_length] +
'</b</html>')
def CopyShortcutComputerAndroid(self):
if self.Unmount.isEnabled():
# if system is mounted we can use shortcuts
index_computer = self.ComputerTree.currentIndex()
file_path_computer = self.ComputerTreeModel.filePath(
index_computer)
file_name_computer = self.ComputerTreeModel.fileName(
index_computer)
index_android = self.AndroidTree.currentIndex()
file_path_android = self.AndroidTreeModel.filePath(index_android)
file_name_android = self.AndroidTreeModel.fileName(index_android)
file_type_android = self.AndroidTreeModel.type(index_android)
file_name_android_length = len(file_name_android)
if file_type_android == 'Folder':
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
command_copy = [
'cp', '-R', file_path_computer, file_path_android
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append('<html><b>' + file_name_computer +
'</b</html>' +
' has been successfully copied to ' +
'<html><b>' + file_path_android +
'</b</html>')
else:
self.Output.append(
'<html><b>Please wait while copying...</b</html>')
QApplication.processEvents()
command_copy = [
'cp', '-R', file_path_computer,
file_path_android[:-file_name_android_length]
]
cp = subprocess.Popen(command_copy,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output_cp = cp.communicate()
self.Output.append(
'<html><b>' + file_name_computer + '</b</html>' +
' has been successfully copied to ' + '<html><b>' +
file_path_android[:-file_name_android_length] +
'</b</html>')
class MainWin(QMainWindow, Ui_MainWindow):
def __init__(self):
super(MainWin,self).__init__()
self.setupUi(self)
self.Login.triggered.connect(self.open_login)
self.RGB.triggered.connect(self.open_image_rgb)
self.LoginDialog = LoginDialog()
self.ImageMainWin = ImageRGB()
# 设置TreeWidgets
self.trees = [self.YCPGAMETREE, self.YCPCOMPTREE, self.YLANDFILETREE]
for tree in self.trees:
tree.setContextMenuPolicy(Qt.CustomContextMenu)
tree.customContextMenuRequested.connect(self.show_context_menu)
tree.header().setMinimumSectionSize(120)
self.model = QFileSystemModel()
self.RailID = ''
self.ylands_path = ''
self.rail_user_data = ''
self.ycp_game_folder_path = ''
self.ycp_comp_folder_path = ''
self.yland_folder_path = ''
self.key = OpenKey(HKEY_CURRENT_USER, r"Software\Rail\YlandsRail")
_value, type = QueryValueEx(self.key, "InstallPath")
if _value:
self.ylands_path = _value
self.rail_user_data = Path.dirname(self.ylands_path) + '\\' + 'rail_user_data\\2000108'
self.YCPTAB.currentChanged.connect(self.refresh_tab_qlistwidget)
self.GroupBoxTitleDict = {0: 'YCP游戏目录', 1: 'YCP组件目录', 2: 'YLAND文件目录'}
self.YCPTAB.setCurrentIndex(0)
print(self.OpenDirBtn.clicked)
# 打开workshop 后去RailId
def open_login(self):
self.LoginDialog.LoginRailIDSignel.connect(self.slot_emit)
self.LoginDialog.show()
def open_image_rgb(self):
self.ImageMainWin.show()
def slot_emit(self, flag, str):
# 获得 rail_id
self.RailID = str
self.ycp_game_folder_path = self.rail_user_data + '\\' + self.RailID + '\\cloud_storage\\files\\Share\\Games'
self.ycp_comp_folder_path = self.rail_user_data + '\\' + self.RailID + '\\cloud_storage\\files\\Share\\Compositions'
self.yland_folder_path = self.rail_user_data + '\\' + self.RailID + '\\cloud_storage\\files\\Scenarios'
if not Path.exists(self.ycp_game_folder_path):
makedirs(self.ycp_game_folder_path)
if not Path.exists(self.ycp_comp_folder_path):
makedirs(self.ycp_comp_folder_path)
if not Path.exists(self.yland_folder_path):
makedirs(self.yland_folder_path)
self.YCPTAB.setEnabled(True)
self.YCPTAB.setCurrentIndex(0)
self.refresh_tab_qlistwidget(0)
self.setAcceptDrops(True)
def refresh_tab_qlistwidget(self, index):
if self.RailID != '':
self.OpenDirBtn.setEnabled(True)
if index == 0:
self.YCPGAMETREE.setEnabled(True)
self.refresh_path(index, self.ycp_game_folder_path)
self.model.setRootPath(self.ycp_game_folder_path)
self.YCPGAMETREE.setModel(self.model)
self.YCPGAMETREE.setRootIndex(self.model.index(self.ycp_game_folder_path))
elif index == 1:
self.YCPCOMPTREE.setEnabled(True)
self.refresh_path(index, self.ycp_comp_folder_path)
self.model.setRootPath(self.ycp_comp_folder_path)
self.YCPCOMPTREE.setModel(self.model)
self.YCPCOMPTREE.setRootIndex(self.model.index(self.ycp_comp_folder_path))
else:
self.YLANDFILETREE.setEnabled(True)
self.refresh_path(index, self.yland_folder_path)
self.model.setRootPath(self.yland_folder_path)
self.YLANDFILETREE.setModel(self.model)
self.YLANDFILETREE.setRootIndex(self.model.index(self.yland_folder_path))
def refresh_path(self, index, path):
self.files_count(path)
self.frame.findChild(QGroupBox, 'groupBox').setTitle(self.GroupBoxTitleDict[index])
self.PathTxt.setText(path)
if MainWin.isconnected(self.OpenDirBtn, 'clicked()'):
self.OpenDirBtn.disconnect()
self.OpenDirBtn.clicked.connect(lambda: self.open_dir(path, index))
#TODO 通过背景颜色，显示文件被使用的状态
def open_dir(self, path, index):
# QFileDialog.getExistingDirectory(self,"浏览"+ self.GroupBoxTitleDict[index], path, QFileDialog.ShowDirsOnly)
QFileDialog.getOpenFileNames(self, "浏览" + self.GroupBoxTitleDict[index], path, "All Files (*);;Text Files (*.txt)")
def files_count(self, path):
count = 0
for root, dirs, files in walk(path):
for each in files:
file = Path.splitext(each)
filename, type = file
if type != '.txt':
count += 1
self.statusbar.showMessage("文件数：" + str(count))
@staticmethod
def isconnected(obj, name):
"""判断信号是否连接
:param obj: 对象
:param name: 信号名，如 clicked()
"""
index = obj.metaObject().indexOfMethod(name)
if index > -1:
method = obj.metaObject().method(index)
if method:
return obj.isSignalConnected(method)
return False
def show_context_menu(self, pos):
sender = self.sender()
row_index = sender.indexAt(pos).row()
menu = QMenu()
cpy = menu.addAction('复制')
cpy.triggered.connect(lambda: self.copy_selected(sender.currentIndex()))
rmfile = menu.addAction('删除')
rmfile.triggered.connect(lambda: self.remove_selected_file(sender.currentIndex()))
menu.exec_(QCursor.pos())
def copy_selected(self, index):
filename = self.model.fileName(index)
filepath = self.model.filePath(index)
data = QMimeData()
url = QUrl.fromLocalFile(filepath)
clipboard = QApplication.clipboard()
data.setUrls([url])
clipboard.setMimeData(data)
def remove_selected_file(self, index):
filename = self.model.fileName(index)
filepath = self.model.filePath(index)
if not self.model.fileInfo(index).isDir():
msgBox = QMessageBox()
msgBox.setText("确定删除文件：" + filename + "?")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
ret = msgBox.exec_()
if ret == QMessageBox.Ok:
self.model.remove(index)
else:
return
def dragEnterEvent(self, event):
if event.mimeData().hasUrls:
filetempname = event.mimeData().urls()[0].fileName()
filename, extension = Path.splitext(filetempname)
if self.YCPTAB.currentIndex() == 0 or self.YCPTAB.currentIndex() == 1:
if extension == '.ycp':
event.accept()
# clipboard = QApplication.clipboard()
# clipboard.clear()
# clipboard.setMimeData(event.mimeData())
else:
msgBox = QMessageBox()
msgBox.setText("只能拖放.ycp后缀文件")
ret = msgBox.exec_()
event.ignore()
return
elif self.YCPTAB.currentIndex() == 2:
if extension == '.yland':
event.accept()
# clipboard = QApplication.clipboard()
# clipboard.clear()
# clipboard.setMimeData(event.mimeData())
else:
msgBox = QMessageBox()
msgBox.setText("只能拖放.yland后缀文件")
ret = msgBox.exec_()
event.ignore()
return
def dragMoveEvent(self, event):
if event.mimeData().hasUrls:
try:
event.setDropAction(Qt.CopyAction)
except Exception as e:
print(e)
event.accept()
else:
event.ignore()
def dropEvent(self, event):
try:
if event.mimeData().hasUrls:
event.setDropAction(Qt.CopyAction)
event.accept()
filepath = event.mimeData().urls()[0]
filename = filepath.fileName()
if self.YCPTAB.currentIndex() == 0:
self.copy_file(filepath.url().replace("file:///", ""), Path.join(self.ycp_game_folder_path, filename))
elif self.YCPTAB.currentIndex() == 1:
self.copy_file(filepath.url().replace("file:///", ""), Path.join(self.ycp_comp_folder_path, filename))
else:
self.copy_file(filepath.url().replace("file:///", ""), Path.join(self.yland_folder_path, filename))
else:
event.ignore()
except Exception as e:
print(e)
def copy_file(self,srcfle, dstfile):
newdstfile = dstfile
if not Path.isfile(srcfle):
print("$%s not exist!" % (srcfle))
else:
fpath, ftempname = Path.split(dstfile)
if not Path.exists(fpath):
makedirs(fpath)
elif Path.exists(dstfile):
filename, extension = Path.splitext(ftempname)
newdstfile = Path.join(fpath, filename + "copybyylandsbox" + extension)
copyfile(srcfle, newdstfile)
class Explorer(QWidget):
def __init__(self, rootdir=QDir.rootPath()):
QWidget.__init__(self)
self.treeview = QTreeView()
self.listview = QListView()
self.path = rootdir
self.filename = ''
self.filepath = rootdir
self.canvas = None
self.col_selector = None
self.header = ''
self.xcol = [1]
self.ycol = [1]
self.ncols = 0
self.dirModel = QFileSystemModel()
self.dirModel.setRootPath(self.path)
self.dirModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)
self.fileModel = QFileSystemModel()
self.fileModel.setRootPath(self.filepath)
self.fileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)
self.fileModel.setNameFilters(['*.txt'])
self.fileModel.setNameFilterDisables(0)
self.treeview.setModel(self.dirModel)
self.listview.setModel(self.fileModel)
for i in [1, 2, 3]: self.treeview.setColumnHidden(i, True)
self.treeview.setHeaderHidden(True)
self.treeview.setRootIndex(self.dirModel.index(self.path))
self.listview.setRootIndex(self.fileModel.index(self.path))
self.treeview.clicked.connect(self.on_clicked)
self.listview.selectionModel().currentChanged.connect(self.file_selected)
self.listview.selectionModel().currentChanged.connect(lambda: self.canvas.update_plot(self))
self.listview.selectionModel().currentChanged.connect(lambda: self.col_selector.update_range(self.ncols))
def on_clicked(self, index):
self.path = self.dirModel.fileInfo(index).absoluteFilePath()
self.listview.setRootIndex(self.fileModel.setRootPath(self.path))
def file_selected(self, index):
self.filename = self.fileModel.fileName(index)
self.filepath = self.fileModel.filePath(index)
self.load_file()
def load_file(self):
try:
if self.filepath.endswith('.txt'):
with open(self.filepath, 'r') as file:
self.header, self.xcol, self.ycol = '', [], []
for ln in file:
if ln.startswith('#'):
self.header += ln[2:]
else:
cols = ln.split('\t')
self.xcol.append(float(cols[0]))
self.ycol.append(float(cols[self.col_selector.sp.value()]))
self.ncols = len(cols)
self.col_selector.update_range(self.ncols)
except:
self.header, self.xcol, self.ycol = '', [0], [0]
def update_rootdir(self, rootdir):
self.path = rootdir
self.treeview.setRootIndex(self.dirModel.index(self.path))
self.listview.setRootIndex(self.fileModel.index(self.path))
class MyApp(QWidget):
def __init__(self):
super().__init__()
self.path = "C:"
self.index = None
self.tv = QTreeView(self)
self.model = QFileSystemModel()
self.btnRen = QPushButton("이름바꾸기")
self.btnDel = QPushButton("파일삭제")
self.layout = QVBoxLayout()
self.setUi()
self.setSlot()
self.show()
def setUi(self):
self.setGeometry(300, 300, 700, 350)
self.setWindowTitle("QFileSystemModel")
self.model.setRootPath(self.path)
self.tv.setModel(self.model)
self.tv.setColumnWidth(0, 250)
self.layout.addWidget(self.tv)
self.layout.addWidget(self.btnDel)
self.layout.addWidget(self.btnRen)
self.setLayout(self.layout)
def setSlot(self):
self.tv.clicked.connect(self.setIndex)
self.btnRen.clicked.connect(self.ren)
self.btnDel.clicked.connect(self.rm)
def setIndex(self, index):
self.index = index
def ren(self):
os.chdir(self.model.filePath(self.model.parent(self.index)))
fname = self.model.fileName(self.index)
text, res = QInputDialog.getText(self, "이름바꾸기", "바꿀이름을 입력하세요",
QLineEdit.Normal, fname)
if res:
while True:
self.ok = True
for i in os.listdir(os.getcwd()):
print(i)
if i == text:
text, res = QInputDialog.getText(
self, "중복오류!", "바꿀이름을 입력하세요", QLineEdit.Normal,
text)
if not res:
return
self.ok = False
if self.ok:
break
os.rename(fname, text)
def rm(self):
os.chdir(self.model.filePath(self.model.parent(self.index)))
fname = self.model.fileName(self.index)
try:
if not self.model.isDir(self.index):
os.unlike(fname)
print(fname + '파일 삭제')
else:
shutil.rmtree(fname)
print(fname + '폴더 삭제')
except:
print("에러발생")
class MyMainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.config_window()
self.create_widgets()
self.config_widgets()
self.create_menubar()
self.bind_widgets()
self.show_widgets()
def config_window(self):
self.setWindowTitle('DirectoPy')
self.setMinimumHeight(600)
self.setMinimumWidth(1000)
def create_widgets(self):
self.central_widget = QWidget()
self.main_layout = QGridLayout()
self.moveup_button = QPushButton('Collapse all', self)
self.goto_lineedit = QLineEdit('', self)
self.goto_button = QPushButton('Go', self)
self.folder_view = QTreeView(self)
self.file_view = QTreeView(self)
self.folder_model = QFileSystemModel(self)
self.file_model = QFileSystemModel(self)
def config_widgets(self):
self.main_layout.addWidget(self.moveup_button, 0, 0)
self.main_layout.addWidget(self.goto_lineedit, 0, 1, 1, 2)
self.main_layout.addWidget(self.goto_button, 0, 3)
self.main_layout.addWidget(self.folder_view, 1, 0, 1, 2)
self.main_layout.addWidget(self.file_view, 1, 2, 1, 2)
self.central_widget.setLayout(self.main_layout)
# Кнопка "вверх"
self.moveup_button.setMaximumWidth(100)
# Кнопка "перейти"
self.goto_button.setMaximumWidth(70)
self.setCentralWidget(self.central_widget)
# панели
self.folder_model.setRootPath(None)
self.folder_model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
self.folder_view.setModel(self.folder_model)
self.folder_view.setRootIndex(self.folder_model.index(None))
self.folder_view.clicked[QModelIndex].connect(self.clicked_onfolder)
self.folder_view.hideColumn(1)
self.folder_view.hideColumn(2)
self.folder_view.hideColumn(3)
self.file_model.setFilter(QDir.Files)
self.file_view.setModel(self.file_model)
self.file_model.setReadOnly(False)
self.file_view.setColumnWidth(0, 200)
self.file_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
# открытие папки при нажати на неё в окне папок
def clicked_onfolder(self, index):
selection_model = self.folder_view.selectionModel()
index = selection_model.currentIndex()
dir_path = self.folder_model.filePath(index)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
# ф-я открытия нового файла
def open_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
file_path = self.file_model.filePath(index).replace('/', '\\')
print(file_path)
self.file_view.update()
# ф-я создания нового файла
def new_file(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isfile(os.path.join(path, "newfile{}.txt".format(i))):
file_name = os.path.join(path, "newfile{}.txt".format(i))
break
file_name = os.path.abspath(file_name)
open(file_name, 'w').close()
else:
print("Please, select folder")
# ф-я удаления файла
def delete_file(self):
indexes = self.file_view.selectedIndexes()
for i in indexes:
self.file_model.remove(i)
# ф-я переименования файла
def rename_file(self):
index = self.file_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.file_view.edit(index)
# ф-я копирования файла
def copy_file(self):
print("COPY")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
copy2(self.file_model.filePath(i), new_filename)
# ф-я возвращения к корню пути
def colapse(self):
self.folder_view.collapseAll()
# ф-я перемещения в заданную директорию
def go_to(self):
dir_path = self.goto_lineedit.text().replace('\\', '/')
print(dir_path)
self.file_model.setRootPath(dir_path)
self.file_view.setRootIndex(self.file_model.index(dir_path))
#self.file_model.setRootPath()
# ф-я перемещения файла
def move_file(self):
print("MOVE")
ask = QFileDialog.getExistingDirectory(self, "Open Directory", "C:\\",
QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
if ask == '':
return
new_path = ask.replace('\\', '/')
indexes = self.file_view.selectedIndexes()[::4]
for i in indexes:
new_filename = new_path + '/' + self.file_model.fileName(i)
move(self.file_model.filePath(i), new_filename)
# ф-я создания новой папки
def new_folder(self):
global file_name
index = self.folder_view.selectedIndexes()
if len(index) > 0:
path = self.folder_model.filePath(index[0])
for i in range(1, 9999999999999999):
if not os.path.isdir(os.path.join(path, "newfolder{}".format(i))):
file_name = os.path.join(path, "newfolder{}".format(i))
break
file_name = os.path.abspath(file_name)
os.mkdir(file_name)
else:
print("Please, select folder")
# ф-я удаления папки
def delete_folder(self):
indexes = self.folder_view.selectedIndexes()
for i in indexes:
self.folder_model.remove(i)
# ф-я переименования папки
def rename_folder(self):
index = self.folder_view.selectedIndexes()
if not index:
return
else:
index = index[0]
self.folder_view.edit(index)
# ф-я закрытия окна файлового менеджера
def exit_application(self):
print("EXIT")
self.close()
# задавание функции каждой кнопке
def bind_widgets(self):
self.open_file_action.triggered.connect(self.open_file)
self.new_file_action.triggered.connect(self.new_file)
self.delete_file_action.triggered.connect(self.delete_file)
self.rename_file_action.triggered.connect(self.rename_file)
self.copy_file_action.triggered.connect(self.copy_file)
self.move_file_action.triggered.connect(self.move_file)
self.exit_action.triggered.connect(self.exit_application)
self.new_folder_action.triggered.connect(self.new_folder)
self.delete_folder_action.triggered.connect(self.delete_folder)
self.rename_folder_action.triggered.connect(self.rename_folder)
self.goto_button.clicked.connect(partial(self.go_to))
self.moveup_button.clicked.connect(partial(self.colapse))
# создание меню
def create_menubar(self):
self.exit_action = QAction('Exit', self)
self.exit_action.setShortcut('Ctrl+Q')
self.new_file_action = QAction('New file', self)
self.new_file_action.setShortcut('F4')
self.open_file_action = QAction('Open file', self)
self.open_file_action.setShortcut('F3')
self.rename_file_action = QAction('Rename file', self)
self.rename_file_action.setShortcut('F2')
self.delete_file_action = QAction('Remove file', self)
self.delete_file_action.setShortcut(QKeySequence.Delete)
self.copy_file_action = QAction('Copy folder...', self)
self.copy_file_action.setShortcut(QKeySequence.Copy)
self.move_file_action = QAction('Move folder...', self)
self.move_file_action.setShortcut(QKeySequence.Cut)
self.new_folder_action = QAction('New folder', self)
self.new_folder_action.setShortcut('Ctrl+Shift+N')
self.delete_folder_action = QAction('Delete folder', self)
self.delete_folder_action.setShortcut('Ctrl+Shift+Del')
self.rename_folder_action = QAction('Rename folder', self)
self.rename_folder_action.setShortcut('Ctrl+Shift+R')
self.menubar = self.menuBar()
self.file_menu = self.menubar.addMenu('File')
self.file_menu.addAction(self.new_file_action)
self.file_menu.addAction(self.open_file_action)
self.file_menu.addAction(self.rename_file_action)
self.file_menu.addAction(self.delete_file_action)
self.file_menu.addAction(self.copy_file_action)
self.file_menu.addAction(self.move_file_action)
self.file_menu.addSeparator()
self.file_menu.addAction(self.exit_action)
self.folder_menu = self.menubar.addMenu('Folder')
self.folder_menu.addAction(self.new_folder_action)
self.folder_menu.addAction(self.delete_folder_action)
self.folder_menu.addAction(self.rename_folder_action)
def show_widgets(self):
self.setLayout(self.main_layout)
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
# sys.stdout = EmittingStream(textWritten=self.normalOutputWritten)
self.actionAutoencoder.setChecked(True)
# Connect the menu action
self.actionSelect_Data_Path.triggered.connect(self.selectPath)
self.actionLoad_from_Data_Path.triggered.connect(self.loadtifFile)
# Connect the model selections
self.actionAutoencoder.triggered.connect(self.createAE_Model)
self.actionAE_CS.triggered.connect(self.createAECS_Model)
self.actionOpen_Model.triggered.connect(self.openModel)
# Connect the treeView action
self.treeView.clicked.connect(self.on_treeView_clicked)
# Connect the Label action
self.actionAddLabel.triggered.connect(self.addCategory)
self.actionDel_Label.triggered.connect(self.delCategory)
self.actionUpdate_Setting.triggered.connect(self.updateLabelSetting)
# Connect the Function action
self.actionStart_Training.triggered.connect(self.Training)
self.actionStop_Training.triggered.connect(self.stopTraining)
self.actionNew_tSNE.triggered.connect(self.New_tSNE)
# Gif
self.movie = QtGui.QMovie("cube.gif")
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(80)
self.movie.setScaledSize(QSize(256, 320))
self.Gif.setMovie(self.movie)
self.movie.start()
self.movie.stop()
import wmi
computer = wmi.WMI()
computer_info = computer.Win32_ComputerSystem()[0]
os_info = computer.Win32_OperatingSystem()[0]
proc_info = computer.Win32_Processor()[0]
gpu_info = computer.Win32_VideoController()[0]
os_name = os_info.Name.encode('utf-8').split(b'|')[0]
os_version = ' '.join([os_info.Version, os_info.BuildNumber])
system_ram = float(
os_info.TotalVisibleMemorySize) / 1048576 # KB to GB
print('OS Name: {0}'.format(os_name))
print('OS Version: {0}'.format(os_version))
print('CPU: {0}'.format(proc_info.Name))
print('RAM: {0} GB'.format(system_ram))
print('Graphics Card: {0}'.format(gpu_info.Name))
self.setWindowIcon(QIcon('Icon.png'))
self.System_textEdit.setText('OS Name: {}\n'
'OS Version: {}\n'
'CPU: {}\n'
'RAM: {} GB\n'
'Graphics Card: {}'.format(
os_name.decode("utf-8"), os_version,
proc_info.Name, system_ram,
gpu_info.Name))
def Training(self):
global file_loaded
if file_loaded:
self.label_7.setText('Training')
self.label_7.setStyleSheet("color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
self.movie.setSpeed(100)
self.movie.start()
self.training_thread = Training_Thread()
self.training_thread.start()
self.training_thread.finished.connect(self.DrawtSNE)
self.training_thread.finished.connect(self.DrawLog)
self.training_thread.quit()
else:
pass
def New_tSNE(self):
self.movie.start()
self.tSNE_thread = tSNE_Thread()
self.tSNE_thread.start()
self.tSNE_thread.finished.connect(self.DrawtSNE)
pass
def stopTraining(self):
self.training_thread = Training_Thread()
if self.training_thread.isRunning():
self.training_thread.terminate()
self.movie.stop()
self.label_7.setText('Stopped')
self.label_7.setStyleSheet("color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
def DrawtSNE(self):
global imagesavepath, currentdate, labels, cavans, groups, labels_dict, groups3D, test_data, test_annotation
from matplotlib.offsetbox import OffsetImage, AnnotationBbox
global df, df_3D, Y, Y_3D
print("DrawtSNE Start ")
test_annotation = test_data.reshape(-1, 190, 190)
# 2D tSNE
plt.cla()
fig, ax = plt.subplots()
ax.margins(0.05) # Optional, just adds 5% padding to the autoscaling
points_with_annotation = []
for label, group in groups:
name = labels_dict[label]
point, = ax.plot(group.x,
group.y,
marker='o',
linestyle='',
ms=5,
label=name,
alpha=0.5)
points_with_annotation.append([point])
plt.title('t-SNE Scattering Plot')
ax.legend()
cavans2D = FigureCanvas(fig)
#Annotation
# create the annotations box
im = OffsetImage(test_annotation[0, :, :], zoom=0.25, cmap='gray')
xybox = (10., 10.)
ab = AnnotationBbox(im, (10, 10),
xybox=xybox,
xycoords='data',
boxcoords="offset points",
pad=0.3,
arrowprops=dict(arrowstyle="->"))
# add it to the axes and make it invisible
ax.add_artist(ab)
ab.set_visible(False)
tsneprelabel = int(len(test_data) / len(labels))
def hover(event):
global df, test_annotation
i = 0
ispointed = np.zeros((len(groups), ), dtype=bool)
for point in points_with_annotation:
if point[0].contains(event)[0]:
ispointed[i] = True
cont, ind = point[0].contains(event)
image_index = ind["ind"][0] + i * tsneprelabel
# get the figure size
w, h = fig.get_size_inches() * fig.dpi
ws = (event.x > w / 2.) * -1 + (event.x <= w / 2.)
hs = (event.y > h / 2.) * -1 + (event.y <= h / 2.)
# if event occurs in the top or right quadrant of the figure,
# change the annotation box position relative to mouse.
ab.xybox = (xybox[0] * ws, xybox[1] * hs)
# place it at the position of the hovered scatter point
global df, test_annotation
df = df
ab.xy = (df['x'][image_index], df['y'][image_index])
# set the image corresponding to that point
im.set_data(test_annotation[image_index, :, :])
ab.set_visible(True)
else:
ispointed[i] = False
i = i + 1
ab.set_visible(max(ispointed))
fig.canvas.draw_idle()
cid = fig.canvas.mpl_connect('motion_notify_event', hover)
rows = int(self.tSNE_Layout.count())
if rows == 1:
myWidget = self.tSNE_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.tSNE_Layout.addWidget(cavans2D)
print("tSNE 2D Finished")
# 3D tSNE
fig_3D = plt.figure()
cavans3D = FigureCanvas(fig_3D)
ax_3D = Axes3D(fig_3D)
ax_3D.margins(
0.05) # Optional, just adds 5% padding to the autoscaling
test_annotation = test_data.reshape(-1, 190, 190)
for label, group in groups3D:
name = labels_dict[label]
ax_3D.scatter(group.x,
group.y,
group.z,
marker='o',
label=name,
alpha=0.8)
ax_3D.legend()
ax_3D.patch.set_visible(False)
ax_3D.set_axis_off()
ax_3D._axis3don = False
from matplotlib.offsetbox import OffsetImage, AnnotationBbox
im_3D = OffsetImage(test_annotation[0, :, :], zoom=0.25, cmap='gray')
xybox = (10., 10.)
ab_3D = AnnotationBbox(im_3D, (10, 10),
xybox=xybox,
xycoords='data',
boxcoords="offset points",
pad=0.3,
arrowprops=dict(arrowstyle="->"))
# add it to the axes and make it invisible
ax_3D.add_artist(ab_3D)
ab_3D.set_visible(False)
def onMouseMotion(event):
global Y_3D
distances = []
for i in range(Y_3D.shape[0]):
x2, y2, _ = proj3d.proj_transform(Y_3D[i, 0], Y_3D[i, 1],
Y_3D[i, 2], ax_3D.get_proj())
x3, y3 = ax_3D.transData.transform((x2, y2))
distance = np.sqrt((x3 - event.x)**2 + (y3 - event.y)**2)
distances.append(distance)
closestIndex = np.argmin(distances)
print(closestIndex)
x2, y2, _ = proj3d.proj_transform(Y_3D[closestIndex,
0], Y_3D[closestIndex, 1],
Y_3D[closestIndex, 2],
ax_3D.get_proj())
ab_3D.xy = (x2, y2)
im_3D.set_data(test_annotation[closestIndex, :, :])
ab_3D.set_visible(True)
fig_3D.canvas.draw_idle()
cid3d = fig_3D.canvas.mpl_connect('motion_notify_event',
onMouseMotion) # on mouse motion
rows = int(self.tSNE3D_Layout.count())
if rows == 1:
myWidget = self.tSNE3D_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.tSNE3D_Layout.addWidget(cavans3D)
self.movie.stop()
self.movie.jumpToFrame(0)
self.label_7.setText('Finished')
self.label_7.setStyleSheet("color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";")
def DrawLog(self):
global history, CSfunction
if CSfunction:
train_history = history
loss = 'class_output_loss'
fig = plt.figure()
plt.plot(range(1,
len(train_history.history[loss]) + 1),
train_history.history[loss])
plt.title('Train History')
plt.ylabel(loss)
plt.xlabel('Epoch')
plt.legend([loss])
loss_cavans = FigureCanvas(fig)
rows = int(self.Log_Layout.count())
if rows == 1:
myWidget = self.Log_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.Log_Layout.addWidget(loss_cavans)
else:
train_history = history
loss = 'decoder_output_loss'
fig = plt.figure()
plt.plot(range(1,
len(train_history.history[loss]) + 1),
train_history.history[loss])
plt.title('Train History')
plt.ylabel(loss)
plt.xlabel('Epoch')
plt.legend([loss])
loss_cavans = FigureCanvas(fig)
rows = int(self.Log_Layout.count())
if rows == 1:
myWidget = self.Log_Layout.itemAt(0).widget()
myWidget.deleteLater()
self.Log_Layout.addWidget(loss_cavans)
def DrawDecoded(self):
global test_data, decoded_imgs
n = 5
fig = plt.figure()
plt.subplots_adjust(wspace=0, hspace=0)
for i in range(n):
# display original
ax = plt.subplot(2, n, i + 1)
plt.imshow(test_data[i].reshape(190, 190))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# display reconstruction
ax = plt.subplot(2, n, i + n + 1)
plt.imshow(decoded_imgs[1][i].reshape(190, 190))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.subplot(2, n, round(n / 2))
plt.tight_layout()
# plt.title('Raw Images &Decoded Images')
cavans = FigureCanvas(fig)
# rows = int(self.Decoded_layout.count())
# if rows == 1:
# myWidget = self.Decoded_layout.itemAt(0).widget()
# myWidget.deleteLater()
# self.Decoded_layout.addWidget(cavans)
def addCategory(self):
global folder_layers, layers_of_folders, file_readed, label_setting, file_loaded
if file_readed:
cat_cont = int(self.Category_Layout.count() / 2)
location = self.Category_Layout.count()
self.Category_new = QtWidgets.QLabel(self.formLayoutWidget)
self.Category_new.setText('Label {} :'.format(cat_cont + 1))
self.Category_new.setStyleSheet("font: 14pt \"Lucida Console\";")
self.Category_new.setObjectName("Category_{}".format(cat_cont + 1))
self.Category_Layout.setWidget(location,
QtWidgets.QFormLayout.LabelRole,
self.Category_new)
self.Category_box_new = QtWidgets.QComboBox(self.formLayoutWidget)
self.Category_box_new.setStyleSheet(
"background-color: rgb(255, 255, 255);\n"
"color: rgb(65, 65, 65);")
self.Category_box_new.setObjectName(
"Category_box{}".format(cat_cont + 1))
self.Category_Layout.setWidget(location,
QtWidgets.QFormLayout.FieldRole,
self.Category_box_new)
self.Category_box_new.clear()
for a in range(0, layers_of_folders):
self.Category_box_new.addItems(folder_layers[a])
self.label_3.setStyleSheet(
"color: rgb(200, 200, 200);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = False
file_loaded = False
def delCategory(self):
global label_setting, file_loaded
rows = int(self.Category_Layout.count() / 1)
if rows / 2 > 2:
box = self.Category_Layout.itemAt(rows - 2,
QtWidgets.QFormLayout.FieldRole)
label = self.Category_Layout.itemAt(
rows - 2, QtWidgets.QFormLayout.LabelRole)
box.widget().deleteLater()
label.widget().deleteLater()
self.label_3.setStyleSheet(
"color: rgb(200, 200, 200);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = False
file_loaded = False
def updateLabelSetting(self):
global labels, label_setting
if str(self.Category_box1.currentText()):
label_numbers = int(self.Category_Layout.count() / 2)
print('\nThere are {} labels.'.format(label_numbers))
rows = int(self.Category_Layout.count())
labels = []
i = 0
for index in range(0, rows, 2):
box = self.Category_Layout.itemAt(
index, QtWidgets.QFormLayout.FieldRole)
print('Label {} :{}'.format(i + 1,
str(box.widget().currentText())))
labels.append(str(box.widget().currentText()))
i = i + 1
self.label_3.setText('Label Updated')
self.label_3.setStyleSheet(
"color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
label_setting = True
print(labels)
def readimgFile(self):
global base_path, folder_layers, layers_of_folders, file_readed, folder_list
if base_path:
folder_layers = []
folder_list = []
layers_of_folders = 0
files = os.scandir(base_path)
# %% Get the 1st layer of folder
first_folder = []
first_folder_kind = []
for entry in files:
if entry.is_dir():
first_folder.append(entry.path)
first_folder_kind.append(entry.name)
folder_layers.append(first_folder_kind)
folder_list.append(first_folder)
# %% Get the 2nd layer of folder
second_folder = []
if first_folder:
second_folder = []
second_folder_kind = []
layers_of_folders += 1
for fldr in first_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
second_folder.append(entry.path)
second_folder_kind.append(entry.name)
second_folder_kind = second_folder_kind[
0:int(len(second_folder_kind) / len(first_folder_kind))]
folder_layers.append(second_folder_kind)
folder_list.append(second_folder)
# %% Get the 3rd layer of folder
third_folder = []
if second_folder:
third_folder = []
third_folder_kind = []
layers_of_folders += 1
for fldr in second_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
third_folder.append(entry.path)
third_folder_kind.append(entry.name)
third_folder_kind = third_folder_kind[0:int(
len(third_folder_kind) /
(len(second_folder_kind) * len(first_folder_kind)))]
folder_layers.append(third_folder_kind)
folder_list.append(third_folder)
# %% Get the 4th layer of folder
forth_folder = []
if third_folder:
forth_folder = []
forth_folder_kind = []
layers_of_folders += 1
for fldr in third_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
forth_folder.append(entry.path)
forth_folder_kind.append(entry.name)
forth_folder_kind = forth_folder_kind[0:int(
len(forth_folder_kind) /
(len(third_folder_kind) * len(second_folder_kind) *
len(first_folder_kind)))]
folder_layers.append(forth_folder_kind)
folder_list.append(forth_folder)
# %% Get the 5th layer of folder
fifth_folder = []
if forth_folder:
fifth_folder = []
fifth_folder_kind = []
layers_of_folders += 1
for fldr in third_folder:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
fifth_folder.append(entry.path)
fifth_folder_kind.append(entry.name)
fifth_folder_kind = fifth_folder_kind[0:int(
len(fifth_folder_kind) /
(len(forth_folder_kind) * len(third_folder_kind) *
len(second_folder_kind) * len(first_folder_kind)))]
folder_layers.append(fifth_folder_kind)
folder_list.append(fifth_folder)
print('\nThere are {} Layers in the Data Path.'.format(
layers_of_folders))
import fnmatch
file_list = []
for root, dirs, files in os.walk(base_path, topdown=False):
for name in files:
if fnmatch.fnmatch(name, '*.tif'):
file_list.append(os.path.join(root, name))
print('\nThere are {} .Tif files in the Data Path.'.format(
len(file_list)))
rows = int(self.Category_Layout.count())
print(rows)
for index in range(0, rows, 2):
print(index)
box = self.Category_Layout.itemAt(
index, QtWidgets.QFormLayout.FieldRole)
print(box.widget().objectName())
box.widget().clear()
for a in range(0, layers_of_folders):
for labels in folder_layers[a]:
box.widget().addItem(labels)
file_readed = True
def loadtifFile(self):
global datanumber, file_loaded
datanumber = int(self.spinBox.value())
self.thread = Thread_1()
self.label_5.setText('Data Loading')
self.label_5.setStyleSheet(
"color: rgb(200, 0, 0);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
self.thread.start()
self.thread.finished.connect(self.DataCreated)
self.thread.quit()
file_loaded = True
def DataCreated(self):
self.label_5.setText('Data Loaded')
self.label_5.setStyleSheet(
"color: rgb(70, 70, 70);\n"
"font: 75 14pt \"MS Shell Dlg 2\";") # Light the Label
def selectPath(self):
global base_path
repfldr = []
celltypefldr = []
self.statusBar().showMessage('Now Loading Files')
base_path = str(
QFileDialog.getExistingDirectory(self, "Select Directory", '/'))
print(base_path)
if base_path:
files = os.scandir(base_path)
# %% Get the 1st layer of folder
for entry in files:
if entry.is_dir():
if 'replicate' in entry.name:
repfldr.append(entry.path)
# %% Get the 2nd layer of folder
for fldr in repfldr:
files = os.scandir(fldr)
for entry in files:
if entry.is_dir():
celltypefldr.append(entry.path)
self.readimgFile()
self.model = QFileSystemModel()
self.model.setRootPath(base_path)
self.treeView.setModel(self.model)
self.treeView.setRootIndex(self.model.index(base_path))
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
return base_path
def keyPressEvent(self, e): # Use ESC to Close the APP
from PyQt5.QtCore import Qt
if e.key() == Qt.Key_Escape:
self.close()
def on_treeView_clicked(self, index):
indexItem = self.model.index(index.row(), 0, index.parent())
fileName = self.model.fileName(indexItem)
filePath = self.model.filePath(indexItem)
from PyQt5.QtGui import QIcon, QPixmap
pixmap = QPixmap(filePath)
self.Cell_Image.setPixmap(pixmap.scaled(256, 256))
def createAE_Model(self, state):
global CSfunction
if state:
self.actionAE_CS.setChecked(False)
CSfunction = False
def createAECS_Model(self, state):
global CSfunction
if state:
self.actionAutoencoder.setChecked(False)
CSfunction = True
def openModel(self):
global model_path
model_path = QFileDialog.getOpenFileName(self, "Select Model", '/')
print(model_path)
def runExample(self):
global base_path, folder_layers, layers_of_folders, file_readed, folder_list
class SidebarView:
def __init__(self, root, wads, controller):
self.wads = wads
self.current_wad = None
self.wad_dir_model = QFileSystemModel()
self.wad_dir = root.findChild(QTreeView, 'sidebar_waddir')
self.wad_dir.setModel(self.wad_dir_model)
for i in range(1, self.wad_dir.header().length()):
self.wad_dir.hideColumn(i)
self.wad_dir.setContextMenuPolicy(Qt.CustomContextMenu)
self.wad_dir.customContextMenuRequested.connect(self.open_dir_menu)
self.loadorder_model = QStandardItemModel()
# rowsRemoved is called when something is moved, AFTER the model actually is updated
self.loadorder_model.rowsRemoved.connect(
self.update_load_ordered_files)
self.loadorder = root.findChild(QListView, 'sidebar_loadorder')
self.loadorder.setModel(self.loadorder_model)
self.loadorder.clicked.connect(self.update_load_ordered_files)
self.loadorder.setContextMenuPolicy(Qt.CustomContextMenu)
self.loadorder.customContextMenuRequested.connect(
self.open_load_order_menu)
self.search_button = root.findChild(QPushButton,
'sidebar_idgames_search')
def search():
display_widget(root, WidgetIndices.IDGAMES_SEARCH)
self.search_button.clicked.connect(search)
self.random_button = root.findChild(QPushButton,
'sidebar_idgames_random')
self.random_button.clicked.connect(controller.random_clicked)
self.selected_wad_id = None
self.iwad_only_checkbox = root.findChild(QCheckBox,
'sidebar_iwad_only')
# checking this should send an empty file_paths list to wads.model.
self.iwad_only_checkbox.stateChanged.connect(
self.update_load_ordered_files)
def show_dir(self, wad):
self.current_wad = wad
self.wad_dir_model.setRootPath(QDir.currentPath())
self.wad_dir.setRootIndex(self.wad_dir_model.index(wad.path))
self.selected_path = wad.path
self.selected_wad_id = wad.id
try:
self.loadorder_model.clear()
for file_path in wad.file_paths:
file_name = os.path.basename(file_path)
item = QStandardItem(file_name)
item.setData(file_path, PATH_ROLE)
item.setFlags(LOAD_ORDER_ITEM_FLAGS)
item.setCheckable(True)
item.setCheckState(Qt.Checked)
self.loadorder_model.appendRow(item)
except KeyError:
print('file paths not found in:', wad.name)
def update_load_ordered_files(self, *_):
file_paths_reordered = []
for i in range(self.loadorder_model.rowCount()):
item = self.loadorder_model.item(i)
if self.iwad_only_checkbox.checkState() != Qt.Checked:
item.setEnabled(True)
if item.checkState() == Qt.Checked:
file_paths_reordered.append(item.data(PATH_ROLE))
else:
item.setEnabled(False)
self.wads.set_load_order(file_paths_reordered)
def open_dir_menu(self, pos):
index = self.wad_dir.indexAt(pos)
file_name = self.wad_dir_model.fileName(index)
file_path = self.wad_dir_model.filePath(index)
add_file_to_load_order_string = 'Add {} to load order list'.format(
file_name)
def add_file_to_load_order():
self.current_wad.add_file_path_to_paths(file_path)
self.show_dir(self.current_wad)
menu_actions = [(add_file_to_load_order_string, add_file_to_load_order)
]
execute_menu = make_context_menu(self.wad_dir, menu_actions)
execute_menu(pos)
def open_load_order_menu(self, pos):
index = self.loadorder.indexAt(pos)
item = self.loadorder_model.itemFromIndex(index)
file_name = item.text()
file_path = item.data()
remove_file_from_load_order_string = 'Remove {} from load order list'.format(
file_name)
def remove_file_from_load_order():
self.current_wad.remove_file_path_from_paths(file_path)
self.show_dir(self.current_wad)
menu_actions = [(remove_file_from_load_order_string,
remove_file_from_load_order)]
execute_menu = make_context_menu(self.loadorder, menu_actions)
execute_menu(pos)
class TrackWindow(QMainWindow):
def __init__(self, people):
super().__init__()
self.people = people
self.setWindowTitle("Tracking stats")
self.result = []
self.central = QWidget(self)
self.vlayout = QVBoxLayout()
self.button_names = []
for person in self.people:
self.upadte_column(person)
self.add_button = QPushButton('Add new people')
self.add_button.setMinimumSize(int((QDesktopWidget().screenGeometry(-1).width())/4), int((QDesktopWidget().screenGeometry(-1).height())/15))
self.vlayout.addWidget(self.add_button)
self.central.setLayout(self.vlayout)
self.setCentralWidget(self.central)
self.add_button.clicked.connect(self.add_person)
def add_person(self):
self.name_person, okPressed = QInputDialog.getText(self, "Name","Name of a person:",QLineEdit.Normal, "")
if okPressed and self.name_person != '':
self.window = QWidget()
self.window.setWindowTitle('Doubleclick your image')
okButtons = QHBoxLayout()
windowLayout = QVBoxLayout()
'''
self.ok_button = QPushButton('Ok')
self.cancel_button = QPushButton('Cancel')
okButtons.addWidget(self.ok_button)
okButtons.addWidget(self.cancel_button)
self.ok_button.setEnabled(False)
self.ok_button.setCheckable(True)
'''
self.model = QFileSystemModel()
self.model.setRootPath('')
self.tree = QTreeView()
self.tree.setModel(self.model)
self.tree.setIndentation(20)
self.tree.setSortingEnabled(True)
self.tree.setWindowTitle("Dir View")
self.tree.setMinimumSize(int((QDesktopWidget().screenGeometry(-1).width())/2), int((QDesktopWidget().screenGeometry(-1).height())/2))
windowLayout.addWidget(self.tree)
windowLayout.addLayout(okButtons)
self.window.setLayout(windowLayout)
self.tree.doubleClicked.connect(self.on_treeView_clicked)
self.window.show()
else:
print('Enter something')
@pyqtSlot(QModelIndex)
def on_treeView_clicked(self, index):
indexItem = self.model.index(index.row(), 0, index.parent())
values = []
fileName = self.model.fileName(indexItem)
filePath = self.model.filePath(indexItem)
values.append(filePath)
self.result.append(self.name_person)
self.result.append(values)
def update_stats(self):
for person in self.people:
ind = str(self.people.index(person))
for key, value in person.__dict__.items():
parametr = getattr(self, key+ind)
if key != 'name':
time_val = float(value.split(' ')[-2])
indx = value.find(str(time_val))
parametr.setText(key+' time: '+value[:indx]+str(int(time_val))+value[value.find('sec')-1:])
def upadte_column(self, person):
ind = self.people.index(person)
setattr(self, 'button'+str(ind), QVBoxLayout())
self.button_names.append('button'+str(ind))
if ind%2 == 0:
setattr(self, 'buttons'+str(ind), QHBoxLayout())
for key, value in person.__dict__.items():
setattr(self, key+str(ind), QLabel(self))
parametr = getattr(self, key+str(ind))
if key != 'name':
time_val = float(value.split(' ')[-2])
indx = value.find(str(time_val))
parametr.setText(key+' time: '+value[:indx]+str(int(time_val))+value[value.find('sec')-1:])
else:
parametr.setText(value)
but_ind = getattr(self, 'button'+str(ind))
but_ind.addWidget(parametr)
if ind%2 == 0:
box_lay = getattr(self, 'buttons'+str(ind))
else:
box_lay = getattr(self, 'buttons'+str(ind-1))
box_lay.addLayout(but_ind)
self.vlayout.insertLayout(-2,box_lay)
def update_row(self):
key = list(self.people[-1].__dict__.keys())[-1]
count = 0
for name in self.button_names:
but_ind = getattr(self, name)
setattr(self, key+str(count), QLabel(self))
parametr = getattr(self, key+str(count))
parametr.setText(key+' time: 0 hrs 0 min 0.0 sec')
but_ind.addWidget(parametr)
count += 1
class App(QMainWindow):
def __init__(self):
super().__init__()
self.title = 'logextracter-gui'
self.left = 10
self.top = 10
self.width = 1024
self.height = 400
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
openSrcFolderAction = QAction(QIcon('opensrcfolder.png'), 'SRC Folder',
self)
openSrcFolderAction.setShortcut('Ctrl+S')
openSrcFolderAction.setStatusTip('Open the source folder')
openSrcFolderAction.triggered.connect(self.browseSrcFolder)
openDestFolderAction = QAction(QIcon('opendestfolder.png'),
'DEST Folder', self)
openDestFolderAction.setShortcut('Ctrl+D')
openDestFolderAction.setStatusTip('Open the destination folder')
openDestFolderAction.triggered.connect(self.browseDestFolder)
exitAction = QAction(QIcon('exit.png'), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.close)
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
fileMenu.addAction(openSrcFolderAction)
fileMenu.addAction(openDestFolderAction)
fileMenu.addAction(exitAction)
helpMenu = menuBar.addMenu('&Help')
self.srcModel = QFileSystemModel()
self.srcModel.setRootPath(QDir.currentPath())
self.srcTree = QTreeView()
self.srcTree.setModel(self.srcModel)
self.srcTree.setRootIndex(self.srcModel.index(QDir.currentPath()))
self.srcTree.setAnimated(False)
self.srcTree.setIndentation(20)
self.srcTree.setSortingEnabled(True)
self.srcTree.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.destModel = QFileSystemModel()
self.destModel.setRootPath(QDir.currentPath())
self.destTree = QTreeView()
self.destTree.setModel(self.destModel)
self.destTree.setRootIndex(self.destModel.index(QDir.currentPath()))
self.destTree.setAnimated(False)
self.destTree.setIndentation(20)
self.destTree.setSortingEnabled(True)
self.extractButton = QPushButton()
self.extractButton.setText('====>')
self.extractButton.clicked.connect(self.extract)
mainLayout = QHBoxLayout()
mainLayout.addWidget(self.srcTree)
mainLayout.addWidget(self.extractButton)
mainLayout.addWidget(self.destTree)
self.centralWidget = QWidget()
self.centralWidget.setLayout(mainLayout)
self.setCentralWidget(self.centralWidget)
self.show()
def browseSrcFolder(self):
directory = QFileDialog.getExistingDirectory(self,
'Open the source folder',
QDir.currentPath())
if directory:
self.srcTree.setRootIndex(self.srcModel.index(directory))
def browseDestFolder(self):
directory = QFileDialog.getExistingDirectory(self,
'Open the source folder',
QDir.currentPath())
if directory:
self.destTree.setRootIndex(self.destModel.index(directory))
def extract(self):
selectionModel = self.srcTree.selectionModel()
indexes = selectionModel.selectedRows(0)
logFilenameList = []
excelFilenameList = []
for index in indexes:
logFilename = self.srcModel.filePath(index)
excelFilename = QDir(
self.destModel.filePath(
self.destTree.rootIndex())).absoluteFilePath(
self.srcModel.fileName(index).replace('.log', '.xlsx'))
logFilenameList.append(logFilename)
excelFilenameList.append(excelFilename)
self.extractThread = ExtractThread()
self.extractThread.setLogFilenameList(logFilenameList)
self.extractThread.setExcelFilenameList(excelFilenameList)
self.extractThread.completed.connect(self.updateStatusBar)
self.extractThread.start()
# for index in indexes:
# logFilename = self.srcModel.filePath(index)
# excelFilename = QDir(self.destModel.filePath(self.destTree.rootIndex())).absoluteFilePath(self.srcModel.fileName(index).replace('.log', '.xlsx'))
# data = parseFile(logFilename)
# saveToExcel(excelFilename, data)
def updateStatusBar(self, message):
self.statusBar().showMessage(message)
class clientUI_Interface(Ui_ClientUI):
'''
Mediator class between the logic and the Presentation
'''
def __init__(self, ftpClientUIMain, ftpClient, homeDir):
Ui_ClientUI.__init__(self)
self.setupUi(ftpClientUIMain)
self.ftpClient = ftpClient
#-----------------Local------------------------------------------------------
self.homeDir = homeDir
self.localDir_treeView.setContextMenuPolicy(
QtCore.Qt.CustomContextMenu)
self.localDir_treeView.customContextMenuRequested.connect(
self.localMenu)
self.populateLocalDir()
#-----------------remote----------------------------------------------------
self.remoteDir_tableWidget.setContextMenuPolicy(
QtCore.Qt.CustomContextMenu)
self.remoteDir_tableWidget.customContextMenuRequested.connect(
self.remoteMenu)
# Reset and hide progress bar
self.progressBar.setValue(0)
self.progressBar.hide()
# Disable all remote widgets and buttons
self.Back_pushButton.setEnabled(False)
self.Quit_pushButton.setEnabled(False)
self.btn_refreshRemoteDir.setEnabled(False)
self.remoteDir_tableWidget.setEnabled(False)
self.dirName_lineEdit.setEnabled(False)
self.btn_createDir.setEnabled(False)
self.btn_Cancell_createDir.setEnabled(False)
# Initialise the table for listing files
self.updateServerDirectoryList()
# Create a thread pool
self.threadpool = QtCore.QThreadPool()
#----------------------- ACTION FUNCTIONS -------------------------------
self.connect_pushButton.clicked.connect(self.connectToServer)
self.Quit_pushButton.clicked.connect(self.quit)
self.btn_refreshRemoteDir.clicked.connect(self.refreshRemote)
self.btn_RefreshLocalDir.clicked.connect(self.refreshLocal)
self.btn_createDir.clicked.connect(self.createDir)
self.btn_Cancell_createDir.clicked.connect(self.disableFolderEdit)
self.Back_pushButton.clicked.connect(self.directoryReturn)
self.remoteDir_tableWidget.doubleClicked.connect(self.openFolder)
#==================================================================================
def setSatus(self, isError, status):
self.ftpClient.isError = isError
self.ftpClient.server_response = status
self.dispStatus()
#==================================================================================
def dispStatus(self):
if self.ftpClient.isError:
self.status_label.setStyleSheet(
'color: red; font-family:Times New Roman')
else:
self.status_label.setStyleSheet(
'color: blue; font-family:Times New Roman; font-size: 11pt')
self.status_label.setText(str(self.ftpClient.server_response))
#==================================================================================
def connectToServer(self):
if not self.ftpClient.IsConnected:
self.ftpClient.initializeFTPConnection(
str(self.lineEdit_host.text()))
self.dispStatus()
self.loginToServer()
if self.ftpClient.IsValidUser:
self.Quit_pushButton.setEnabled(True)
self.connect_pushButton.setEnabled(False)
self.connect_pushButton.setText("Connect")
self.Back_pushButton.setEnabled(True)
self.btn_refreshRemoteDir.setEnabled(True)
self.remoteDir_tableWidget.setEnabled(True)
self.refreshRemote()
self.conStatus.setStyleSheet(
'color: blue; font-family:Times New Roman; font-size: 11pt')
self.conStatus.setText("Online : ")
self.dispStatus()
#==================================================================================
def loginToServer(self):
if self.ftpClient.IsConnected:
self.connect_pushButton.setText("Login")
username = str(self.lineEdit_username.text())
password = str(self.lineEdit_Password.text())
self.ftpClient.login(username, password)
self.dispStatus()
#==================================================================================
def populateLocalDir(self):
self.localModel = QFileSystemModel()
self.localModel.setRootPath(QtCore.QDir.rootPath())
self.localDir_treeView.setModel(self.localModel)
self.localDir_treeView.setRootIndex(
self.localModel.index(str(self.homeDir)))
self.localDir_treeView.setSortingEnabled(True)
#==================================================================================
def localMenu(self):
local_menu = QtWidgets.QMenu()
fileUpload = local_menu.addAction("Upload")
fileUpload.triggered.connect(self.uploadFile)
cursor = QtGui.QCursor() #privide a cursor location
local_menu.exec_(cursor.pos()) # pass it to the menu executor
#==================================================================================
def uploadFile(self):
if self.ftpClient.IsConnected:
local_index = self.localDir_treeView.currentIndex()
filename = self.localModel.fileName(local_index)
filepath = self.localModel.filePath(local_index)
#self.ftpClient.upload_file(filename)
self.ftpClient.upLoadList.append(filename)
uploadThread = actionHandler(self.ftpClient.upload_file, filename,
filepath)
uploadThread.signals.finished.connect(self.uploadThreadComplete)
uploadThread.signals.error.connect(self.uploadFailed)
uploadThread.signals.fileProgress.connect(
self.displayUploadProgBar)
self.threadpool.start(uploadThread)
msg = "Upload file : " + filename
self.setSatus(False, msg)
self.dispStatus()
else:
self.uploadFailed()
self.disconnected()
#==================================================================================
def uploadFailed(self):
msg = "Upload Failed, Check connection"
self.setSatus(True, msg)
self.dispStatus()
print(msg)
#==================================================================================
def uploadThreadComplete(self):
self.setSatus(False, "Done Uploading")
self.dispStatus()
self.progressBar.hide()
self.up_downLoadlabel.setText("")
self.progressBar.setEnabled(False)
self.Back_pushButton.setEnabled(True)
self.btn_refreshRemoteDir.setEnabled(True)
self.remoteDir_tableWidget.setEnabled(True)
self.refreshRemote()
#==================================================================================
def displayUploadProgBar(self): #, filename)
if len(self.ftpClient.upLoadList) is not 0:
self.progressBar.show()
self.progressBar.setEnabled(True)
self.up_downLoadlabel.setText("Uploading file")
self.progressBar.setValue(self.ftpClient.getProgressVal())
return
#==================================================================================
def remoteMenu(self):
remote_menu = QtWidgets.QMenu()
fileDownload = remote_menu.addAction("Download")
fileDownload.triggered.connect(self.downloadFile)
fileDownload = remote_menu.addAction("Open")
fileDownload.triggered.connect(self.openFolder)
fileDownload = remote_menu.addAction("Delete")
fileDownload.triggered.connect(self.deleteFile)
fileDownload = remote_menu.addAction("New Folder")
fileDownload.triggered.connect(self.enableFolderEdit)
cursor = QtGui.QCursor()
remote_menu.exec_(cursor.pos())
#==================================================================================
def deleteFile(self):
for currentQTableWidgetRow in self.remoteDir_tableWidget.selectionModel(
).selectedRows():
if currentQTableWidgetRow.row() != 0:
try:
filename = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 0).text()
permission = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 3).text()
if permission.find('d') is not -1:
path = self.addPath(filename)
self.ftpClient.directory_delete(path)
self.dispStatus()
self.refreshRemote()
else:
path = self.addPath(filename)
self.ftpClient.file_delete(path)
self.dispStatus()
self.refreshRemote()
except:
self.setSatus(True, "Cant delete File")
self.dispStatus()
return
#==================================================================================
def enableFolderEdit(self):
self.dirName_lineEdit.setEnabled(True)
self.btn_createDir.setEnabled(True)
self.label_foldername.setEnabled(True)
self.btn_Cancell_createDir.setEnabled(True)
self.Back_pushButton.setEnabled(False)
self.btn_refreshRemoteDir.setEnabled(False)
self.remoteDir_tableWidget.setEnabled(False)
#==================================================================================
def disableFolderEdit(self):
self.btn_Cancell_createDir.setEnabled(False)
self.dirName_lineEdit.setEnabled(False)
self.label_foldername.setEnabled(False)
self.btn_createDir.setEnabled(False)
self.Back_pushButton.setEnabled(True)
self.btn_refreshRemoteDir.setEnabled(True)
self.remoteDir_tableWidget.setEnabled(True)
#==================================================================================
def createDir(self):
self.dirName_lineEdit.setFocus()
directoryName = str(self.dirName_lineEdit.text())
self.dirName_lineEdit.clear()
self.ftpClient.directory_create(directoryName)
self.disableFolderEdit()
self.dispStatus()
self.refreshRemote()
return
#==================================================================================
def addPath(self, filename):
self.ftpClient.directory_print()
print(self.ftpClient.serverDir)
self.ftpClient.serverDir = self.ftpClient.serverDir.replace('\r\n', '')
s = '\\'
path = self.ftpClient.serverDir + s + filename
path = [self.ftpClient.serverDir, str(filename)]
path = '\\'.join(path)
return path
#==================================================================================
def openFolder(self):
for currentQTableWidgetRow in self.remoteDir_tableWidget.selectionModel(
).selectedRows():
try:
filename = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 0).text()
except:
return
if (filename == ".."):
self.directoryReturn()
elif not (filename == ".."):
try:
permission = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 3).text()
if permission.find('d') is not -1:
path = self.addPath(filename)
print('path :', path)
self.ftpClient.directory_change(path)
self.dispStatus()
self.refreshRemote()
else:
self.setSatus(True, "Cant open file, Download instead")
self.dispStatus()
except:
self.setSatus(True, "Cant open file, Download instead")
self.dispStatus()
else:
self.updateCurrentDir()
self.ftpClient.directory_print()
self.dispStatus()
self.refreshRemote()
#==================================================================================
def directoryReturn(self):
self.ftpClient.directory_return()
self.ftpClient.directory_print()
self.dispStatus()
self.refreshRemote()
#==================================================================================
def downloadFile(self):
for currentQTableWidgetRow in self.remoteDir_tableWidget.selectionModel(
).selectedRows():
try:
filename = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 0).text()
except:
return
permission = self.remoteDir_tableWidget.item(
currentQTableWidgetRow.row(), 3).text()
if permission.find('d') is -1:
try:
#saveFileInDirectory = str(QtWidgets.QFileDialog.getExistingDirectory(None, "Save File In Directory", currentDirectory,\
#QtWidgets.QFileDialog.ShowDirsOnly))
self.ftpClient.downloadList.append(filename)
self.callDownloadFn()
downloadThread = actionHandler(
self.ftpClient.download_file, filename)
downloadThread.signals.finished.connect(
self.downloadThreadComplete)
downloadThread.signals.error.connect(self.downloadFailed)
downloadThread.signals.fileProgress.connect(
self.displayDownloadProgBar)
self.threadpool.start(downloadThread)
except:
print("Error creating download Thread")
else:
self.setSatus(True, "Cant downloadFile, Try open instead")
self.dispStatus()
self.dispStatus()
#==================================================================================
def callDownloadFn(self):
self.setSatus(False, "Downloading ...")
self.dispStatus()
self.Back_pushButton.setEnabled(False)
self.btn_refreshRemoteDir.setEnabled(False)
self.remoteDir_tableWidget.setEnabled(False)
#==================================================================================
def downloadFailed(self):
msg = "Download Failed!!"
self.setSatus(True, msg)
self.dispStatus()
print(msg)
#==================================================================================
def downloadThreadComplete(self):
self.setSatus(False, "Done Downloading")
self.dispStatus()
self.refreshRemote()
self.progressBar.hide()
self.up_downLoadlabel.setText("")
self.progressBar.setEnabled(False)
self.Back_pushButton.setEnabled(True)
self.btn_refreshRemoteDir.setEnabled(True)
self.remoteDir_tableWidget.setEnabled(True)
#==================================================================================
def displayDownloadProgBar(self): #, filename)
if len(self.ftpClient.downloadList) is not 0:
self.progressBar.show()
self.progressBar.setEnabled(True)
self.up_downLoadlabel.setText("Downloading file")
self.progressBar.setValue(self.ftpClient.getProgressVal())
return
#==================================================================================
def updateCurrentDir(self):
self.ftpClient.directory_print()
self.remoteDir_lineEdit.setText(str(self.ftpClient.serverDir))
#==================================================================================
def updateServerDirectoryList(self):
try:
self.remoteDir_tableWidget.setRowCount(0)
# set column count
self.remoteDir_tableWidget.setColumnCount(4)
# Set Row Count:
self.remoteDir_tableWidget.setRowCount(
len(self.ftpClient.ListInDir) + 1)
# Default:
header = self.remoteDir_tableWidget.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
header.setSectionResizeMode(1,
QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(2,
QtWidgets.QHeaderView.ResizeToContents)
row = 0
col = 0
for item in self.ftpClient.ListInDir:
print(item)
for fileProperty in item:
fileTypeIco = None
if col == 0:
if item[3].find('x') is -1:
tempFilename = fileProperty.lower()
if tempFilename.endswith(
('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
fileTypeIco = "assets/image.ico"
elif tempFilename.endswith(
('.mp4', '.wmv', '.mkv', '.avi')):
fileTypeIco = "assets/video.ico"
else:
fileTypeIco = "assets/file.ico"
else:
fileTypeIco = "assets/folder.ico"
tempItem = QtWidgets.QTableWidgetItem(
QtGui.QIcon(QtGui.QPixmap(fileTypeIco)), fileProperty)
self.remoteDir_tableWidget.setItem(row, col, tempItem)
col = col + 1
row = row + 1
col = 0
self.remoteDir_tableWidget.setHorizontalHeaderItem(
0, QtWidgets.QTableWidgetItem("Name"))
self.remoteDir_tableWidget.setHorizontalHeaderItem(
1, QtWidgets.QTableWidgetItem("Size"))
self.remoteDir_tableWidget.setHorizontalHeaderItem(
2, QtWidgets.QTableWidgetItem("Last Modified"))
self.remoteDir_tableWidget.setHorizontalHeaderItem(
3, QtWidgets.QTableWidgetItem("Permissions"))
self.remoteDir_tableWidget.setSelectionBehavior(
QtWidgets.QTableView.SelectRows)
except:
self.setSatus(True, "Unable to update Server Directory.")
self.dispStatus()
#==================================================================================
def refreshRemote(self):
if self.ftpClient.IsConnected:
self.ftpClient.getDirList()
self.updateServerDirectoryList()
self.updateCurrentDir()
#self.setSatus(False,"Remote Directory refreshed")
self.dispStatus()
else:
self.disconnected()
#==================================================================================
def refreshLocal(self):
self.populateLocalDir()
#==================================================================================
def updateStatus(self):
time.sleep(1)
if self.ftpClient.IsConnected:
self.status_label.setStyleSheet(
'color: blue; font-family:Times New Roman; font-size: 11pt')
self.status_label.setText("...")
else:
self.disconnected()
#==================================================================================
def disconnected(self):
if not self.ftpClient.IsConnected:
self.Quit_pushButton.setEnabled(False)
self.btn_refreshRemoteDir.setEnabled(False)
self.remoteDir_lineEdit.setText("")
self.remoteDir_tableWidget.clear()
self.remoteDir_tableWidget.setEnabled(False)
self.connect_pushButton.setEnabled(True)
time.sleep(1)
self.conStatus.setStyleSheet(
'color: red; font-family:Times New Roman; font-size: 11pt')
self.conStatus.setText("Offline :")
self.status_label.setText('')
self.Back_pushButton.setEnabled(False)
def quit(self):
if self.ftpClient.IsConnected:
self.ftpClient.logout()
self.Quit_pushButton.setEnabled(False)
self.btn_refreshRemoteDir.setEnabled(False)
self.remoteDir_lineEdit.setText("")
self.remoteDir_tableWidget.clear()
self.remoteDir_tableWidget.setEnabled(False)
self.connect_pushButton.setEnabled(True)
self.conStatus.setStyleSheet(
'color: red; font-family:Times New Roman; font-size: 11pt')
self.conStatus.setText("Offline :")
self.status_label.setText('')
self.Back_pushButton.setEnabled(False)
class FilenamePrompt(_BasePrompt):
"""A prompt for a filename."""
def __init__(self, question, parent=None):
super().__init__(question, parent)
self._init_texts(question)
self._init_key_label()
self._lineedit = LineEdit(self)
if question.default:
self._lineedit.setText(question.default)
self._lineedit.textEdited.connect(self._set_fileview_root)
self._vbox.addWidget(self._lineedit)
self.setFocusProxy(self._lineedit)
self._init_fileview()
self._set_fileview_root(question.default)
if config.val.prompt.filebrowser:
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self._to_complete = ''
@pyqtSlot(str)
def _set_fileview_root(self, path, *, tabbed=False):
"""Set the root path for the file display."""
separators = os.sep
if os.altsep is not None:
separators += os.altsep
dirname = os.path.dirname(path)
basename = os.path.basename(path)
if not tabbed:
self._to_complete = ''
try:
if not path:
pass
elif path in separators and os.path.isdir(path):
# Input "/" -> don't strip anything
pass
elif path[-1] in separators and os.path.isdir(path):
# Input like /foo/bar/ -> show /foo/bar/ contents
path = path.rstrip(separators)
elif os.path.isdir(dirname) and not tabbed:
# Input like /foo/ba -> show /foo contents
path = dirname
self._to_complete = basename
else:
return
except OSError:
log.prompt.exception("Failed to get directory information")
return
root = self._file_model.setRootPath(path)
self._file_view.setRootIndex(root)
@pyqtSlot(QModelIndex)
def _insert_path(self, index, *, clicked=True):
"""Handle an element selection.
Args:
index: The QModelIndex of the selected element.
clicked: Whether the element was clicked.
"""
if index == QModelIndex():
path = os.path.join(self._file_model.rootPath(), self._to_complete)
else:
path = os.path.normpath(self._file_model.filePath(index))
if clicked:
path += os.sep
else:
# On Windows, when we have C:\foo and tab over .., we get C:\
path = path.rstrip(os.sep)
log.prompt.debug('Inserting path {}'.format(path))
self._lineedit.setText(path)
self._lineedit.setFocus()
self._set_fileview_root(path, tabbed=True)
if clicked:
# Avoid having a ..-subtree highlighted
self._file_view.setCurrentIndex(QModelIndex())
def _init_fileview(self):
self._file_view = QTreeView(self)
self._file_model = QFileSystemModel(self)
self._file_view.setModel(self._file_model)
self._file_view.clicked.connect(self._insert_path)
if config.val.prompt.filebrowser:
self._vbox.addWidget(self._file_view)
else:
self._file_view.hide()
# Only show name
self._file_view.setHeaderHidden(True)
for col in range(1, 4):
self._file_view.setColumnHidden(col, True)
# Nothing selected initially
self._file_view.setCurrentIndex(QModelIndex())
# The model needs to be sorted so we get the correct first/last index
self._file_model.directoryLoaded.connect(
lambda: self._file_model.sort(0))
def accept(self, value=None):
text = value if value is not None else self._lineedit.text()
text = downloads.transform_path(text)
if text is None:
message.error("Invalid filename")
return False
self.question.answer = text
return True
def item_focus(self, which):
# This duplicates some completion code, but I don't see a nicer way...
assert which in ['prev', 'next'], which
selmodel = self._file_view.selectionModel()
parent = self._file_view.rootIndex()
first_index = self._file_model.index(0, 0, parent)
row = self._file_model.rowCount(parent) - 1
last_index = self._file_model.index(row, 0, parent)
if not first_index.isValid():
# No entries
return
assert last_index.isValid()
idx = selmodel.currentIndex()
if not idx.isValid():
# No item selected yet
idx = last_index if which == 'prev' else first_index
elif which == 'prev':
idx = self._file_view.indexAbove(idx)
else:
assert which == 'next', which
idx = self._file_view.indexBelow(idx)
# wrap around if we arrived at beginning/end
if not idx.isValid():
idx = last_index if which == 'prev' else first_index
idx = self._do_completion(idx, which)
selmodel.setCurrentIndex(
idx, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
self._insert_path(idx, clicked=False)
def _do_completion(self, idx, which):
filename = self._file_model.fileName(idx)
while not filename.startswith(self._to_complete) and idx.isValid():
if which == 'prev':
idx = self._file_view.indexAbove(idx)
else:
assert which == 'next', which
idx = self._file_view.indexBelow(idx)
filename = self._file_model.fileName(idx)
return idx
def _allowed_commands(self):
return [('prompt-accept', 'Accept'), ('leave-mode', 'Abort')]
class DipteraTrack(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(DipteraTrack, self).__init__(parent)
self.setupUi(self)
# Session parameters:
self.session_loc = '...'
self.session_name = '...'
self.bckg_loc = '...'
self.bckg_img_format = '...'
self.cal_loc = '...'
self.cal_name = '...'
self.cal_img_format = '...'
self.bckg_img_list = []
self.mov_name_list = []
self.cam_name_list = []
self.N_mov = 0
self.N_cam = 0
self.frame_name = '...'
self.frame_img_format = '...'
self.model_loc = '...'
self.model_name = '...'
self.start_frame = 0
self.trig_frame = 0
self.end_frame = 0
self.trigger_mode = '...'
self.mov_1_name = '...'
self.mov_2_name = '...'
self.mov_3_name = '...'
self.mov_4_name = '...'
self.mov_5_name = '...'
self.mov_6_name = '...'
self.mov_7_name = '...'
self.mov_8_name = '...'
self.cam_1_name = '...'
self.cam_2_name = '...'
self.cam_3_name = '...'
self.cam_4_name = '...'
self.cam_5_name = '...'
self.cam_6_name = '...'
self.img_formats = ['...', 'bmp', 'tif']
self.trig_modes = ['...', 'start', 'center', 'end']
self.ses_par_file = ''
# Focal grid parameters:
self.nx = None
self.ny = None
self.nz = None
self.ds = None
self.x0 = None
self.y0 = None
self.z0 = None
self.pixel_size = None
self.flt = Flight_Tracker_Class()
self.initialize()
self.connectActions()
def initialize(self):
self.add_session_param_gui()
self.add_focal_grid_gui()
self.add_model_scale_gui()
self.add_model_view_gui()
self.add_image_segment_gui()
self.add_pcl_view_gui()
self.add_contour_view_gui()
def connectActions(self):
self.connect_session_param_gui()
self.connect_focal_grid_gui()
self.connect_model_scale_gui()
self.connect_model_view_gui()
self.connect_image_segment_gui()
self.connect_pcl_view_gui()
self.connect_contour_view_gui()
def add_session_param_gui(self):
self.ses_folder_rbtn.toggled.connect(lambda: self.ses_folder_rbtn)
self.bckg_folder_rbtn.toggled.connect(lambda: self.bckg_folder_rbtn)
self.cal_folder_rbtn.toggled.connect(lambda: self.cal_folder_rbtn)
self.mov_folder1_rbtn.toggled.connect(lambda: self.mov_folder1_rbtn)
self.mov_folder2_rbtn.toggled.connect(lambda: self.mov_folder2_rbtn)
self.mov_folder3_rbtn.toggled.connect(lambda: self.mov_folder3_rbtn)
self.mov_folder4_rbtn.toggled.connect(lambda: self.mov_folder4_rbtn)
self.mov_folder5_rbtn.toggled.connect(lambda: self.mov_folder5_rbtn)
self.mov_folder6_rbtn.toggled.connect(lambda: self.mov_folder6_rbtn)
self.mov_folder7_rbtn.toggled.connect(lambda: self.mov_folder7_rbtn)
self.mov_folder8_rbtn.toggled.connect(lambda: self.mov_folder8_rbtn)
self.cam_folder1_rbtn.toggled.connect(lambda: self.cam_folder1_rbtn)
self.cam_folder2_rbtn.toggled.connect(lambda: self.cam_folder2_rbtn)
self.cam_folder3_rbtn.toggled.connect(lambda: self.cam_folder3_rbtn)
self.cam_folder4_rbtn.toggled.connect(lambda: self.cam_folder4_rbtn)
self.cam_folder5_rbtn.toggled.connect(lambda: self.cam_folder5_rbtn)
self.cam_folder6_rbtn.toggled.connect(lambda: self.cam_folder6_rbtn)
self.frame_name_rbtn.toggled.connect(lambda: self.frame_name_rbtn)
self.mdl_loc_rbtn.toggled.connect(lambda: self.mdl_loc_rbtn)
self.mdl_name_rbtn.toggled.connect(lambda: self.mdl_name_rbtn)
self.load_settings_rbtn.toggled.connect(
lambda: self.load_settings_rbtn)
self.bck_img_fmt_box.addItem(self.img_formats[0])
self.bck_img_fmt_box.addItem(self.img_formats[1])
self.bck_img_fmt_box.addItem(self.img_formats[2])
self.cal_img_fmt_box.addItem(self.img_formats[0])
self.cal_img_fmt_box.addItem(self.img_formats[1])
self.cal_img_fmt_box.addItem(self.img_formats[2])
self.frame_img_fmt_box.addItem(self.img_formats[0])
self.frame_img_fmt_box.addItem(self.img_formats[1])
self.frame_img_fmt_box.addItem(self.img_formats[2])
self.trig_mode_box.addItem(self.trig_modes[0])
self.trig_mode_box.addItem(self.trig_modes[1])
self.trig_mode_box.addItem(self.trig_modes[2])
self.trig_mode_box.addItem(self.trig_modes[3])
self.start_frame_spin.setMinimum(0)
self.start_frame_spin.setMaximum(0)
self.start_frame_spin.setValue(0)
self.start_frame_spin.valueChanged.connect(self.set_start_frame)
self.trig_frame_spin.setMinimum(0)
self.trig_frame_spin.setMaximum(0)
self.trig_frame_spin.setValue(0)
self.trig_frame_spin.valueChanged.connect(self.set_trig_frame)
self.end_frame_spin.setMinimum(0)
self.end_frame_spin.setMaximum(0)
self.end_frame_spin.setValue(0)
self.end_frame_spin.valueChanged.connect(self.set_end_frame)
self.reset_selection_push_btn.clicked.connect(self.reset_selection)
self.load_settings_push_btn.clicked.connect(self.load_session_file)
self.save_settings_push_btn.clicked.connect(self.save_session_file)
directory = '/media/flyami'
self.file_model = QFileSystemModel()
self.file_model.setRootPath(directory)
self.folder_select_tree.setModel(self.file_model)
self.folder_select_tree.setRootIndex(self.file_model.index(directory))
def connect_session_param_gui(self):
self.tabs.setTabEnabled(1, False)
self.folder_select_tree.clicked.connect(self.select_folder_file)
self.bck_img_fmt_box.currentIndexChanged.connect(
self.set_bckg_img_format)
self.cal_img_fmt_box.currentIndexChanged.connect(
self.set_cal_img_format)
self.frame_img_fmt_box.currentIndexChanged.connect(
self.set_frame_img_format)
self.trig_mode_box.currentIndexChanged.connect(self.set_trigger_mode)
self.start_session_push_btn.clicked.connect(self.start_session)
def select_folder_file(self, index):
indexItem = self.file_model.index(index.row(), 0, index.parent())
fileName = self.file_model.fileName(indexItem)
filePath = self.file_model.filePath(indexItem)
if self.ses_folder_rbtn.isChecked():
self.session_loc = filePath
self.session_name = fileName
self.ses_folder_label.setText(self.session_loc)
self.ses_name_label.setText(self.session_name)
elif self.bckg_folder_rbtn.isChecked():
self.bckg_loc = fileName
self.bckg_folder_label.setText(self.bckg_loc)
elif self.cal_folder_rbtn.isChecked():
self.cal_loc = fileName
self.cal_folder_label.setText(self.cal_loc)
try:
for file_name in os.listdir(self.session_loc + '/' +
self.cal_loc):
if file_name.endswith("calib.txt"):
self.cal_name = file_name
self.cal_file_label.setText(self.cal_name)
except:
self.cal_name = '...'
self.cal_file_label.setText(self.cal_name)
elif self.mov_folder1_rbtn.isChecked():
self.mov_1_name = fileName
self.mov_folder1_label.setText(fileName)
elif self.mov_folder2_rbtn.isChecked():
self.mov_2_name = fileName
self.mov_folder2_label.setText(fileName)
elif self.mov_folder3_rbtn.isChecked():
self.mov_3_name = fileName
self.mov_folder3_label.setText(fileName)
elif self.mov_folder4_rbtn.isChecked():
self.mov_4_name = fileName
self.mov_folder4_label.setText(fileName)
elif self.mov_folder5_rbtn.isChecked():
self.mov_5_name = fileName
self.mov_folder5_label.setText(fileName)
elif self.mov_folder6_rbtn.isChecked():
self.mov_6_name = fileName
self.mov_folder6_label.setText(fileName)
elif self.mov_folder7_rbtn.isChecked():
self.mov_7_name = fileName
self.mov_folder7_label.setText(fileName)
elif self.mov_folder8_rbtn.isChecked():
self.mov_8_name = fileName
self.mov_folder8_label.setText(fileName)
elif self.cam_folder1_rbtn.isChecked():
self.cam_1_name = fileName
self.cam_folder1_label.setText(fileName)
elif self.cam_folder2_rbtn.isChecked():
self.cam_2_name = fileName
self.cam_folder2_label.setText(fileName)
elif self.cam_folder3_rbtn.isChecked():
self.cam_3_name = fileName
self.cam_folder3_label.setText(fileName)
elif self.cam_folder4_rbtn.isChecked():
self.cam_4_name = fileName
self.cam_folder4_label.setText(fileName)
elif self.cam_folder5_rbtn.isChecked():
self.cam_5_name = fileName
self.cam_folder5_label.setText(fileName)
elif self.cam_folder6_rbtn.isChecked():
self.cam_6_name = fileName
self.cam_folder6_label.setText(fileName)
elif self.frame_name_rbtn.isChecked():
try:
frame_name_split = fileName.split('_', 1)
self.frame_name = frame_name_split[0] + '_'
self.frame_name_label.setText(self.frame_name)
except:
self.frame_name = '...'
self.frame_name_label.setText(self.frame_name)
elif self.mdl_loc_rbtn.isChecked():
self.model_loc = filePath
self.mdl_loc_label.setText(self.model_loc)
elif self.mdl_name_rbtn.isChecked():
self.model_name = fileName
self.mdl_name_label.setText(self.model_name)
elif self.load_settings_rbtn.isChecked():
self.ses_par_file = filePath
self.load_settings_file_label.setText(self.ses_par_file)
def reset_selection(self):
if self.ses_folder_rbtn.isChecked():
self.session_loc = '...'
self.session_name = '...'
self.ses_folder_label.setText(self.session_loc)
self.ses_name_label.setText(self.session_name)
elif self.bckg_folder_rbtn.isChecked():
self.bckg_loc = '...'
self.bckg_folder_label.setText(self.bckg_loc)
elif self.cal_folder_rbtn.isChecked():
self.cal_loc = '...'
self.cal_folder_label.setText(self.cal_loc)
self.cal_name = '...'
self.cal_file_label.setText(self.cal_name)
elif self.mov_folder1_rbtn.isChecked():
self.mov_1_name = '...'
self.mov_folder1_label.setText(self.mov_1_name)
elif self.mov_folder2_rbtn.isChecked():
self.mov_2_name = '...'
self.mov_folder2_label.setText(self.mov_2_name)
elif self.mov_folder3_rbtn.isChecked():
self.mov_3_name = '...'
self.mov_folder3_label.setText(self.mov_3_name)
elif self.mov_folder4_rbtn.isChecked():
self.mov_4_name = '...'
self.mov_folder4_label.setText(self.mov_4_name)
elif self.mov_folder5_rbtn.isChecked():
self.mov_5_name = '...'
self.mov_folder5_label.setText(self.mov_5_name)
elif self.mov_folder6_rbtn.isChecked():
self.mov_6_name = '...'
self.mov_folder6_label.setText(self.mov_6_name)
elif self.mov_folder7_rbtn.isChecked():
self.mov_7_name = '...'
self.mov_folder7_label.setText(self.mov_7_name)
elif self.mov_folder8_rbtn.isChecked():
self.mov_8_name = '...'
self.mov_folder8_label.setText(self.mov_8_name)
elif self.cam_folder1_rbtn.isChecked():
self.cam_1_name = '...'
self.cam_folder1_label.setText(self.cam_1_name)
elif self.cam_folder2_rbtn.isChecked():
self.cam_2_name = '...'
self.cam_folder2_label.setText(self.cam_2_name)
elif self.cam_folder3_rbtn.isChecked():
self.cam_3_name = '...'
self.cam_folder3_label.setText(self.cam_3_name)
elif self.cam_folder4_rbtn.isChecked():
self.cam_4_name = '...'
self.cam_folder4_label.setText(self.cam_4_name)
elif self.cam_folder5_rbtn.isChecked():
self.cam_5_name = '...'
self.cam_folder5_label.setText(self.cam_5_name)
elif self.cam_folder6_rbtn.isChecked():
self.cam_6_name = '...'
self.cam_folder6_label.setText(self.cam_6_name)
elif self.frame_name_rbtn.isChecked():
self.frame_name = '...'
self.frame_name_label.setText(self.frame_name)
elif self.mdl_loc_rbtn.isChecked():
self.model_loc = '...'
self.mdl_loc_label.setText(self.model_loc)
elif self.mdl_name_rbtn.isChecked():
self.model_name = '...'
self.mdl_name_label.setText(self.model_name)
def set_start_frame(self, val):
self.start_frame = val
def set_trig_frame(self, val):
self.trig_frame = val
def set_end_frame(self, val):
self.end_frame = val
def set_bckg_img_format(self, ind):
self.bckg_img_format = self.img_formats[ind]
def set_cal_img_format(self, ind):
self.cal_img_format = self.img_formats[ind]
def set_frame_img_format(self, ind):
self.frame_img_format = self.img_formats[ind]
def set_trigger_mode(self, ind):
self.trigger_mode = self.trig_modes[ind]
if (ind == 0):
self.start_frame_spin.setMinimum(0)
self.start_frame_spin.setMaximum(0)
self.start_frame_spin.setValue(0)
self.trig_frame_spin.setMinimum(0)
self.trig_frame_spin.setMaximum(0)
self.trig_frame_spin.setValue(0)
self.end_frame_spin.setMinimum(0)
self.end_frame_spin.setMaximum(0)
self.end_frame_spin.setValue(0)
self.start_frame = 0
self.trig_frame = 0
self.end_frame = 0
elif (ind == 1):
# Start trigger mode:
try:
file_count = 0
for file_name in os.listdir(self.session_loc + '/' +
self.mov_1_name + '/' +
self.cam_1_name):
if file_name.endswith(self.frame_img_format):
file_count += 1
frame_start = 0
frame_trig = 0
frame_end = file_count - 1
except:
frame_start = 0
frame_trig = 0
frame_end = 0
self.start_frame_spin.setMinimum(frame_start)
self.start_frame_spin.setMaximum(frame_trig)
self.start_frame_spin.setValue(frame_start)
self.trig_frame_spin.setMinimum(frame_start)
self.trig_frame_spin.setMaximum(frame_end)
self.trig_frame_spin.setValue(frame_trig)
self.end_frame_spin.setMinimum(frame_trig)
self.end_frame_spin.setMaximum(frame_end)
self.end_frame_spin.setValue(frame_end)
self.start_frame = frame_start
self.trig_frame = frame_trig
self.end_frame = frame_end
elif (ind == 2):
# Center trigger mode:
try:
file_count = 0
for file_name in os.listdir(self.session_loc + '/' +
self.mov_1_name + '/' +
self.cam_1_name):
if file_name.endswith(self.frame_img_format):
file_count += 1
frame_start = 0
frame_trig = int(np.ceil(file_count / 2.0))
frame_end = file_count - 1
except:
frame_start = 0
frame_trig = 0
frame_end = 0
self.start_frame_spin.setMinimum(frame_start)
self.start_frame_spin.setMaximum(frame_trig)
self.start_frame_spin.setValue(frame_start)
self.trig_frame_spin.setMinimum(frame_start)
self.trig_frame_spin.setMaximum(frame_end)
self.trig_frame_spin.setValue(frame_trig)
self.end_frame_spin.setMinimum(frame_trig)
self.end_frame_spin.setMaximum(frame_end)
self.end_frame_spin.setValue(frame_end)
self.start_frame = frame_start
self.trig_frame = frame_trig
self.end_frame = frame_end
elif (ind == 3):
# End trigger mode:
try:
file_count = 0
for file_name in os.listdir(self.session_loc + '/' +
self.mov_1_name + '/' +
self.cam_1_name):
if file_name.endswith(self.frame_img_format):
file_count += 1
frame_start = 0
frame_trig = file_count - 1
frame_end = file_count - 1
except:
frame_start = 0
frame_trig = 0
frame_end = 0
self.start_frame_spin.setMinimum(frame_start)
self.start_frame_spin.setMaximum(frame_trig)
self.start_frame_spin.setValue(frame_start)
self.trig_frame_spin.setMinimum(frame_start)
self.trig_frame_spin.setMaximum(frame_end)
self.trig_frame_spin.setValue(frame_trig)
self.end_frame_spin.setMinimum(frame_trig)
self.end_frame_spin.setMaximum(frame_end)
self.end_frame_spin.setValue(frame_end)
self.start_frame = frame_start
self.trig_frame = frame_trig
self.end_frame = frame_end
def start_session(self):
# Check parameters
par_okay = True
if (self.session_loc == '...'):
par_okay = False
print('No session folder')
if (self.session_name == '...'):
par_okay = False
print('No session name')
if (self.bckg_loc == '...'):
par_okay = False
print('No background folder')
if (self.bckg_img_format == '...'):
par_okay = False
print('No background image format')
if (self.cal_loc == '...'):
par_okay = False
print('No calibration folder')
if (self.cal_name == '...'):
par_okay = False
print('No calibration file')
if (self.cal_img_format == '...'):
par_okay = False
print('No calibration image format')
if (self.mov_1_name == '...'):
par_okay = False
print('No movie folders selected')
if (self.cam_1_name == '...'):
par_okay = False
print('No camera folders selected')
if (self.frame_name == '...'):
par_okay = False
print('No frame name')
if (self.frame_img_format == '...'):
par_okay = False
print('No frame image format')
if (self.model_loc == '...'):
par_okay = False
print('No model folder')
if (self.model_name == '...'):
par_okay = False
print('No model selected')
if (self.trigger_mode == '...'):
par_okay = False
print('No trigger mode selected')
try:
self.bckg_img_list = []
for file_name in os.listdir(self.session_loc + '/' +
self.bckg_loc):
if file_name.endswith(self.bckg_img_format):
self.bckg_img_list.append(str(file_name))
self.bckg_img_list.sort()
#print(self.bckg_img_list)
except:
par_okay = False
self.bckg_img_list = []
print('Could not find background images')
if (par_okay):
if (self.mov_1_name != '...'):
self.mov_name_list.append(str(self.mov_1_name))
if (self.mov_2_name != '...'):
self.mov_name_list.append(str(self.mov_2_name))
if (self.mov_3_name != '...'):
self.mov_name_list.append(str(self.mov_3_name))
if (self.mov_4_name != '...'):
self.mov_name_list.append(str(self.mov_4_name))
if (self.mov_5_name != '...'):
self.mov_name_list.append(str(self.mov_5_name))
if (self.mov_6_name != '...'):
self.mov_name_list.append(str(self.mov_6_name))
if (self.mov_7_name != '...'):
self.mov_name_list.append(str(self.mov_7_name))
if (self.mov_8_name != '...'):
self.mov_name_list.append(str(self.mov_8_name))
self.mov_name_list.sort()
self.N_mov = len(self.mov_name_list)
print('Number of movies: ' + str(self.N_mov))
print(self.mov_name_list)
if (self.cam_1_name != '...'):
self.cam_name_list.append(str(self.cam_1_name))
if (self.cam_2_name != '...'):
self.cam_name_list.append(str(self.cam_2_name))
if (self.cam_3_name != '...'):
self.cam_name_list.append(str(self.cam_3_name))
if (self.cam_4_name != '...'):
self.cam_name_list.append(str(self.cam_4_name))
if (self.cam_5_name != '...'):
self.cam_name_list.append(str(self.cam_5_name))
if (self.cam_6_name != '...'):
self.cam_name_list.append(str(self.cam_6_name))
self.cam_name_list.sort()
self.N_cam = len(self.cam_name_list)
print('Number of cameras: ' + str(self.N_cam))
print(self.cam_name_list)
# Transfer parameters to the flight_tracker_class.py
self.flt.N_cam = self.N_cam
self.flt.N_mov = self.N_mov
self.flt.session_loc = str(self.session_loc)
self.flt.session_name = str(self.session_name)
self.flt.bckg_loc = str(self.bckg_loc)
self.flt.bckg_img_list = self.bckg_img_list
self.flt.bckg_img_format = str(self.bckg_img_format)
self.flt.cal_loc = str(self.cal_loc)
self.flt.cal_name = str(self.cal_name)
self.flt.cal_img_format = str(self.cal_img_format)
self.flt.mov_name_list = self.mov_name_list
self.flt.cam_name_list = self.cam_name_list
self.flt.frame_name = str(self.frame_name)
self.flt.frame_img_format = str(self.frame_img_format)
self.flt.model_loc = str(self.model_loc)
self.flt.model_name = str(self.model_name)
self.flt.start_point = self.start_frame
self.flt.trig_point = self.trig_frame
self.flt.end_point = self.end_frame
self.flt.trigger_mode = str(self.trigger_mode)
self.flt.set_parameters()
self.flt.print_parameters()
self.tabs.setTabEnabled(1, True)
def load_session_file(self):
# Load session parameter file
try:
pickle_in = open(self.ses_par_file, 'rb')
ses_dict = pickle.load(pickle_in)
self.session_loc = ses_dict['session_loc']
self.session_name = ses_dict['session_name']
self.bckg_loc = ses_dict['bckg_loc']
self.bckg_img_list = ses_dict['bckg_img_list']
self.bckg_img_format = ses_dict['bckg_img_format']
self.cal_loc = ses_dict['cal_loc']
self.cal_name = ses_dict['cal_name']
self.cal_img_format = ses_dict['cal_img_format']
self.mov_1_name = ses_dict['mov_1_name']
self.mov_2_name = ses_dict['mov_2_name']
self.mov_3_name = ses_dict['mov_3_name']
self.mov_4_name = ses_dict['mov_4_name']
self.mov_5_name = ses_dict['mov_5_name']
self.mov_6_name = ses_dict['mov_6_name']
self.mov_7_name = ses_dict['mov_7_name']
self.mov_8_name = ses_dict['mov_8_name']
self.cam_1_name = ses_dict['cam_1_name']
self.cam_2_name = ses_dict['cam_2_name']
self.cam_3_name = ses_dict['cam_3_name']
self.cam_4_name = ses_dict['cam_4_name']
self.cam_5_name = ses_dict['cam_5_name']
self.cam_6_name = ses_dict['cam_6_name']
self.frame_name = ses_dict['frame_name']
self.frame_img_format = ses_dict['frame_img_format']
self.model_loc = ses_dict['model_loc']
self.model_name = ses_dict['model_name']
self.trigger_mode = ses_dict['trigger_mode']
self.start_frame = ses_dict['start_frame']
self.trig_frame = ses_dict['trig_frame']
self.end_frame = ses_dict['end_frame']
print('loaded session parameters')
except:
print('could not load session parameter file')
def save_session_file(self):
# Save session paramter file
try:
ses_dict = {
'session_loc': self.session_loc,
'session_name': self.session_name,
'bckg_loc': self.bckg_loc,
'bckg_img_list': self.bckg_img_list,
'bckg_img_format': self.bckg_img_format,
'cal_loc': self.cal_loc,
'cal_name': self.cal_name,
'cal_img_format': self.cal_img_format,
'mov_1_name': self.mov_1_name,
'mov_2_name': self.mov_2_name,
'mov_3_name': self.mov_3_name,
'mov_4_name': self.mov_4_name,
'mov_5_name': self.mov_5_name,
'mov_6_name': self.mov_6_name,
'mov_7_name': self.mov_7_name,
'mov_8_name': self.mov_8_name,
'cam_1_name': self.cam_1_name,
'cam_2_name': self.cam_2_name,
'cam_3_name': self.cam_3_name,
'cam_4_name': self.cam_4_name,
'cam_5_name': self.cam_5_name,
'cam_6_name': self.cam_6_name,
'frame_name': self.frame_name,
'frame_img_format': self.frame_img_format,
'model_loc': self.model_loc,
'model_name': self.model_name,
'trigger_mode': self.trigger_mode,
'start_frame': self.start_frame,
'trig_frame': self.trig_frame,
'end_frame': self.end_frame
}
os.chdir(self.session_loc)
ses_pickle = open('session_parameters.pickle', 'wb')
pickle.dump(ses_dict, ses_pickle)
ses_pickle.close()
print('saved session_parameters.pickle')
except:
print('could not save session parameter file')
def set_nx(self, val):
self.nx = val
def set_ny(self, val):
self.ny = val
def set_nz(self, val):
self.nz = val
def set_ds(self, val):
self.ds = val
def set_x0(self, val):
self.x0 = val
def set_y0(self, val):
self.y0 = val
def set_z0(self, val):
self.z0 = val
def set_pixel_size(self, val):
self.pixel_size = val
def add_focal_grid_gui(self):
self.nx = 320
self.ny = 320
self.nz = 320
self.ds = 0.032
self.x0 = 0.0
self.y0 = 0.0
self.z0 = 0.0
self.pixel_size = 0.040
def connect_focal_grid_gui(self):
self.tabs.setTabEnabled(2, False)
self.nx_spin.setMinimum(1)
self.nx_spin.setMaximum(2048)
self.nx_spin.setValue(self.nx)
self.nx_spin.valueChanged.connect(self.set_nx)
self.ny_spin.setMinimum(1)
self.ny_spin.setMaximum(2048)
self.ny_spin.setValue(self.ny)
self.ny_spin.valueChanged.connect(self.set_ny)
self.nz_spin.setMinimum(1)
self.nz_spin.setMaximum(2048)
self.nz_spin.setValue(self.nz)
self.nz_spin.valueChanged.connect(self.set_nz)
self.ds_spin.setMinimum(0.001)
self.ds_spin.setMaximum(1.000)
self.ds_spin.setSingleStep(0.001)
self.ds_spin.setValue(self.ds)
self.ds_spin.valueChanged.connect(self.set_ds)
self.x0_spin.setRange(-10.0, 10.0)
self.x0_spin.setSingleStep(0.01)
self.x0_spin.setValue(self.x0)
self.x0_spin.valueChanged.connect(self.set_x0)
self.y0_spin.setRange(-10.0, 10.0)
self.y0_spin.setSingleStep(0.01)
self.y0_spin.setValue(self.y0)
self.y0_spin.valueChanged.connect(self.set_y0)
self.z0_spin.setRange(-10.0, 10.0)
self.z0_spin.setSingleStep(0.01)
self.z0_spin.setValue(self.z0)
self.z0_spin.valueChanged.connect(self.set_z0)
self.pixel_size_spin.setRange(0.001, 0.1)
self.pixel_size_spin.setSingleStep(0.001)
self.pixel_size_spin.setValue(self.pixel_size)
self.pixel_size_spin.valueChanged.connect(self.set_pixel_size)
self.calc_vox_btn.clicked.connect(self.calculate_focal_grid)
self.vox_progress_bar.setRange(0, 100)
self.vox_progress_bar.setValue(0)
def update_grid_progress_bar(self, progress):
self.vox_progress_bar.setValue(progress)
def calculate_focal_grid(self):
self.flt.nx = self.nx
self.flt.ny = self.ny
self.flt.nz = self.nz
self.flt.ds = self.ds
self.flt.x0 = self.x0
self.flt.y0 = self.y0
self.flt.z0 = self.z0
self.flt.pixel_size = self.pixel_size
self.flt.set_focal_grid_parameters()
self.flt.set_pixel_size(self.pixel_size)
self.flt.calculate_focal_grid(self.update_grid_progress_bar)
self.tabs.setTabEnabled(2, True)
self.rawFrameView.setFrameParam()
self.set_model_scale_gui()
def add_model_scale_gui(self):
self.tabs.setTabEnabled(2, False)
def connect_model_scale_gui(self):
self.tabs.setTabEnabled(3, False)
self.rawFrameView.loadFLT(self.flt)
def set_model_scale_gui(self):
drag_pnt_data = self.flt.get_drag_point_pars()
symbols = drag_pnt_data[0]
labels = drag_pnt_data[1]
adj = drag_pnt_data[4]
scale_texts = drag_pnt_data[6]
scale_calc = drag_pnt_data[7]
length_calc = drag_pnt_data[8]
origin_ind = drag_pnt_data[9]
contour_calc = drag_pnt_data[10]
scale_data = []
for i in range(len(scale_texts)):
scale_data.append(1.0)
xyz_pos = drag_pnt_data[3]
pos_list = []
for i in range(xyz_pos.shape[0]):
pos_list.append((xyz_pos[i, 0], xyz_pos[i, 1], xyz_pos[i, 2]))
start_pos = np.array(pos_list)
p_clr = drag_pnt_data[2]
p_clr_list = []
for i in range(p_clr.shape[0]):
p_clr_list.append((p_clr[i, 0], p_clr[i, 1], p_clr[i, 2]))
pnt_clr = np.array([p_clr_list],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte)])
l_clr = drag_pnt_data[5]
l_clr_list = []
for i in range(l_clr.shape[0]):
l_clr_list.append(
(l_clr[i, 0], l_clr[i, 1], l_clr[i, 2], l_clr[i, 3], l_clr[i,
4]))
line_clr = np.array([l_clr_list],
dtype=[('red', np.ubyte), ('green', np.ubyte),
('blue', np.ubyte), ('alpha', np.ubyte),
('width', float)])
self.rawFrameView.setSessionLoc(self.session_loc)
self.rawFrameView.setPos(start_pos)
self.rawFrameView.setAdj(adj)
self.rawFrameView.setLines(l_clr)
self.rawFrameView.setSymbols(symbols)
self.rawFrameView.setTexts(labels)
self.rawFrameView.setTextColor(p_clr)
self.rawFrameView.setScaleCalc(scale_calc)
self.rawFrameView.setLengthCalc(length_calc)
self.rawFrameView.setOriginInd(origin_ind)
self.rawFrameView.add_frame(self.start_frame)
self.rawFrameView.add_graph()
self.rawFrameView.setMouseCallbacks()
self.raw_mov_spin.setMinimum(1)
self.raw_mov_spin.setMaximum(self.N_mov)
self.raw_mov_spin.setValue(1)
self.raw_mov_spin.valueChanged.connect(self.rawFrameView.setMovNR)
self.raw_frame_spin.setMinimum(self.start_frame)
self.raw_frame_spin.setMaximum(self.end_frame)
self.raw_frame_spin.setValue(self.start_frame)
self.raw_frame_spin.valueChanged.connect(
self.rawFrameView.update_frame)
self.scaleTable.setRowCount(2)
self.scaleTable.setColumnCount(len(scale_texts))
for i in range(len(scale_texts)):
self.scaleTable.setItem(0, i, QTableWidgetItem(scale_texts[i]))
self.scaleTable.setItem(1, i, QTableWidgetItem(str(scale_data[i])))
self.rawFrameView.connect_table(self.scaleTable)
self.load_scale_btn.clicked.connect(self.rawFrameView.load_model_scale)
self.save_scale_btn.clicked.connect(self.rawFrameView.save_model_scale)
self.set_model_btn.clicked.connect(self.update_model_scale)
def update_model_scale(self):
self.tabs.setTabEnabled(3, True)
self.model_view_window.set_file_loc(self.model_loc)
self.rawFrameView.update_model_scale()
self.model_view_window.load_model()
self.tabs.setTabEnabled(4, True)
self.set_image_segment_gui()
def add_model_view_gui(self):
self.tabs.setTabEnabled(3, False)
def connect_model_view_gui(self):
self.tabs.setTabEnabled(4, False)
self.model_view_window.loadFLT(self.flt)
def add_image_segment_gui(self):
self.tabs.setTabEnabled(4, False)
def connect_image_segment_gui(self):
self.tabs.setTabEnabled(5, False)
self.body_thresh = 40
self.wing_thresh = 20
self.sigma = 0.05
self.K = 3000
self.min_body_size = 50
self.min_wing_size = 3
self.seg_view.loadFLT(self.flt)
self.seg_view.setBodyThresh(self.body_thresh)
self.seg_view.setWingThresh(self.wing_thresh)
self.seg_view.setSigma(self.sigma)
self.seg_view.setK(self.K)
self.seg_view.setMinBodySize(self.min_body_size)
self.seg_view.setMinWingSize(self.min_wing_size)
#self.seg_view.setTethered(self.tethered)
def set_image_segment_gui(self):
print("resetting mask")
self.seg_view.reset_mask()
self.seg_view.add_frame(self.flt.start_point)
self.seg_mov_spin.setMinimum(1)
self.seg_mov_spin.setMaximum(self.N_mov)
self.seg_mov_spin.setValue(1)
self.seg_mov_spin.valueChanged.connect(self.seg_view.update_mov)
self.seg_frame_spin.setMinimum(self.flt.start_point)
self.seg_frame_spin.setMaximum(self.flt.end_point)
self.seg_mov_spin.setValue(self.flt.start_point)
self.seg_frame_spin.valueChanged.connect(self.seg_view.update_frame)
self.body_thresh_spin.setMinimum(0)
self.body_thresh_spin.setMaximum(255)
self.body_thresh_spin.setValue(self.body_thresh)
self.body_thresh_spin.valueChanged.connect(self.seg_view.setBodyThresh)
self.wing_thresh_spin.setMinimum(0)
self.wing_thresh_spin.setMaximum(255)
self.wing_thresh_spin.setValue(self.wing_thresh)
self.wing_thresh_spin.valueChanged.connect(self.seg_view.setWingThresh)
self.sigma_spin.setMinimum(0.0)
self.sigma_spin.setMaximum(2.0)
self.sigma_spin.setSingleStep(0.01)
self.sigma_spin.setValue(self.sigma)
self.sigma_spin.valueChanged.connect(self.seg_view.setSigma)
self.K_spin.setMinimum(0)
self.K_spin.setMaximum(10000)
self.K_spin.setSingleStep(100)
self.K_spin.setValue(self.K)
self.K_spin.valueChanged.connect(self.seg_view.setK)
self.min_body_spin.setMinimum(0)
self.min_body_spin.setMaximum(10000)
self.min_body_spin.setValue(self.min_body_size)
self.min_body_spin.valueChanged.connect(self.seg_view.setMinBodySize)
self.min_wing_spin.setMinimum(0)
self.min_wing_spin.setMaximum(10000)
self.min_wing_spin.setValue(self.min_wing_size)
self.min_wing_spin.valueChanged.connect(self.seg_view.setMinWingSize)
#self.tethered_check.setChecked(self.tethered)
#self.tethered_check.stateChanged.connect(self.seg_view.setTethered)
self.seg_update_btn.clicked.connect(self.seg_view.update_parameters)
self.mask_cam_nr_spin.setMinimum(1)
self.mask_cam_nr_spin.setMaximum(self.flt.N_cam)
self.mask_cam_nr_spin.setValue(1)
self.mask_cam_nr_spin.valueChanged.connect(self.seg_view.set_mask_view)
self.mask_seg_nr_spin.setMinimum(1)
self.mask_seg_nr_spin.setMaximum(1)
self.mask_seg_nr_spin.setValue(1)
self.mask_seg_nr_spin.valueChanged.connect(
self.seg_view.set_mask_segment)
self.seg_view.add_mask_spin(self.mask_seg_nr_spin, self.flt.N_cam)
self.add_mask_btn.clicked.connect(self.seg_view.add_mask)
self.reset_mask_btn.clicked.connect(self.seg_view.reset_mask)
self.continue_btn.clicked.connect(self.set_pcl_view_gui)
def add_pcl_view_gui(self):
self.tabs.setTabEnabled(5, False)
def connect_pcl_view_gui(self):
self.min_nr_points = 50
self.min_conn_points = 50
self.sphere_radius = 0.25
self.phi_bound = 120
self.theta_bound = 50
self.eta_bound = 180
self.tethered = True
self.pcl_view.loadFLT(self.flt)
self.flt.set_tethered_flight(self.tethered)
self.flt.set_min_conn_points(self.min_nr_points)
self.flt.set_min_nr_points(self.min_conn_points)
self.flt.set_stroke_bound(self.phi_bound)
self.flt.set_deviation_bound(self.theta_bound)
self.flt.set_wing_pitch_bound(self.eta_bound)
def set_pcl_view_gui(self):
self.tabs.setTabEnabled(5, True)
self.pcl_view.setMov(1)
self.pcl_view.loadFrame(self.flt.start_point)
self.pcl_mov_spin.setMinimum(1)
self.pcl_mov_spin.setMaximum(self.N_mov)
self.pcl_mov_spin.setValue(1)
self.pcl_mov_spin.valueChanged.connect(self.pcl_view.setMov)
self.pcl_frame_spin.setMinimum(self.flt.start_point)
self.pcl_frame_spin.setMaximum(self.flt.end_point)
self.pcl_frame_spin.setValue(self.flt.start_point)
self.pcl_frame_spin.valueChanged.connect(self.load_pcl_view_frame)
self.sphere_radius_spin.setMinimum(0.0)
self.sphere_radius_spin.setMaximum(2.0)
self.sphere_radius_spin.setSingleStep(0.01)
self.sphere_radius_spin.setValue(self.sphere_radius)
self.pcl_view.setSphereRadius(self.sphere_radius)
self.sphere_radius_spin.valueChanged.connect(
self.pcl_view.setSphereRadius)
self.tethered_radio_btn.toggled.connect(self.set_tethered_flight)
self.free_radio_btn.toggled.connect(self.set_free_flight)
self.stroke_bound_spin.setMinimum(0)
self.stroke_bound_spin.setMaximum(120)
self.stroke_bound_spin.setValue(self.phi_bound)
self.stroke_bound_spin.valueChanged.connect(
self.pcl_view.setStrokeBound)
self.dev_bound_spin.setMinimum(0)
self.dev_bound_spin.setMaximum(90)
self.dev_bound_spin.setValue(self.theta_bound)
self.dev_bound_spin.valueChanged.connect(self.pcl_view.setDevBound)
self.wing_pitch_bound_spin.setMinimum(0)
self.wing_pitch_bound_spin.setMaximum(180)
self.wing_pitch_bound_spin.setValue(self.eta_bound)
self.wing_pitch_bound_spin.valueChanged.connect(
self.pcl_view.setWingPitchBound)
self.pcl_view_btn.toggled.connect(lambda: self.pcl_view_btn)
self.bbox_view_btn.toggled.connect(lambda: self.bbox_view_btn)
self.model_view_btn.toggled.connect(lambda: self.model_view_btn)
stl_list = self.flt.get_stl_list()
self.pcl_view.load_stl_files(stl_list, self.model_loc)
self.set_contour_view_gui()
def set_free_flight(self):
self.tethered = False
self.flt.set_tethered_flight(self.tethered)
def set_tethered_flight(self):
self.tethered = True
self.flt.set_tethered_flight(self.tethered)
def load_pcl_view_frame(self, frame_nr):
if self.pcl_view_btn.isChecked():
self.pcl_view.setPCLView(True)
elif self.bbox_view_btn.isChecked():
self.pcl_view.setBBoxView(True)
elif self.model_view_btn.isChecked():
self.pcl_view.setModelView(True)
self.pcl_view.loadFrame(frame_nr)
def add_contour_view_gui(self):
self.tabs.setTabEnabled(6, False)
def connect_contour_view_gui(self):
self.contour_view.loadFLT(self.flt)
def set_contour_view_gui(self):
self.tabs.setTabEnabled(6, True)
self.opt_mov_spin.setMinimum(1)
self.opt_mov_spin.setMaximum(self.N_mov)
self.opt_mov_spin.setValue(1)
self.opt_mov_spin.valueChanged.connect(self.contour_view.setMovNR)
self.contour_view.add_frame(self.start_frame)
self.contour_view.add_contour(self.start_frame)
self.opt_frame_spin.setMinimum(self.start_frame)
self.opt_frame_spin.setMaximum(self.end_frame)
self.opt_frame_spin.setValue(self.start_frame)
self.opt_frame_spin.valueChanged.connect(
self.contour_view.update_frame)
self.init_view_check.toggled.connect(self.contour_view.set_init_view)
self.dest_view_check.toggled.connect(self.contour_view.set_dest_view)
self.src_view_check.toggled.connect(self.contour_view.set_src_view)
class FilenamePrompt(_BasePrompt):
"""A prompt for a filename."""
def __init__(self, question, parent=None):
super().__init__(question, parent)
self._init_texts(question)
self._init_key_label()
self._lineedit = LineEdit(self)
if question.default:
self._lineedit.setText(question.default)
self._lineedit.textEdited.connect(self._set_fileview_root)
self._vbox.addWidget(self._lineedit)
self.setFocusProxy(self._lineedit)
self._init_fileview()
self._set_fileview_root(question.default)
if config.val.prompt.filebrowser:
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self._to_complete = ''
@pyqtSlot(str)
def _set_fileview_root(self, path, *, tabbed=False):
"""Set the root path for the file display."""
separators = os.sep
if os.altsep is not None:
separators += os.altsep
dirname = os.path.dirname(path)
basename = os.path.basename(path)
if not tabbed:
self._to_complete = ''
try:
if not path:
pass
elif path in separators and os.path.isdir(path):
# Input "/" -> don't strip anything
pass
elif path[-1] in separators and os.path.isdir(path):
# Input like /foo/bar/ -> show /foo/bar/ contents
path = path.rstrip(separators)
elif os.path.isdir(dirname) and not tabbed:
# Input like /foo/ba -> show /foo contents
path = dirname
self._to_complete = basename
else:
return
except OSError:
log.prompt.exception("Failed to get directory information")
return
root = self._file_model.setRootPath(path)
self._file_view.setRootIndex(root)
@pyqtSlot(QModelIndex)
def _insert_path(self, index, *, clicked=True):
"""Handle an element selection.
Args:
index: The QModelIndex of the selected element.
clicked: Whether the element was clicked.
"""
if index == QModelIndex():
path = os.path.join(self._file_model.rootPath(), self._to_complete)
else:
path = os.path.normpath(self._file_model.filePath(index))
if clicked:
path += os.sep
else:
# On Windows, when we have C:\foo and tab over .., we get C:\
path = path.rstrip(os.sep)
log.prompt.debug('Inserting path {}'.format(path))
self._lineedit.setText(path)
self._lineedit.setFocus()
self._set_fileview_root(path, tabbed=True)
if clicked:
# Avoid having a ..-subtree highlighted
self._file_view.setCurrentIndex(QModelIndex())
def _init_fileview(self):
self._file_view = QTreeView(self)
self._file_model = QFileSystemModel(self)
self._file_view.setModel(self._file_model)
self._file_view.clicked.connect(self._insert_path)
if config.val.prompt.filebrowser:
self._vbox.addWidget(self._file_view)
else:
self._file_view.hide()
# Only show name
self._file_view.setHeaderHidden(True)
for col in range(1, 4):
self._file_view.setColumnHidden(col, True)
# Nothing selected initially
self._file_view.setCurrentIndex(QModelIndex())
# The model needs to be sorted so we get the correct first/last index
self._file_model.directoryLoaded.connect(
lambda: self._file_model.sort(0))
def accept(self, value=None, save=False):
self._check_save_support(save)
text = value if value is not None else self._lineedit.text()
text = downloads.transform_path(text)
if text is None:
message.error("Invalid filename")
return False
self.question.answer = text
return True
def item_focus(self, which):
# This duplicates some completion code, but I don't see a nicer way...
assert which in ['prev', 'next'], which
selmodel = self._file_view.selectionModel()
parent = self._file_view.rootIndex()
first_index = self._file_model.index(0, 0, parent)
row = self._file_model.rowCount(parent) - 1
last_index = self._file_model.index(row, 0, parent)
if not first_index.isValid():
# No entries
return
assert last_index.isValid()
idx = selmodel.currentIndex()
if not idx.isValid():
# No item selected yet
idx = last_index if which == 'prev' else first_index
elif which == 'prev':
idx = self._file_view.indexAbove(idx)
else:
assert which == 'next', which
idx = self._file_view.indexBelow(idx)
# wrap around if we arrived at beginning/end
if not idx.isValid():
idx = last_index if which == 'prev' else first_index
idx = self._do_completion(idx, which)
selmodel.setCurrentIndex(
idx,
QItemSelectionModel.ClearAndSelect | # type: ignore[arg-type]
QItemSelectionModel.Rows)
self._insert_path(idx, clicked=False)
def _do_completion(self, idx, which):
filename = self._file_model.fileName(idx)
while not filename.startswith(self._to_complete) and idx.isValid():
if which == 'prev':
idx = self._file_view.indexAbove(idx)
else:
assert which == 'next', which
idx = self._file_view.indexBelow(idx)
filename = self._file_model.fileName(idx)
return idx
def _allowed_commands(self):
return [('prompt-accept', 'Accept'), ('leave-mode', 'Abort')]
class FileBrowser(QTreeView):
def __init__(self,
parent=None,
textPad=None,
notebook=None,
codeView=None):
super().__init__()
self.path = self.checkPath(os.getcwd())
self.filename = None
self.text = None
self.initItems()
self.textPad = textPad
self.notebook = notebook
self.codeView = codeView
self.mainWindow = parent
self.index = None
self.copySourceFilePath = None # copy / paste items
self.copySourceFileName = None
self.isCopyFileFolder = None
self.setStyleSheet("""
border: 5 px;
background-color: black;
color: white;
alternate-background-color: #FFFFFF;
selection-background-color: #3b5784;
""")
# Contextmenu
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.openMenu)
self.popMenu = QMenu()
self.popMenu.setStyleSheet("""
color: #FFFFFF;
background-color: #2c2c2c;
selection-background-color: #3b5784;
alternate-background-color: #FFFFFF;
""")
infoAction = QAction('Info', self)
infoAction.triggered.connect(self.onInfo)
createFolderAction = QAction('Create New Folder', self)
createFolderAction.triggered.connect(self.onCreateNewFolder)
copyAction = QAction('Copy Item', self)
copyAction.triggered.connect(self.onCopy)
pasteAction = QAction('Paste Item', self)
pasteAction.triggered.connect(self.onPaste)
renameAction = QAction('Rename Item', self)
renameAction.triggered.connect(self.onRename)
deleteAction = QAction('Delete Item', self)
deleteAction.triggered.connect(self.onDelete)
terminalAction = QAction('Open Terminal', self)
terminalAction.triggered.connect(self.onTerminal)
self.popMenu.addAction(infoAction)
self.popMenu.addSeparator()
self.popMenu.addAction(createFolderAction)
self.popMenu.addSeparator()
self.popMenu.addAction(copyAction)
self.popMenu.addAction(pasteAction)
self.popMenu.addAction(renameAction)
self.popMenu.addSeparator()
self.popMenu.addAction(deleteAction)
self.popMenu.addSeparator()
self.popMenu.addAction(terminalAction)
def openMenu(self, position):
# -> open ContextMenu
self.popMenu.exec_(self.mapToGlobal(position))
def onInfo(self):
if not self.index:
return
index = self.index
indexItem = self.model.index(index.row(), 0, index.parent())
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
bundle = fileInfo.isBundle() # bool
dir = fileInfo.isDir() # bool
file = fileInfo.isFile() # bool
executable = fileInfo.isExecutable() # bool
readable = fileInfo.isReadable() # bool
writable = fileInfo.isWritable() # bool
created = fileInfo.created() # QDateTime
#modified = fileInfo.lastModified() # QDateTime
owner = fileInfo.owner() # QString
size = fileInfo.size() # QInt
s = format(size, ',d')
text = ''
text += 'Type:\t'
if bundle:
text += 'Bundle\n\n'
if dir:
text += 'Path\n\n'
if file:
text += 'File\n\n'
if readable:
text += 'read:\tyes\n'
else:
text += 'read:\tno\n'
if writable:
text += 'write:\tyes\n'
else:
text += 'write:\tno\n'
if executable:
text += 'exec:\tyes\n\n'
else:
text += 'exec:\tno\n\n'
text += 'size:\t' + str(s) + ' bytes' + '\n'
text += 'owner:\t' + owner + '\n'
text += 'created:\t' + str(created.date().day()) + '.' + \
str(created.date().month()) + '.' + \
str(created.date().year()) + ' ' + \
created.time().toString() + '\n'
q = MessageBox(QMessageBox.Information, fileName, text,
QMessageBox.NoButton)
q.exec_()
def onCreateNewFolder(self):
if not self.index:
return
else:
index = self.index
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
path = os.getcwd() + '/'
path = self.checkPath(path)
index = self.index
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
dialog = EnterDialog(self.mainWindow, fileName, \
filePath, fileDir, fileInfo, False, path)
dialog.exec_()
# return
def onCopy(self):
if not self.index:
return
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
if fileName == '..':
self.clearSelection()
self.mainWindow.statusBar.showMessage("can't copy this item !",
3000)
self.copySourceFilePath = None
self.copySourceFileName = None
self.isCopyFileFolder = None
return
if fileDir:
self.copySourceFilePath = filePath
self.copySourceFileName = fileName
self.isCopyFileFolder = True
self.mainWindow.statusBar.showMessage('Path: <' + \
self.copySourceFileName + \
'> marked', 3000)
else:
self.copySourceFilePath = filePath
self.copySourceFileName = fileName
self.mainWindow.statusBar.showMessage('File: <' + \
self.copySourceFileName + \
'> marked', 3000)
def onPaste(self):
if not self.index:
return
if not self.copySourceFilePath:
self.mainWindow.statusBar.showMessage('nothing marked !', 3000)
return
if not self.copySourceFileName:
self.mainWindow.statusBar.showMessage('nothing marked !', 3000)
return
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
rootPath = os.getcwd()
rootPath = self.checkPath(rootPath)
fileList = os.listdir(self.path) # File list at current path
if fileName == '..':
# clicked on '..'
rootPath = os.getcwd()
rootPath = self.checkPath(rootPath)
if fileDir and self.isCopyFileFolder:
# copy path to another path
if fileName == '..':
path = os.getcwd()
path = self.checkPath(path)
else:
path = filePath
newPath = path + '/' + self.copySourceFileName
fileList = os.listdir(path)
if self.copySourceFileName in fileList:
q = MessageBox(
QMessageBox.Warning, "Error",
"Another path with the same name already exists.",
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
if self.copySourceFilePath in newPath:
q = MessageBox(QMessageBox.Critical, 'Error',
'Name of path already exists in new path',
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
try:
os.mkdir(newPath)
self.copytree(self.copySourceFilePath, newPath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
elif fileDir and not self.isCopyFileFolder:
# copy file to path
if fileName == '..':
path = os.getcwd()
path = self.checkPath(path)
else:
path = filePath
fileList = os.listdir(path) # File list at current path
if self.copySourceFileName in fileList:
result = MessageBox(QMessageBox.Warning, "Warning",
"File already exists.\n" + "Continue ?",
QMessageBox.Yes | QMessageBox.No)
if (result.exec_() == QMessageBox.Yes):
try:
shutil.copy(self.copySourceFilePath, path)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
else:
self.resetMarkedItems()
return
else:
try:
shutil.copy(self.copySourceFilePath, path)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
elif not fileDir and self.isCopyFileFolder:
# copy path to selected file -> correct this user input ...
newPath = rootPath + '/' + self.copySourceFileName
if self.copySourceFileName in fileList:
q = MessageBox(
QMessageBox.Information, "Error",
"Another path with the same name already exists.",
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
try:
os.mkdir(newPath)
self.copytree(self.copySourceFilePath, newPath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
elif not fileDir and not self.isCopyFileFolder:
# user copy file to another file -> correct this input
fileList = os.listdir(rootPath) # File list in current path
if self.copySourceFileName in fileList:
result = MessageBox(
QMessageBox.Warning, "Warning",
"File with this name already exists !" + "Continue ?",
QMessageBox.Yes | QMessageBox.No)
if (result.exec_() == QMessageBox.Yes):
try:
shutil.copy(self.copySourceFilePath, rootPath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
return
else:
self.resetMarkedItems(True)
return
else:
try:
shutil.copy(self.copySourceFilePath, rootPath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.Ok)
q.exec_()
self.resetMarkedItems(True)
return
self.resetMarkedItems()
def resetMarkedItems(self, showMessage=False):
# reset marked items
self.copySourceFilePath = None
self.copySourceFileName = None
self.isCopyFileFolder = None
if showMessage:
self.mainWindow.statusBar.showMessage('Mark removed !', 3000)
# copy path with subfolder
# thanks to stackoverflow.com ..... !
def copytree(self, src, dst, symlinks=False, ignore=None):
if not os.path.exists(dst):
os.makedirs(dst)
if not os.path.exists(src):
os.makedirs(src)
for item in os.listdir(src):
s = os.path.join(src, item)
d = os.path.join(dst, item)
if os.path.isdir(s):
self.copytree(s, d, symlinks, ignore)
else:
if not os.path.exists(
d) or os.stat(s).st_mtime - os.stat(d).st_mtime > 1:
shutil.copy2(s, d)
def onRename(self):
if not self.index:
return
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
dialog = EnterDialog(self.mainWindow, fileName, filePath, fileDir,
fileInfo, True)
dialog.exec_()
def onDelete(self):
if not self.index:
return
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
if fileDir:
if fileName == '..':
self.mainWindow.statusBar.showMessage(
'can not delete this item !', 3000)
return
else:
result = MessageBox(QMessageBox.Warning, 'Delete directory',
'<b>' + filePath + '</b>' + " ?",
QMessageBox.Yes | QMessageBox.No)
if (result.exec_() == QMessageBox.Yes):
try:
shutil.rmtree(filePath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
self.resetMarkedItems()
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
else:
return
else:
pathList = filePath.split('/')[:-1]
path = ''
for elem in pathList:
path += elem + '/'
file = filePath.split('/')[-1]
result = MessageBox(QMessageBox.Warning, 'Delete file',
path + "<b>" + file + "</b>" + " ?",
QMessageBox.Yes | QMessageBox.No)
if (result.exec_() == QMessageBox.Yes):
try:
os.remove(filePath)
self.mainWindow.statusBar.showMessage('Done !', 3000)
except Exception as e:
q = MessageBox(QMessageBox.Critical, "Error", str(e),
QMessageBox.NoButton)
q.exec_()
self.resetMarkedItems(True)
def onTerminal(self):
c = Configuration()
system = c.getSystem()
command = c.getTerminal(system)
thread = RunThread(command)
thread.start()
def initItems(self):
font = QFont()
font.setPixelSize(16)
self.prepareModel(os.getcwd())
self.setToolTip(os.getcwd())
# prepare drag and drop
self.setDragEnabled(False)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setSizePolicy(sizePolicy)
self.setAutoExpandDelay(2)
self.setAlternatingRowColors(False)
self.setAnimated(False)
self.setIndentation(20)
self.setSortingEnabled(False)
self.setRootIsDecorated(False)
self.setPalette(QPalette(Qt.black))
self.verticalScrollBar().setStyleSheet("""border: 20px solid black;
background-color: darkgreen;
alternate-background-color: #FFFFFF;""")
self.horizontalScrollBar().setStyleSheet("""border: 20px solid black;
background-color: darkgreen;
alternate-background-color: #FFFFFF;""")
self.setFont(font)
# signals
self.doubleClicked.connect(self.onDoubleClicked)
self.clicked.connect(self.onClicked)
self.pressed.connect(self.onClicked)
#self.entered.connect(self.onEntered)
self.columnMoved()
# that hides the size, file type and last modified colomns
self.setHeaderHidden(True)
self.hideColumn(1)
self.hideColumn(2)
self.hideColumn(3)
self.resize(400, 400)
def prepareModel(self, path):
self.model = QFileSystemModel()
self.model.setRootPath(path)
#model.setFilter(QDir.AllDirs |QDir.NoDotAndDotDot | QDir.AllEntries)
self.model.setFilter(QDir.Files | QDir.AllDirs | QDir.NoDot
| QDir.Hidden)
#self.model.setNameFilters(self.filter)
self.model.rootPathChanged.connect(self.onRootPathChanged)
self.fsindex = self.model.setRootPath(path)
self.setModel(self.model)
self.setRootIndex(self.fsindex)
def checkPath(self, path):
if '\\' in path:
path = path.replace('\\', '/')
return path
def getFileInformation(self):
index = self.index
indexItem = self.model.index(index.row(), 0, index.parent())
fileName = self.model.fileName(indexItem)
filePath = self.model.filePath(indexItem)
fileDir = self.model.isDir(indexItem)
fileInfo = self.model.fileInfo(indexItem)
fileName = self.checkPath(fileName)
filePath = self.checkPath(filePath)
return (fileName, filePath, fileDir, fileInfo)
def onClicked(self, index):
self.index = index #.... index des FileSystemModels
indexItem = self.model.index(index.row(), 0, index.parent())
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
self.setToolTip(filePath)
if fileDir:
self.path = self.checkPath(os.getcwd())
self.filename = None
else:
self.filename = filePath
self.path = self.checkPath(os.getcwd())
#print('self.filename: ', self.filename)
#print('self.path: ', self.path)
def refresh(self, dir=None):
if not dir:
dir = self.checkPath(os.getcwd())
else:
dir = dir
self.model.setRootPath(dir)
if self.rootIsDecorated:
self.setRootIsDecorated(False)
self.clearSelection()
def onDoubleClicked(self, index):
self.index = index #.... wie oben ... def onClicked(...):
indexItem = self.model.index(index.row(), 0, index.parent())
fileName, filePath, fileDir, fileInfo = self.getFileInformation()
if fileDir:
filePath = self.checkPath(filePath)
try:
os.chdir(filePath)
except Exception as e:
self.mainWindow.statusBar.showMessage(str(e), 3000)
self.path = self.checkPath(os.getcwd())
self.model.setRootPath(filePath)
if self.rootIsDecorated:
self.setRootIsDecorated(False)
else:
self.filename = filePath
try:
with open(self.filename, 'r') as f:
self.text = f.read()
except Exception as e:
self.mainWindow.statusBar.showMessage(str(e), 3000)
self.filename = None
return
# debug
if self.textPad:
if not self.textPad.filename:
editor = CodeEditor(self.mainWindow)
editor.setText(self.text)
editor.filename = filePath
self.notebook.newTab(editor)
self.textPad = editor
x = self.notebook.count() # number of tabs
index = x - 1
self.notebook.setCurrentIndex(index)
tabName = os.path.basename(editor.filename)
self.notebook.setTabText(x, tabName)
self.textPad = editor
#self.textPad.filename = filePath
else:
editor = CodeEditor(self.mainWindow)
editor.setText(self.text)
editor.filename = filePath
tabName = os.path.basename(editor.filename)
self.notebook.newTab(editor)
x = self.notebook.count() # number of tabs
index = x - 1
self.notebook.setCurrentIndex(index)
self.textPad = editor
#self.textPad.filename = filePath
if not self.textPad:
editor = CodeEditor(self.mainWindow)
editor.filename = None
self.notebook.newTab(editor)
x = self.notebook.count()
index = x - 1
self.notebook.setCurrentIndex(index)
self.textPad = editor
#self.textPad.filename = filePath
# make codeView
codeViewList = self.codeView.makeDictForCodeView(self.text)
self.codeView.updateCodeView(codeViewList)
# update textPad Autocomplete
autocomplete = Qsci.QsciAPIs(self.textPad.lexer)
self.textPad.autocomplete = autocomplete
self.textPad.setPythonAutocomplete()
self.clearSelection()
def onRootPathChanged(self):
self.setModel(None)
self.setModel(self.model)
self.fsindex = self.model.setRootPath(QDir.currentPath())
self.setRootIndex(self.fsindex)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setSizePolicy(sizePolicy)
self.setAutoExpandDelay(2)
self.setAlternatingRowColors(False)
self.setAnimated(True)
self.setIndentation(20)
self.setSortingEnabled(False)
self.setRootIsDecorated(False)
self.setHeaderHidden(True)
self.hideColumn(1)
self.hideColumn(2)
self.hideColumn(3)
self.setToolTip(QDir.currentPath())
self.path = os.getcwd()
self.path = self.checkPath(self.path)
