class MyWindow(QMainWindow):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setInputStrings()
self.ui.buttonCheck.clicked.connect(self.clickMethod)
def setInputStrings(self):
if self.ui.boxCaseSensitivity.isChecked():
self.inputMatrix = self.ui.inputFieldMatrix.toPlainText()
self.inputWord = self.ui.inputFieldKeyword.text()
else:
self.inputMatrix = self.ui.inputFieldMatrix.toPlainText().upper()
self.inputWord = self.ui.inputFieldKeyword.text().upper()
def clickMethod(self):
self.setInputStrings()
myMatrix = LetterMatrix(self.inputMatrix)
if myMatrix.correctInput():
wordAppearances = str(myMatrix.totalWordAppearances(self.inputWord))
self.ui.labelOutput.setText("Das Wort wurde " + wordAppearances + " mal gefunden")
else:
self.ui.labelOutput.setText("Ungültige Eingabe")
def main():
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
windowStyle.styles.dark(app)
mw = windowStyle.window.ModernWindow(MainWindow)
mw.setWindowTitle("Volume Buddy")
mw.show()
app.exec_()
class mywindow(QtWidgets.QMainWindow):
source = ""
target = ""
CURENT = 0
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#self.setAcceptDrops(True)
#print(app.arguments())
mywindow.source = app.arguments()[1]
#self.ui.comboBox.addItem(app.arguments()[1])
mywindow.target = r"\\192.168.1.170\мах"
self.statusBar().showMessage(mywindow.target + " to " +
mywindow.source)
self.ui.Send.clicked.connect(self.SendF)
self.ui.Cancel.clicked.connect(self.CancelF)
def SendF(self):
#proc = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#proc.wait()
#res = proc.communicate()
#shutil.copy(mywindow.source.replace('\\','\\'), mywindow.target.replace('\\','\\'))
#self.statusBar().showMessage(mywindow.source + " to " + mywindow.target )
try:
os.system(
'C:\\Windows\\robocopy.exe /y "{source}" "{target}" > nul'.
format(source=mywindow.source, target=mywindow.target))
#proc = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except IOError as e:
print("Unable to copy file. %s" % e)
exit(1)
except:
print("Unexpected error:", sys.exc_info())
exit(1)
#
self.statusBar().showMessage("oooo")
def CancelF(self):
print("Exit")
sys.exit()
class Pencere(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ip = ""
self.port = ""
self.link = "http://aargin.com/"
def siteyeGit_A(self):
# Proxyyi siteden çektik, ip ve portu aldık
# 1 https://gimmeproxy.com/api/getProxy
# 2 https://api.getproxylist.com/proxy
proxyCek = requests.get("https://api.getproxylist.com/proxy")
self.ip,self.port = proxyCek.json()['ip'], str(proxyCek.json()['port'])
self.ui.lblIp.setText("IP : "+self.ip)
self.ui.lblPort.setText("PORT : "+self.port)
self.ui.lblApiSite.setText("API : https://api.getproxylist.com/proxy")
proxyAyarla(self.ip,self.port,self.link)
def siteyeGit_M(self):
proxyAyarla(self.ip,self.port,self.link)
def getIp(self, ip):
self.ip = ip
def getPort(self, port):
self.port = port
def getLink1(self, link):
self.link = link
def getLink2(self, link):
self.link = link
class MyWork(QtWidgets.QMainWindow):
def __init__(self):
super(MyWork, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self) #Calls GUI.py, loads the GUI
self.show()
class ApplicationWindow(QtWidgets.QMainWindow):
flag = 0
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.actionOpen_Image.triggered.connect(self.OpenImage)
self.ui.Combo1.currentTextChanged.connect(self.ChooseOperation)
self.ui.comboBox_2.currentTextChanged.connect(self.KSpace)
self.ui.comboBox.currentTextChanged.connect(self.Gradients)
self.ui.Combo1.setCurrentIndex(0)
self.widgets = [
self.ui.InputImage1, self.ui.FourierInput1, self.ui.KSpace
]
for i in range(len(self.widgets)):
self.widgets[i].ui.histogram.hide()
self.widgets[i].ui.roiBtn.hide()
self.widgets[i].ui.menuBtn.hide()
self.widgets[i].ui.roiPlot.hide()
self.pen1 = pg.mkPen(color=(255, 0, 0))
self.pen2 = pg.mkPen(color=(0, 0, 255))
self.ui.pushButton.clicked.connect(self.ShowGraph)
def ShowGraph(self):
rand_Bz = np.random.randint(-3, 4, 20)
const_Bx = [0] * 20
const_By = [0] * 20
const_Bz = [2] * 20
nonUn_Bz = rand_Bz + const_Bz
self.ui.withx.clear()
self.ui.withy.clear()
self.ui.withz.clear()
self.ui.withz.plotItem.plot(nonUn_Bz, pen=self.pen1)
self.ui.withz.setLabel('left', 'B', units='Tesla')
self.ui.withz.setLabel('bottom', 'Z-axis')
self.ui.withx.plotItem.plot(const_Bx, pen=self.pen2)
self.ui.withx.setLabel('left', 'B', units='Tesla')
self.ui.withx.setLabel('bottom', 'X-axis')
self.ui.withy.plotItem.plot(const_By, pen=self.pen2)
self.ui.withy.setLabel('left', 'B', units='Tesla')
self.ui.withy.setLabel('bottom', 'Y-axis')
def Gradients(self):
var = np.arange(-1, 1, 0.1)
if (str(self.ui.comboBox.currentText())) == 'Gradient Effect':
print('Choose prope Gradient Coil')
elif (str(self.ui.comboBox.currentText())) == 'Slice Selection':
const_Bx = [0] * 20
const_BxG = const_Bx + var
self.ui.withx.clear()
self.ui.withx.plotItem.plot(const_BxG, pen=self.pen2)
elif (str(self.ui.comboBox.currentText())) == 'Phase Encoding':
const_By = [0] * 20
const_ByG = const_By + var
self.ui.withy.clear()
self.ui.withy.plotItem.plot(const_ByG, pen=self.pen2)
elif (str(self.ui.comboBox.currentText())) == 'Frequency Encoding':
const_Bz = [2] * 20
rand_Bz = np.random.randint(-3, 4, 20)
nonUn_Bz = rand_Bz + const_Bz
const_BzG = nonUn_Bz + var
self.ui.withz.clear()
self.ui.withz.plotItem.plot(const_BzG, pen=self.pen1)
def OpenImage(self):
self.filePath = QtWidgets.QFileDialog.getOpenFileName(
None, 'Open file',
'F:\25-9\Downloads\talta tebya\Second Semester\DSP\Task2 Equalizer\TASK 2'
)
self.image = cv.cvtColor(cv.imread(self.filePath[0]),
cv.COLOR_BGR2GRAY)
self.ui.InputImage1.show()
self.ui.InputImage1.setImage(self.image.T)
self.flag = 1
self.dft = np.fft.fft2(self.image)
self.real = np.real(self.dft)
self.imaginary = np.imag(self.dft)
self.magnitude = np.abs(self.dft)
self.phase = np.angle(self.dft)
#K-Space Image
self.fourier = np.fft.fft2(self.image)
self.fourier_shift = np.fft.fftshift(self.fourier)
self.k = np.abs(20 * np.log10(self.fourier_shift))
#Gibb's ringing
self.err1 = self.fourier_shift[:, 112:112 + 32]
self.img_back1 = np.abs(np.fft.ifft2(self.err1, s=[256, 256]))
#Ghosting
self.err2 = self.fourier_shift.copy()
self.err2[:, ::2] = 0.8 * self.err2[:, ::2]
self.img_back2 = np.abs(np.fft.ifft2(self.err2))
#T2* blurring
self.T2star = 20 # milliseconds
self.Ttotal = 100 # time it takes to "read" k-space
self.N = self.fourier_shift.shape[0] # number of pixels
self.err3 = self.fourier_shift.copy()
for i in range(self.err3.shape[1]):
self.err3[:, i] = self.err3[:, i] * np.exp(
-np.linspace(0, self.Ttotal, self.N) / self.T2star)
self.img_back3 = np.abs(np.fft.ifft2(self.err3))
plt.imshow(self.img_back3, cmap='gray')
def ChooseOperation(self):
if (str(self.ui.Combo1.currentText())) == 'FT Magnitude':
if (self.flag == 0):
msg = QMessageBox()
msg.setWindowTitle("Warning")
msg.setText("Please,choose image first")
msg.setIcon(QMessageBox.Warning)
x = msg.exec_()
else:
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(
np.fft.fftshift(20 * np.log(self.magnitude.T)))
if (str(self.ui.Combo1.currentText())) == 'FT Phase':
if (self.flag == 0):
msg = QMessageBox()
msg.setWindowTitle("Warning")
msg.setText("Please,choose image first")
msg.setIcon(QMessageBox.Warning)
x = msg.exec_()
else:
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(self.phase.T)
if (str(self.ui.Combo1.currentText())) == 'FT Real Component':
if (self.flag == 0):
msg = QMessageBox()
msg.setWindowTitle("Warning")
msg.setText("Please,choose image first")
msg.setIcon(QMessageBox.Warning)
x = msg.exec_()
else:
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(20 * np.log(self.real.T))
if (str(self.ui.Combo1.currentText())) == 'FT Imaginary Component':
if (self.flag == 0):
msg = QMessageBox()
msg.setWindowTitle("Warning")
msg.setText("Please,choose image first")
msg.setIcon(QMessageBox.Warning)
x = msg.exec_()
else:
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(self.imaginary.T)
if (str(self.ui.Combo1.currentText())) == 'Select an Option':
print('Please select a proper option')
def KSpace(self):
if (str(self.ui.comboBox_2.currentText())) == 'Show K-Space Image':
self.ui.KSpace.show()
self.ui.KSpace.setImage(self.k.T)
elif (str(self.ui.comboBox_2.currentText())) == "Show Gibb's Ringing":
self.ui.KSpace.show()
self.ui.KSpace.setImage(self.img_back1.T)
msg = QMessageBox()
msg.setWindowTitle("Definition")
msg.setText(
"Gibb's ringing occurs when the frequencies that are sampled in k-space are not sufficiently high "
)
s = msg.exec_()
elif (str(self.ui.comboBox_2.currentText())) == 'Show Ghosting Effect':
self.ui.KSpace.show()
self.ui.KSpace.setImage(self.img_back2.T)
msg = QMessageBox()
msg.setWindowTitle("Definition")
msg.setText(
"Ghosting happens when even and odd k-space lines are intensity modulated differently"
)
s = msg.exec_()
elif (str(self.ui.comboBox_2.currentText())) == 'Show T2* Blurring':
self.ui.KSpace.show()
self.ui.KSpace.setImage(self.img_back3.T)
msg = QMessageBox()
msg.setWindowTitle("Definition")
msg.setText(
"This particular artefact is due to the fact that when we acquire k-space data, the signal that we base our measurement on decays over time, with a time constant called T2*"
)
s = msg.exec_()
if (str(self.ui.comboBox_2.currentText())) == 'K-Space':
print('Please select a proper option')
class Mainwindow(QtWidgets.QMainWindow,
Ui_MainWindow): #Ventana principal de la GUI
def __init__(self, *args, **kwargs):
#Configuration
QtWidgets.QMainWindow.__init__(self, *args,
**kwargs) #Inicializar clases heredadas
self.ui = Ui_MainWindow() #Inicializamos la ventanan de la GUI
self.ui.setupUi(self)
#Set style
try:
self.real_path = os.path.dirname(os.path.abspath(__file__))
with open(self.real_path + '/GUI_style.css') as f:
self.setStyleSheet(f.read())
except:
self.real_path = os.path.dirname(sys.executable)
with open(self.real_path + '/GUI_style.css') as f:
self.setStyleSheet(f.read())
#Arrow
icon = QtGui.QIcon()
arrow = self.real_path + '/Arrow.jpg'
icon.addPixmap(QtGui.QPixmap(arrow), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
icon.addPixmap(QtGui.QPixmap(arrow), QtGui.QIcon.Normal,
QtGui.QIcon.On)
self.ui.toolButton_arrow.setIcon(icon)
#Properties
self.main_dir = ''
self.files = []
self.files_order = []
self.files_f = []
self.filter = ["Python (*.py)", "Fortran files (*.f90)"]
self.fcomments = 'before'
self.terminal = True
self.lib = ''
self.new_folder = ''
self.folder_path = ''
self.interface = ''
self.py_interface = ''
self.module_list = []
self.window_fmodule = ffiles.Window_fmodule(self_fparser=self)
self.window_options = ffiles.Window_options(self_fparser=self)
self.terminal_text = ffiles.Terminal(self_fparser=self)
self.makefile = make.Makefile(self_fparser=self)
self.ui.actionOpen_Directory.setShortcut("Ctrl+O")
self.ui.actionOpen_Files.setShortcut("Ctrl+F")
self.ui.actionOptions.setShortcut("Ctrl+T")
self.ui.actionClear.setShortcut("Ctrl+W")
#Connect signals
#Use .connect(lambda: function(args)) to send extra arguments through the function
self.ui.menuFile.triggered[QtWidgets.QAction].connect(self.action)
self.ui.toolButton_arrow.clicked.connect(
lambda: ffiles.select_ffiles(self))
self.ui.pushButton_fparser.clicked.connect(
lambda: ffiles.fortran_parser(self))
# self.ui.combobox.signal.connect(lambda: make.function(self.ui,self.makefile))
#self.ui.pushButton_makeOK.clicked.connect(lambda: make.selectOS(self.ui))
self.ui.comboBox_makeFC.activated.connect(self.makefile.fcompiler)
self.ui.pushButton_searchFC.clicked.connect(self.makefile.searchFC)
self.ui.toolButton_lib.clicked.connect(self.makefile.searchLib)
#self.ui.pushButton_makeOK.clicked.connect(self.makefile.properties)
self.ui.pushButton_makeOK.clicked.connect(self.makefile.runmake)
def action(self, selected_action):
if selected_action.text() == 'Open Files':
ffiles.open_files(self)
elif selected_action.text() == 'Open Folder':
ffiles.open_folder(self)
elif selected_action.text() == 'Options':
ffiles.select_options(self)
elif selected_action.text() == 'Clear':
ffiles.clear(self)
class StartQT4(QtGui.QMainWindow): ### generated class
mcu_com = communication.MCUcomm()
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
### link the PyQt generated file to a specific method (methods are defined below)###
##################<Buttons>#####################################################################
self.ui.pushButton_connect.clicked.connect(self.connect)
self.ui.pushButton_disconnect.clicked.connect(self.disconnect)
self.ui.pushButton_ventilationFanON.clicked.connect(self.ventilationFanON)
self.ui.pushButton_ventilationFanOFF.clicked.connect(self.ventilationFanOFF)
self.ui.pushButton_circulationFanON.clicked.connect(self.circulationFanON)
self.ui.pushButton_circulationFanOFF.clicked.connect(self.circulationFanOFF)
self.ui.pushButton_panelLightON.clicked.connect(self.panelLightON)
self.ui.pushButton_panelLightOFF.clicked.connect(self.panelLightOFF)
self.ui.pushButton_humidifierON.clicked.connect(self.humidifierON)
self.ui.pushButton_humidifierOFF.clicked.connect(self.humidifierOFF)
self.ui.pushButton_growLightON.clicked.connect(self.growLightON)
self.ui.pushButton_growLightOFF.clicked.connect(self.growLightOFF)
self.ui.pushButton_heaterON.clicked.connect(self.heaterON)
self.ui.pushButton_heaterOFF.clicked.connect(self.heaterOFF)
self.ui.pushButton_waterPumpON.clicked.connect(self.waterPumpON)
self.ui.pushButton_waterPumpOFF.clicked.connect(self.waterPumpOFF)
self.ui.pushButton_airPumpON.clicked.connect(self.airPumpON)
self.ui.pushButton_airPumpOFF.clicked.connect(self.airPumpOFF)
##################</Buttons>####################################################################
#############<Methods_for_buttons>####################################################
def connect(self):
self.mcu_com.openMCU(str(self.ui.lineEdit.text()))
time.sleep(2) # wait until arduino's bootloader done loading (arduino tend to auto restart each time new connection is made)
self.periodic_sampling()
def disconnect(self):
self.mcu_com.closeMCU()
def ventilationFanON(self):
self.mcu_com.ventilationFanON()
def ventilationFanOFF(self):
self.mcu_com.ventilationFanOFF()
def circulationFanON(self):
self.mcu_com.circulationFanON()
def circulationFanOFF(self):
self.mcu_com.circulationFanOFF()
def panelLightON(self):
self.mcu_com.panelLightON()
def panelLightOFF(self):
self.mcu_com.panelLightOFF()
def humidifierON(self):
self.mcu_com.humidifierON()
def humidifierOFF(self):
self.mcu_com.humidifierOFF()
def growLightON(self):
self.mcu_com.growLightON()
def growLightOFF(self):
self.mcu_com.growLightOFF()
def heaterON(self):
self.mcu_com.heaterON()
def heaterOFF(self):
self.mcu_com.heaterOFF()
def waterPumpON(self):
self.mcu_com.waterPumpON()
def waterPumpOFF(self):
self.mcu_com.waterPumpOFF()
def airPumpON(self):
self.mcu_com.airPumpON()
def airPumpOFF(self):
self.mcu_com.airPumpOFF()
#############</Methods_for_buttons>####################################################
###<display_stuffs>###
def updateDisplays(self, a, b, c, d, e, f, g, h, i, j):
self.ui.lcdNumber_windowSwitch.display(a)
self.ui.lcdNumber_shellSwitch.display(b)
self.ui.lcdNumber_waterTemperature.display(c)
self.ui.lcdNumber_waterConductivity.display(d)
self.ui.lcdNumber_waterpH.display(e)
self.ui.lcdNumber_lightIntensity.display(f)
self.ui.lcdNumber_lightPAR.display(g)
self.ui.lcdNumber_airTemperature.display(h)
self.ui.lcdNumber_airHumidity.display(i)
self.ui.lcdNumber_airCO2.display(j)
###<display_stuffs>###
#######<thread>###
def periodic_sampling_scheduler(self):
if self.mcu_com.mcuStatus() == True:
threading.Timer(1, self.periodic_sampling).start() # update displays every one second
def periodic_sampling(self):
if self.mcu_com.mcuStatus() == True:
receivedData = self.mcu_com.getAllSensor()
splitData = receivedData.split(',')
a = (splitData[0])
b = (splitData[1])
c = (splitData[2])
d = (splitData[3])
e = (splitData[4])
f = (splitData[5])
g = (splitData[6])
h = (splitData[7])
i = (splitData[8])
j = (splitData[9])
self.updateDisplays(a, b, c, d, e, f, g, h, i, j)
self.periodic_sampling_scheduler()
class MyForm(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.PushButtonAddGold.clicked.connect(self.browse_folder)
def browse_folder(self):
app = QtGui.QMainWindow()
myapp = MyWindow(self)
myapp.show()
def choosen(self, factory):
directory = QtGui.QFileDialog.getOpenFileName(self)
print(directory)
f = open(directory)
l = list(f.readlines())
instance = factory.create(l)
#self.graphvizdraw(instance)
self.qtdraw(instance)
def graphvizdraw(self, instance):
d = draw()
d.drawGraph(instance.edges, instance.tokens)
label = self.ui.label_picture
path = os.path.abspath('test-output/round-table.gv.pdf')
pdf2png.gs_pdf_to_png(path, 70)
path2 = os.path.abspath('test-output/round-table.gv.png')
#pixmap = QtGui.QPixmap(path2)
#label.setPixmap(pixmap)
myPixmap = QtGui.QPixmap(path2)
# myScaledPixmap = myPixmap.scaled(label.size())
label.setPixmap(myPixmap)
label.show()
def qtdraw(self, instance):
pixmap = QtGui.QPixmap(QtCore.QSize(400,400))
pixmap.fill(QtGui.QColor(200,0,0))
painter = QtGui.QPainter (pixmap)
#gradient = QtGui.QLinearGradient(QtCore.QPoint(pixmap.rect().topLeft()),
# QtCore.QPoint(pixmap.rect().bottomLeft()))
print("painter kész")
#gradient.setColorAt(0, QtCore.Qt.blue)
#gradient.setColorAt(0.4, QtCore.Qt.cyan)
#gradient.setColorAt(1, QtCore.Qt.green)
#brush = QtGui.QBrush(gradient)
#painter.fillRect(QtCore.QRectF(0,0,400,400), brush)
#painter.drawText(QtCore.QRectF(0,0,400,400), QtCore.Qt.AlignCenter,
# "This is az image created with QPainter and QPixmap")
painter.setBrush(QtGui.QColor(200,200,0))
painter.setBackground(QtGui.QColor(200,0,0))
#painter.drawRect(110,15,540,60)
#painter.drawEllipse(QtCore.QPoint(200, 400), 150, 40)
painter.drawArc(20,350, 150, 40, 16*0, 16*180)
del painter
print("rajzoltam")
pixmap.save("output.jpg")
#print("mentve")
label = self.ui.label_picture
label.setPixmap(pixmap)
label.show()
class mywindow(QtWidgets.QMainWindow):
files = ""
CURENT = 0
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setAcceptDrops(True)
self.ui.pushB_Init2.clicked.connect(self.pushB_Init2)
self.ui.pushB_Init12.clicked.connect(self.pushB_Init12)
self.ui.pushB_Connect.clicked.connect(self.pushB_Connect)
self.ui.pushB_Restart.clicked.connect(self.pushB_Restart)
#self.ui.actionSend.triggered.connect(self.MenuSendClicked)
#self.ui.label_1.clicked.connect(self.label_1)
#self.ui.actionExit.triggered.connect(self.MenuExitClicked)
#self.ui.pushButtonExit.clicked.connect(self.MenuExitClicked)
#self.ui.pushButton.clicked.connect(self.InsertProg)
#self.ui.tableWidget.cellClicked[int, int].connect(self.clickedRowColumn)
def pushB_Init12(self):
print("pushB_Init12")
return True
def pushB_Init2(self):
print("pushB_Init2")
return True
def pushB_Connect(self):
print("pushB_Connect")
return True
def pushB_Restart(self):
print("pushB_Restart")
return True
def label_1(self):
print("label_1")
return True
def dragEnterEvent(self, e):
if e.mimeData().hasUrls:
e.accept()
else:
e.ignore()
def dragMoveEvent(self, e):
if e.mimeData().hasUrls:
e.accept()
else:
e.ignore()
def dropEvent(self, e):
f = e.mimeData().urls()
mywindow.files = f[0].toString()
print(mywindow.files)
if mywindow.files[-3:] == "mp4":
print("кто это?")
class MainWindow(Functionalities):
def __init__(self, path_to_patient, index_side, interactive_mode):
self.main_win = QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.main_win)
self.path_to_patient = path_to_patient
self.index_side = int(index_side)
self.interactive_mode = int(interactive_mode)
self.rel_folder = self.rel_folder()
# Add stylesheet
self.stylesheet_filename = '{}/UX/dark.qss'.format(self.rel_folder)
self.loadStylesheet(self.stylesheet_filename)
self.current_file_name = " "
# call classes
self.externalNeuronArray = PopUpExternalNeuronArray(self.main_win)
self.meshRefinement = PopUpMeshRefinement(self.main_win)
self.cpeActive = PopUpCPEActive(self.main_win)
self.fullFieldIFFT = PopUpFullFieldIFFT(self.main_win)
# Initializations
# Extra Widget Group Show/Hide state
# self.ui.widget_CPE_Active.hide()
# self.ui.widget_Global_Rot.hide()
if self.ui.comboBox_Spectrum_Truncation_Method.currentText(
) == 'No Truncation':
self.ui.widget_Spectrum_Truncation_Method.hide()
self.ui.stackedWidget.setCurrentIndex(0)
# self.ui.widget_Name_Prepared_Array.hide()
# Initial States
# Signals to slots
# Test function
self.ui.checkBox_Voxel_orr_DTI.stateChanged.connect(
lambda: self.selection_list(self.ui.checkBox_Voxel_orr_DTI))
self.ui.checkBox_Init_Neuron_Model_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.
checkBox_Init_Neuron_Model_Ready))
self.ui.checkBox_Init_Mesh_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.checkBox_Init_Mesh_Ready))
self.ui.checkBox_Adjusted_Neuron_Model_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.
checkBox_Adjusted_Neuron_Model_Ready))
self.ui.checkBox_Signal_Generation_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.
checkBox_Signal_Generation_Ready))
self.ui.checkBox_CSF_Mesh_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.checkBox_CSF_Mesh_Ready))
self.ui.checkBox_Adapted_Mesh_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.checkBox_Adapted_Mesh_Ready))
self.ui.checkBox_Parallel_Computing_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.
checkBox_Parallel_Computing_Ready))
self.ui.checkBox_Parallel_Computing_Interrupted.stateChanged.connect(
lambda: self.selection_list(self.ui.
checkBox_Parallel_Computing_Ready))
self.ui.checkBox_IFFT_Ready.stateChanged.connect(
lambda: self.selection_list(self.ui.checkBox_IFFT_Ready))
# Page Change
self.ui.treeWidget_Project_Browser.itemSelectionChanged.connect(
lambda: self.qtree_item())
self.ui.treeWidget_Project_Browser.topLevelItem(0).setSelected(True)
# CheckBox signal
self.ui.checkBox_Parallel_Computing_Interrupted.stateChanged.connect(
lambda: self.connected_check_boxes(
self.ui.checkBox_Parallel_Computing_Interrupted, self.ui.
checkBox_Parallel_Computing_Ready))
self.ui.checkBox_Parallel_Computing_Ready.stateChanged.connect(
lambda: self.connected_check_boxes(
self.ui.checkBox_Parallel_Computing_Ready, self.ui.
checkBox_Parallel_Computing_Interrupted))
self.ui.checkBox_Current_Control.stateChanged.connect(
lambda: self.disable_widget(self.ui.checkBox_Current_Control, self.
ui.checkBox_CPE_Active))
self.ui.checkBox_Neuron_Model_Array_Prepared.stateChanged.connect(
lambda: self.show_menu_item_on_checkbox_click(
self.ui.checkBox_Neuron_Model_Array_Prepared, self.ui.
widget_Name_Of_External_Neuron_Array))
self.ui.checkBox_Neuron_Model_Array_Prepared.stateChanged.connect(
lambda: self.show_menu_item_on_checkbox_click(
self.ui.checkBox_Neuron_Model_Array_Prepared, self.ui.
widget_Name_Of_External_Neuron_Array_2))
self.ui.checkBox_Neuron_Model_Array_Prepared.stateChanged.connect(
lambda: self.show_menu_item_on_checkbox_click(
self.ui.checkBox_Neuron_Model_Array_Prepared, self.ui.
widget_Name_Of_External_Neuron_Array_3))
# PopUps
self.ui.checkBox_Neuron_Model_Array_Prepared.stateChanged.connect(
lambda: self.pop_up_reverse(
self.ui.checkBox_Neuron_Model_Array_Prepared, self.
externalNeuronArray, self.main_win))
self.ui.checkBox_Skip_Mesh_Refinement.stateChanged.connect(
lambda: self.pop_up_reverse(self.ui.checkBox_Skip_Mesh_Refinement,
self.meshRefinement, self.main_win))
self.ui.checkBox_CPE_Active.stateChanged.connect(lambda: self.pop_up(
self.ui.checkBox_CPE_Active, self.cpeActive, self.main_win))
self.ui.checkBox_Full_Field_IFFT.stateChanged.connect(
lambda: self.pop_up(self.ui.checkBox_Full_Field_IFFT, self.
fullFieldIFFT, self.main_win))
# Signal to show hidden menu items
# self.ui.lineEdit_Brain_Shape.editingFinished.connect(lambda: self.brain_shape_name_control())
# self.ui.lineEdit_Brain_Shape.textEdited.connect(lambda: self.brain_shape_name_control())
# self.ui.lineEdit_Brain_Shape.textChanged.connect(lambda: self.brain_shape_name_control())
self.ui.lineEdit_Approximating_Dimensions.editingFinished.connect(
lambda: self.check_lineedit_if_list_entered(
self.ui.lineEdit_Approximating_Dimensions.text(), self.ui.
lineEdit_Approximating_Dimensions))
self.ui.lineEdit_Approx_Geometry_Center.editingFinished.connect(
lambda: self.check_lineedit_if_list_entered(
self.ui.lineEdit_Approx_Geometry_Center.text(), self.ui.
lineEdit_Approx_Geometry_Center))
self.ui.comboBox_Spectrum_Truncation_Method.currentIndexChanged.connect(
lambda: self.show_menu_item_on_combobox_state_change(
"No Truncation", self.ui.comboBox_Spectrum_Truncation_Method,
self.ui.widget_Spectrum_Truncation_Method))
self.ui.comboBox_Spectrum_Truncation_Method.currentIndexChanged.connect(
lambda: self.spectrum_truncation_method_combobox_control())
# self.ui.checkBox_Neuron_Model_Array_Prepared.stateChanged.connect(lambda: self.hide_menu_item_on_checkbox_click(self.ui.checkBox_Neuron_Model_Array_Prepared, self.externalNeuronArray.ui.widget_Global_Rot))
self.ui.checkBox_Dimensions_From_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Dimensions_From_MRI, self.ui.
widget_Approximating_Dimensions))
self.ui.checkBox_Dimensions_From_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Dimensions_From_MRI, self.ui.
widget_Approximating_Dimensions_2))
self.ui.checkBox_Dimensions_From_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Dimensions_From_MRI, self.ui.
widget_Approximating_Dimensions_3))
self.ui.checkBox_Approx_Geom_Centered_On_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Approx_Geom_Centered_On_MRI, self.ui.
widget_Approx_Geometry_Center))
self.ui.checkBox_Approx_Geom_Centered_On_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Approx_Geom_Centered_On_MRI, self.ui.
widget_Approx_Geometry_Center_2))
self.ui.checkBox_Approx_Geom_Centered_On_MRI.stateChanged.connect(
lambda: self.hide_menu_item_on_checkbox_click(
self.ui.checkBox_Approx_Geom_Centered_On_MRI, self.ui.
widget_Approx_Geometry_Center_3))
self.ui.checkBox_Approx_Geom_Centered_On_MRI.stateChanged.connect(
lambda: self.ui.lineEdit_Approx_Geometry_Center.setText('0'))
# LineEdit to List functions
self.ui.lineEdit_N_Ranvier.editingFinished.connect(
lambda: self.check_lineedit_if_list_entered_absolute(
self.ui.lineEdit_N_Ranvier.text(), self.ui.lineEdit_N_Ranvier))
self.ui.lineEdit_Fiber_Diameter.editingFinished.connect(
lambda: self.check_lineedit_if_list_entered_absolute(
self.ui.lineEdit_Fiber_Diameter.text(), self.ui.
lineEdit_Fiber_Diameter))
self.ui.lineEdit_Phi_Vector.editingFinished.connect(
lambda: self.check_lineedit_if_list_entered(
self.ui.lineEdit_Phi_Vector.text(), self.ui.lineEdit_Phi_Vector
))
self.ui.lineEdit_Truncation_Parameter.editingFinished.connect(
lambda: self.check_lineedit_if_value_entered(
self.ui.lineEdit_Truncation_Parameter.text(), self.ui.
lineEdit_Truncation_Parameter))
# Load last saved dictionary
self.load_last_save_state()
# modify me!!!!!!!!!!!!!!
self.dict_list = [
"pop_up_control/dictionaries/dict_cpe_active.py",
"pop_up_control/dictionaries/dict_external_neuron_array.py",
"pop_up_control/dictionaries/dict_full_field_ifft.py",
"pop_up_control/dictionaries/dict_mesh_refinement.py"
]
# Display Images
self.ui.pushButton_Placed_Neurons.clicked.connect(lambda: self.display(
self.ui.label_Image_Placed_Neurons, self.path_to_patient +
'/Images/Axon_connections.png', self.path_to_patient +
'/Images/Placed_neurons.png'))
self.ui.pushButton_Signal_Recovered.clicked.connect(
lambda: self.display(
self.ui.label_Image_Signal_Recovered, self.path_to_patient +
'/Images/Signal_recovered_shape.png', self.path_to_patient +
'/Images/Signal_recovered_shape.png'))
self.ui.pushButton_CSF_Full_Refinement.clicked.connect(
lambda: self.display(
self.ui.label_Image_CSF_Full_Refinement, self.path_to_patient +
'/Images/CSF_full_refinement.png', self.path_to_patient +
'/Images/CSF_full_refinement.png'))
self.ui.pushButton_Adapted_Mesh.clicked.connect(lambda: self.display(
self.ui.label_Image_Adapted_Mesh, self.path_to_patient +
'/Images/Adapted_mesh.png', self.path_to_patient +
'/Images/Adapted_mesh.png'))
self.ui.pushButton_Signal_Convoluted_1st_Point.clicked.connect(
lambda: self.display(
self.ui.label_Image_Signal_Convoluted_1st_Point, self.
path_to_patient + '/Images/Signal_convoluted_1st_point.png',
self.path_to_patient +
'/Images/Signal_convoluted_1st_point.png'))
self.ui.pushButton_Axon_Activation.clicked.connect(
lambda: self.display(
self.ui.label_Image_Axon_Activation, self.path_to_patient +
'/Images/Axon_activation.png', self.path_to_patient +
'/Images/Activated_neurons.png'))
# Load/Save/Reset/Run to dictionary
self.ui.pushButton_Run.clicked.connect(lambda: self.dict_write(
self.output_dict(), self.current_file_name))
# Modification to run a subprocess on another thread when Run button is clicked.
self.ui.pushButton_Run.clicked.connect(lambda: self.run_thread())
self.ui.pushButton_SaveAs.clicked.connect(lambda: self.save_as())
self.ui.pushButton_Load.clicked.connect(lambda: self.load_dict())
self.ui.pushButton_Reset.clicked.connect(lambda: self.reset_state())
def show(self):
self.main_win.show()
if not self.interactive_mode:
self.save_as(
os.path.join(os.path.abspath(os.getcwd()), 'GUI_inp_dict.py'))
self.run_thread()
def run_command(self):
"""The subprocess takes the terminal command as a list."""
#put a command for the "Run" button in the GUI. The command depends on whether you use Docker or not. In the former case, you have two different options: as a sudo user or not. Check the tutorial.
dir_code = os.path.dirname(
os.getcwd()) # OSS-DBS folder to be mount, NOT OSS_platform folder
if sys.platform == 'linux':
if os.environ.get('SINGULARITY_NAME'):
output = subprocess.run(['python3', 'Launcher_OSS_lite.py'])
else:
output = subprocess.run([
'docker', 'run', '-e', 'PATIENTDIR', '--volume',
dir_code + ':/opt/OSS-DBS', '--volume',
self.path_to_patient + ':/opt/Patient', '-it', '--rm',
'custom_oss-dbs', 'python3', 'Launcher_OSS_lite.py'
]) #
elif sys.platform == 'darwin' or sys.platform == 'win32':
output = subprocess.run([
'docker', 'run', '-e', 'PATIENTDIR', '--volume',
dir_code + ':/opt/OSS-DBS', '--volume',
self.path_to_patient + ':/opt/Patient', '-it', '--rm',
'ningfei/oss-dbs', 'python3', 'Launcher_OSS_lite.py'
])
else:
print("The system's OS does not support OSS-DBS")
raise SystemExit
# does not work on macOS
#out2 = subprocess.run(['docker','logs','OSS_container'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) #
#stdout_as_str = out2.stdout.decode("utf-8")
#text_file = open(self.path_to_patient+"/Docker_log.txt", "wt")
#n = text_file.write(stdout_as_str)
#text_file.close()
#print(output.returncode)
#if not os.path.exists(self.path_to_patient+'/success.txt'):
# subprocess.call(['touch', self.path_to_patient+'/fail.txt'])
# print("Error occurred, check the terminal")
#else:
# print("Simulation is completed")
# self.closeWindow()
if self.index_side == 0:
if not os.path.exists(self.path_to_patient + '/success_rh.txt'):
subprocess.call(
['touch', self.path_to_patient + '/fail_rh.txt'])
print("Error occurred when simulating rh, check the terminal")
else:
print("Simulation is completed")
else:
if not os.path.exists(self.path_to_patient + '/success_lh.txt'):
subprocess.call(
['touch', self.path_to_patient + '/fail_lh.txt'])
print("Error occurred when simulating lh, check the terminal")
else:
print("Simulation is completed")
self.closeWindow()
# the commands below work only with a properly installed Paraview (supporting from paraview.simple import *)
#print(self.path_to_patient)
#prepare screenshots
#we need to insert the correct path here (use the already written python scripts)
#with open(os.devnull, 'w') as FNULL: subprocess.call(['python','Visualization_files/Paraview_csv_neurons.py',self.path_to_patient], shell=True, stdout=FNULL, stderr=subprocess.STDOUT)
# try:
# subprocess.run(['python','Visualization_files/Paraview_csv_neurons.py',self.path_to_patient])
# except:
# subprocess.run(['python','Visualization_files/Paraview_connections_processed.py',self.path_to_patient])
# try:
# subprocess.run(['python','Visualization_files/Paraview_csv_activation.py.py',self.path_to_patient])
# except:
# subprocess.run(['python','Visualization_files/Paraview_connections_activation.py',self.path_to_patient])
# subprocess.run(['python','Visualization_files/Paraview_CSFref.py',self.path_to_patient])
# subprocess.run(['python','Visualization_files/Paraview_adapted.py',self.path_to_patient])
#subprocess.run(['python','Visualization_files/Paraview_csv_neurons.py',self.path_to_patient])
#subprocess.run(['xterm','-hold','-e','ls'])
#command_to_run='gnome-terminal -- bash -c "python3 Launcher_OSS_lite.py && read"'
#command_to_run='xterm -hold -e python3 Launcher_OSS_lite.py'
#subprocess.run(['xterm','-hold','-e','python3','Launcher_OSS_lite.py'])
#subprocess.run(['gnome-terminal','--execute','python3', 'Launcher_OSS_lite.py'])#
#substitute tilda
#subprocess.run([
"""add the command you use to run OSS-DBS here (as shown above)"""
def run_thread(self):
t = Thread(target=self.run_command)
t.start()
# Call to tree Item
def qtree_item(self):
if self.ui.treeWidget_Project_Browser.topLevelItem(0).isSelected():
self.click_change_page(0)
elif self.ui.treeWidget_Project_Browser.topLevelItem(1).isSelected():
self.click_change_page(1)
elif self.ui.treeWidget_Project_Browser.topLevelItem(2).isSelected():
self.click_change_page(2)
elif self.ui.treeWidget_Project_Browser.topLevelItem(5).isSelected():
self.click_change_page(3)
elif self.ui.treeWidget_Project_Browser.topLevelItem(6).isSelected():
self.click_change_page(4)
elif self.ui.treeWidget_Project_Browser.topLevelItem(7).isSelected():
self.click_change_page(5)
elif self.ui.treeWidget_Project_Browser.topLevelItem(8).isSelected():
self.click_change_page(6)
def click_change_page(self, page_num):
self.ui.stackedWidget.setCurrentIndex(page_num)
def spectrum_truncation_method_combobox_control(self):
if self.ui.comboBox_Spectrum_Truncation_Method.currentText(
) == 'Octave Band Method':
self.ui.widget_STM_1.show()
self.ui.widget_STM_2.show()
self.ui.widget_STM_3.show()
self.ui.widget_STM_4.hide()
self.ui.widget_STM_5.hide()
self.ui.widget_STM_6.hide()
self.ui.widget_Truncate_Already_Obtained_Full_Solution.hide()
self.ui.widget_Truncate_Already_Obtained_Full_Solution_2.hide()
self.ui.widget_Truncate_Already_Obtained_Full_Solution_3.hide()
else:
self.ui.widget_STM_1.hide()
self.ui.widget_STM_2.hide()
self.ui.widget_STM_3.hide()
self.ui.widget_STM_4.show()
self.ui.widget_STM_5.show()
self.ui.widget_STM_6.show()
self.ui.widget_Truncate_Already_Obtained_Full_Solution.show()
self.ui.widget_Truncate_Already_Obtained_Full_Solution_2.show()
self.ui.widget_Truncate_Already_Obtained_Full_Solution_3.show()
# Selection list
def selection_list(self, checkbox):
vmri = self.ui.checkBox_Voxel_orr_MRI
vdti = self.ui.checkBox_Voxel_orr_DTI
inmr = self.ui.checkBox_Init_Neuron_Model_Ready
imr = self.ui.checkBox_Init_Mesh_Ready
anmr = self.ui.checkBox_Adjusted_Neuron_Model_Ready
sgr = self.ui.checkBox_Signal_Generation_Ready
cmr = self.ui.checkBox_CSF_Mesh_Ready
amr = self.ui.checkBox_Adapted_Mesh_Ready
pcr = self.ui.checkBox_Parallel_Computing_Ready
pci = self.ui.checkBox_Parallel_Computing_Interrupted
ifftr = self.ui.checkBox_IFFT_Ready
full_checkbox_list = [
vmri, vdti, inmr, anmr, sgr, cmr, amr, pcr, pci, ifftr
]
vdti_L = [vmri]
inmr_L = [vmri]
imr_L = [vmri, inmr]
anmr_L = [vmri, inmr, imr]
sgr_L = [pcr, pci, ifftr]
cmr_L = [vmri, inmr, imr, anmr, sgr]
amr_L = [vmri, inmr, imr, anmr, cmr, sgr]
pcr_L = [vmri, inmr, imr, anmr, cmr, amr, sgr]
pci_L = [vmri, inmr, imr, anmr, cmr, amr, sgr]
ifftr_L = [vmri, inmr, imr, anmr, cmr, amr, sgr, pcr]
if checkbox == vdti:
if checkbox.checkState() == 2:
for x in vdti_L:
if x.checkState() == 0:
x.setCheckState(2)
if checkbox == inmr:
if checkbox.checkState() == 2:
for x in inmr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == imr:
if checkbox.checkState() == 2:
for x in imr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == anmr:
if checkbox.checkState() == 2:
for x in anmr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == cmr:
if checkbox.checkState() == 2:
for x in cmr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == amr:
if checkbox.checkState() == 2:
for x in amr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == sgr:
if checkbox.checkState() == 0:
for x in sgr_L:
x.setCheckState(0)
elif checkbox == pcr:
if checkbox.checkState() == 2:
for x in pcr_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == pci:
if checkbox.checkState() == 2:
for x in pci_L:
if x.checkState() == 0:
x.setCheckState(2)
elif checkbox == ifftr:
if checkbox.checkState() == 2:
pcr.setCheckState(2)
pci.setCheckState(0)
for x in ifftr_L:
if x.checkState() == 0:
x.setCheckState(2)
def output_dict(self):
# from pop_up_control.dictionaries import dict_cpe_active, dict_external_neuron_array, dict_full_field_ifft, \
# dict_mesh_refinement
output_dict = Dictionary(self).output_dict()
output_dict['Stim_side'] = self.index_side
output_dict['stretch'] = self.stretch
# # concatenate various dictionaries
# output_dict.update(dict_cpe_active.d)
# output_dict.update(dict_external_neuron_array.d)
# output_dict.update(dict_full_field_ifft.d)
# output_dict.update(dict_mesh_refinement.d)
return output_dict
def dict_write(self, output_dict, filename):
if os.path.isabs(filename):
pass
else:
filename = '{}/{}'.format(self.rel_folder, filename)
if " " in filename or "default_dict.py" in filename or "last_save.py" in filename:
self.save_as()
else:
with open(filename, 'w') as test_dict:
test_dict.write(Header.header)
test_dict.write("d = {\n")
for x in output_dict:
test_dict.write(" '{}': {},\n".format(
x, output_dict[x]))
# append data from other dicts
for dict_filename in self.dict_list:
dict_filename = '{}/{}'.format(self.rel_folder,
dict_filename)
with open(dict_filename, 'r') as f:
content = f.read().split('{')[1].split('}')[0]
test_dict.write(content.strip())
test_dict.write("}\n")
with open("{}/GUI_tree_files/last_save.py".format(self.rel_folder),
'w') as last_save:
last_save.write("d = {\n")
for x in output_dict:
last_save.write(" '{}': {},\n".format(
x, output_dict[x]))
last_save.write(" }\n")
if self.interactive_mode:
self.info(
"Run",
"Setup state has been written to {}.".format(filename))
else:
print("Setup state has been written to {}".format(filename))
def save_as(self, filename=""):
if filename == "":
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename, _ = QFileDialog.getSaveFileName(
None,
"Save State",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
if filename != "":
filename = self.py_check(filename)
if "default_dict.py" in filename or "last_save.py" in filename:
self.info(
"Write Forbidden",
"Oops, that didn't save! It seems you attempted to write to the default dictionary."
)
else:
with open(filename, 'w') as save_as_dict:
save_as_dict.write(Header.header)
save_as_dict.write("d = {\n")
for x in self.output_dict():
save_as_dict.write(" '{}': {},\n".format(
x,
self.output_dict()[x]))
# append data from other dicts
for dict_filename in self.dict_list:
dict_filename = '{}/{}'.format(self.rel_folder,
dict_filename)
with open(dict_filename, 'r') as f:
content = f.read().split('{')[1].split('}')[0]
save_as_dict.write(content.strip())
save_as_dict.write("}\n")
with open(
"{}/GUI_tree_files/last_save.py".format(
self.rel_folder), 'w') as last_save:
last_save.write("d = {\n")
for x in self.output_dict():
last_save.write(" '{}': {},\n".format(
x,
self.output_dict()[x]))
# append data from other dicts
for dict_filename in self.dict_list:
dict_filename = '{}/{}'.format(self.rel_folder,
dict_filename)
with open(dict_filename, 'r') as f:
content = f.read().split('{')[1].split('}')[0]
last_save.write(content.strip())
last_save.write("}\n")
if self.interactive_mode:
self.info(
"Run",
"Setup state has been written to {}.".format(filename))
else:
print(
"Setup state has been written to {}".format(filename))
self.set_current_file_name(filename)
def set_load_state(self, d):
self.stretch = d['stretch']
# default choice of processors
if sys.platform == 'linux':
physical_cores = os.popen(
"""lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l"""
).read()[:-1]
d['number_of_processors'] = int(int(physical_cores) *
0.5) # leave some
print("Number of cores drawn by default: ",
d['number_of_processors'])
else:
print("All cores available for Docker will be drawn")
self.ui.checkBox_Voxel_orr_MRI.setCheckState(
self.anti_corrector(d['voxel_arr_MRI']))
self.ui.checkBox_Voxel_orr_DTI.setCheckState(
----self.anti_corrector(d['voxel_arr_DTI']))
self.ui.checkBox_Init_Neuron_Model_Ready.setCheckState(
self.anti_corrector(d['Init_neuron_model_ready']))
self.ui.checkBox_Init_Mesh_Ready.setCheckState(
self.anti_corrector(d['Init_mesh_ready']))
self.ui.checkBox_Adjusted_Neuron_Model_Ready.setCheckState(
self.anti_corrector(d['Adjusted_neuron_model_ready']))
self.ui.checkBox_CSF_Mesh_Ready.setCheckState(
self.anti_corrector(d['CSF_mesh_ready']))
self.ui.checkBox_Adapted_Mesh_Ready.setCheckState(
self.anti_corrector(d['Adapted_mesh_ready']))
self.ui.checkBox_Signal_Generation_Ready.setCheckState(
self.anti_corrector(d['signal_generation_ready']))
self.ui.checkBox_Parallel_Computing_Ready.setCheckState(
self.anti_corrector(d['Parallel_comp_ready']))
self.ui.checkBox_Parallel_Computing_Interrupted.setCheckState(
self.anti_corrector(d['Parallel_comp_interrupted']))
self.ui.checkBox_IFFT_Ready.setCheckState(
self.anti_corrector(d['IFFT_ready']))
self.ui.lineEdit_MRI_Data_Name.setText(d['MRI_data_name'])
self.ui.checkBox_MRI_m.setCheckState(self.anti_corrector(
d['MRI_in_m']))
self.ui.lineEdit_DTI_Data_Name.setText(d['DTI_data_name'])
self.ui.checkBox_DTI_m.setCheckState(self.anti_corrector(
d['DTI_in_m']))
self.ui.doubleSpinBox_CSF_Index.setValue(d['CSF_index'])
self.ui.doubleSpinBox_WM_Index.setValue(d['WM_index'])
self.ui.doubleSpinBox_GM_Index.setValue(d['GM_index'])
self.ui.comboBox_Default_Material.setCurrentIndex(
d['default_material'] - 1)
self.ui.comboBox_Electrode_Type.setCurrentText(d['Electrode_type'])
self.ui.lineEdit_Brain_Shape.setText("{}".format(
d['Brain_shape_name']))
# self.ui.doubleSpinBox_X_Length.setValue(d['x_length'])
# self.ui.doubleSpinBox_Y_Length.setValue(d['y_length'])
# self.ui.doubleSpinBox_Z_Length.setValue(d['z_length'])
self.get_lineedit_entry(d['Aprox_geometry_center'],
self.ui.lineEdit_Approx_Geometry_Center)
try:
self.get_lineedit_entry(d['Approximating_Dimensions'],
self.ui.lineEdit_Approximating_Dimensions)
except:
pass
self.ui.doubleSpinBox_Implantation_Coordinate_X.setValue(
d['Implantation_coordinate_X'])
self.ui.doubleSpinBox_Implantation_Coordinate_Y.setValue(
d['Implantation_coordinate_Y'])
self.ui.doubleSpinBox_Implantation_Coordinate_Z.setValue(
d['Implantation_coordinate_Z'])
self.ui.doubleSpinBox_2nd_Point_On_Lead_X.setValue(
d['Second_coordinate_X'])
self.ui.doubleSpinBox_2nd_Point_On_Lead_Y.setValue(
d['Second_coordinate_Y'])
self.ui.doubleSpinBox_2nd_Point_On_Lead_Z.setValue(
d['Second_coordinate_Z'])
self.ui.doubleSpinBox_Turn_Around_Lead_Axis.setValue(d['Rotation_Z'])
self.ui.doubleSpinBox_Encapsulation_Thickness.setValue(
d['encap_thickness'])
self.ui.comboBox_Encapsulation_Tissue_Type.setCurrentIndex(
d['encap_tissue_type'] - 1)
self.ui.doubleSpinBox_Conductivity_Scaling.setValue(
d['encap_scaling_cond'])
self.ui.doubleSpinBox_Permittivity_Scaling.setValue(
d['encap_scaling_perm'])
self.ui.lineEdit_Pattern_Model_Name.setText("{}".format(
d['pattern_model_name']))
try:
self.ui.comboBox_Axon_Model_Type.setCurrentText("{}".format(
d['Axon_Model_Type']))
except:
pass
self.ui.lineEdit_Fiber_Diameter.setText("{}".format(d['diam_fib']))
self.ui.lineEdit_N_Ranvier.setText("{}".format(d['n_Ranvier']))
self.ui.doubleSpinBox_V_Init.setValue(d['v_init'])
self.ui.checkBox_Neuron_Model_Array_Prepared.setCheckState(
self.anti_corrector(d['Neuron_model_array_prepared']))
self.ui.lineEdit_Name_Prepared_Neuron_Array.setText("{}".format(
d['Name_prepared_neuron_array']))
self.externalNeuronArray.ui.checkBox_Global_Rot.setCheckState(
self.anti_corrector(d['Global_rot']))
if self.externalNeuronArray.ui.checkBox_Global_Rot.checkState() == 2:
self.externalNeuronArray.ui.doubleSpinBox_X_Seed.setValue(
d['x_seed'])
self.externalNeuronArray.ui.doubleSpinBox_Y_Seed.setValue(
d['y_seed'])
self.externalNeuronArray.ui.doubleSpinBox_Z_Seed.setValue(
d['z_seed'])
self.externalNeuronArray.ui.spinBox_X_Steps.setValue(d['x_steps'])
self.externalNeuronArray.ui.spinBox_Y_Steps.setValue(d['y_steps'])
self.externalNeuronArray.ui.spinBox_Z_Steps.setValue(d['z_steps'])
self.externalNeuronArray.ui.doubleSpinBox_X_Step.setValue(
d['x_step'])
self.externalNeuronArray.ui.doubleSpinBox_Y_Step.setValue(
d['y_step'])
self.externalNeuronArray.ui.doubleSpinBox_Z_Step.setValue(
d['z_step'])
self.get_lineedit_entry(
d['alpha_array_glob'],
self.externalNeuronArray.ui.lineEdit_Alpha_Array_Glob)
self.get_lineedit_entry(
d['beta_array_glob'],
self.externalNeuronArray.ui.lineEdit_Beta_Array_Glob)
self.get_lineedit_entry(
d['gamma_array_glob'],
self.externalNeuronArray.ui.lineEdit_Gamma_Array_Glob)
else:
self.get_lineedit_entry(
d['X_coord_old'],
self.externalNeuronArray.ui.lineEdit_X_Coordinate_Old)
self.get_lineedit_entry(
d['Y_coord_old'],
self.externalNeuronArray.ui.lineEdit_Y_Coordinate_Old)
self.get_lineedit_entry(
d['Z_coord_old'],
self.externalNeuronArray.ui.lineEdit_Z_Coordinate_Old)
self.get_lineedit_entry(
d['YZ_angles'], self.externalNeuronArray.ui.lineEdit_YZ_Angles)
self.get_lineedit_entry(
d['ZX_angles'], self.externalNeuronArray.ui.lineEdit_ZX_Angles)
self.get_lineedit_entry(
d['XY_angles'], self.externalNeuronArray.ui.lineEdit_XY_Angles)
self.ui.comboBox_Laplace_Formulation.setCurrentText(d['EQS_core'])
self.ui.checkBox_Skip_Mesh_Refinement.setCheckState(
self.anti_corrector(d['Skip_mesh_refinement']))
self.get_lineedit_entry(
d['refinement_frequency'],
self.meshRefinement.ui.lineEdit_Refinement_Frequency)
self.meshRefinement.ui.spinBox_No_Of_Refinement_Frequencies.setValue(
d['num_ref_freqs'])
self.meshRefinement.ui.doubleSpinBox_Deviation_Threshold.setValue(
d['Adaptive_frac_div'])
self.meshRefinement.ui.doubleSpinBox_Min_Scaling.setValue(
d['Min_Scaling'])
self.meshRefinement.ui.doubleSpinBox_CSF_Ref_Reg.setValue(
d['CSF_ref_reg'])
self.meshRefinement.ui.doubleSpinBox_Rel_Div.setValue(d['rel_div'])
self.meshRefinement.ui.doubleSpinBox_Rel_Div_Current.setValue(
d['rel_div_current'])
self.ui.spinBox_El_Order.setValue(d['el_order'])
self.ui.spinBox_Number_Of_Processors.setValue(
d['number_of_processors'])
try:
self.ui.checkBox_FEniCS_MPI.setCheckState(
self.anti_corrector(d['FEniCS_MPI']))
except:
pass
self.ui.checkBox_Current_Control.setCheckState(
self.anti_corrector(d['current_control']))
self.get_lineedit_entry(d['Phi_vector'], self.ui.lineEdit_Phi_Vector)
try:
self.ui.comboBox_Solver_Type.setCurrentText("{}".format(
d['Solver_Type']))
except:
pass
self.ui.doubleSpinBox_Frequency.setValue(d['freq'])
self.ui.doubleSpinBox_T.setValue(d['T'])
self.ui.doubleSpinBox_T_Step.setValue(d['t_step'])
self.ui.doubleSpinBox_Signal_Shift.setValue(d['phi'])
self.ui.comboBox_Signal_Type.setCurrentText("{}".format(
d['Signal_type']))
self.ui.doubleSpinBox_Amplitude_Scale.setValue(d['Ampl_scale'])
self.ui.checkBox_CPE_Active.setCheckState(
self.anti_corrector(d['CPE_activ']))
self.cpeActive.ui.doubleSpinBox_Alpha.setValue(d['beta'])
self.cpeActive.ui.doubleSpinBox_K_S.setValue(d['K_A'])
self.cpeActive.ui.doubleSpinBox_Alpha_Ground.setValue(d['beta_ground'])
self.cpeActive.ui.doubleSpinBox_K_S_Ground.setValue(d['K_A_ground'])
self.ui.checkBox_Full_Field_IFFT.setCheckState(
self.anti_corrector(d['Full_Field_IFFT']))
self.fullFieldIFFT.ui.spinBox_T_Step_End.setValue(d['t_step_end'])
self.fullFieldIFFT.ui.checkBox_VTA_From_DivE.setCheckState(
self.anti_corrector(d['VTA_from_divE']))
self.fullFieldIFFT.ui.checkBox_VTA_From_NEURON.setCheckState(
self.anti_corrector(d['VTA_from_NEURON']))
self.fullFieldIFFT.ui.checkBox_VTA_From_E.setCheckState(
self.anti_corrector(d['VTA_from_E']))
self.get_lineedit_entry(
d['Activation_threshold_VTA'],
self.fullFieldIFFT.ui.lineEdit_Activation_Threshold)
self.ui.comboBox_Spectrum_Truncation_Method.setCurrentText(
d['spectrum_trunc_method'])
self.get_entry_truncation_parameter(
d['trunc_param'], self.ui.comboBox_Spectrum_Truncation_Method,
self.ui.lineEdit_Truncation_Parameter,
self.ui.spinBox_Truncation_Parameter)
self.ui.checkBox_Truncate_The_Obtained_Full_Solution.setCheckState(
self.anti_corrector(d['Truncate_the_obtained_full_solution']))
#self.ui.checkBox_Show_Paraview_Screenshots.setCheckState(self.anti_corrector(d['Show_paraview_screenshots']))
self.ui.checkBox_external_grounding.setCheckState(
self.anti_corrector(d['external_grounding']))
# save sub dictionaries
self.cpeActive.saveDict()
self.meshRefinement.saveDict()
self.fullFieldIFFT.saveDict()
self.externalNeuronArray.saveDict()
def load_dict(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename, _ = QFileDialog.getOpenFileName(
None,
"Load State",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
if filename:
with open(filename, 'r') as f:
num = f.read().find('{')
f.seek(num)
content = f.read()
d = ast.literal_eval(content.strip())
self.set_load_state(d)
self.info("Run",
"{} has been loaded successfully.".format(filename))
self.set_current_file_name(filename)
def reset_state(self):
filename = "{}/GUI_tree_files/default_dict.py".format(self.rel_folder)
with open(filename, 'r') as f:
num = f.read().find('{')
f.seek(num)
content = f.read()
d = ast.literal_eval(content.strip())
self.set_load_state(d)
# self.set_current_file_name(filename)
# Display Images
self.display(self.ui.label_Image_Placed_Neurons,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
self.display(self.ui.label_Image_Signal_Recovered,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
self.display(self.ui.label_Image_CSF_Full_Refinement,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
self.display(self.ui.label_Image_Adapted_Mesh,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
self.display(self.ui.label_Image_Signal_Convoluted_1st_Point,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
self.display(self.ui.label_Image_Axon_Activation,
'{}/icons/image_placeholder.png'.format(self.rel_folder),
'{}/icons/image_placeholder.png'.format(self.rel_folder),
2)
def load_last_save_state(self):
try:
filename = "{}/GUI_tree_files/default_dict.py".format(
self.rel_folder)
with open(filename, 'r') as f:
num = f.read().find('{')
f.seek(num)
content = f.read()
d = ast.literal_eval(content.strip())
self.set_load_state(d)
# self.info("Run", "Last save state was loaded successfully")
# self.set_current_file_name(filename)
except AssertionError:
# self.info("Run", "Oopsie! There seems to have been a problem with loading the default settings")
pass
except ValueError:
# self.info("Run", "Oopsie! There seems to have been a problem with loading the default settings")
pass
except SyntaxError:
# self.info("Run", "Oopsie! There seems to be a syntax error with the last saved dictionary file.")
pass
except FileNotFoundError:
self.info("Run",
"Oopsie! A default_dict.py file seems not to be found.")
pass
except:
self.info(
"Run",
"Oopsie! There seems to have been a problem loading the last saved dictionary."
)
class MainWindows(QMainWindow):
def __init__(self):
super().__init__()
self.gui = Ui_MainWindow()
self.gui.setupUi(self)
try:
js = json.load(open('config.json', encoding='utf-8'))
self.user_name = js['Login']['user_name']
self.user_password = js['Login']['user_password']
self.user_cookies = js['Login']['user_cookies']
self.ban_status = js['Setting']['ban_status']
self.ban_word = js['Setting']['ban_word']
self.work_thread = js['Setting']['work_thread']
self.download_thread = js['Setting']['download_thread']
self.screening_criteria = js['Setting']['screening_criteria']
except:
self.gui.listWidget.addItem('读取配置文件失败')
self.work = False
else:
self.work = True
self._search_type = {'全年龄': 'safe', '全部': 'all', 'R18': 'r18'}
self.gui.button_search_start.clicked.connect(self.search)
self.gui.button_ranking_start.clicked.connect(self.ranking)
def _search_thread(self):
keyword = self.gui.search_tag.toPlainText()
mode = self._search_type[self.gui.search_type.currentText()]
start = self.gui.search_startpage.toPlainText()
finish = self.gui.search_finishpage.toPlainText()
if keyword != '' and mode != '' and start != '' and finish != '':
try:
if int(finish) >= int(start):
all_time = 0
pixix = Pixiv(self.user_cookies)
for i in range(int(start), int(finish) + 1):
self.gui.listWidget.addItem(
'正在爬取第{0}页......'.format(i))
time1 = time.time()
pics = pixix.search(keyword=keyword,
mode=mode,
search_page=i)
if pics != []:
new_data = pixix.screen(self.screening_criteria,
pics['data'],
self.work_thread)
pixix.download(freq=self.download_thread,
data=new_data,
path=pics['path'])
time2 = time.time()
self.gui.listWidget.addItem(
'第{0}页完成，用时{1}秒'.format(
i, round(time2 - time1), 2))
all_time = all_time + time2 - time1
else:
self.gui.listWidget.addItem('第{0}页为空'.format(i))
self.gui.listWidget.addItem('{0}到{1}页已完成，共用时{2}秒'.format(
start, finish, round(all_time, 2)))
else:
self.gui.listWidget.addItem('Error：开始页数不能大于结束页数')
except ValueError:
self.gui.listWidget.addItem('Error：请输入数字')
else:
self.gui.listWidget.addItem('Error：请输入')
def search(self):
if self.work:
pixiv = Pixiv(self.user_cookies)
if pixiv.login_status():
thread = threading.Thread(target=self._search_thread)
thread.start()
else:
self.gui.listWidget.addItem('Error：登录失效')
else:
self.gui.listWidget.addItem('读取配置文件出错，无法运行')
def _ranking_thread(self):
ranking_type = {
'今日普通': 'daily',
'本周普通': 'weekly',
'本月普通': 'monthly',
'新人普通': 'rookie',
'原创普通': 'original',
'受男性欢迎普通': 'male',
'受女性欢迎普通': 'female',
'今日R18': 'daily_r18',
'本周R18': 'weekly_r18',
'本月R18': 'monthly_r18',
'新人R18': 'rookie_r18',
'原创R18': 'original_r18',
'受男性欢迎R18': 'male_r18',
'受女性欢迎R18': 'female_r18'
}
mode = ranking_type[self.gui.ranking_type.currentText() +
self.gui.ranking_type2.currentText()]
date = self.gui.ranking_date.toPlainText()
if mode not in ['weekly_r18', 'monthly_r18', 'monthly', 'weekly']:
try:
int(date)
except ValueError:
self.gui.listWidget.addItem('Error：请输入数字')
else:
pixiv = Pixiv(self.user_cookies)
time1 = time.time()
self.gui.listWidget.addItem('正在搜索...')
pics = pixiv.ranking_list(mode=mode, date=date)
if pics != []:
new_data = pixiv.screen(self.screening_criteria,
pics['data'], self.work_thread)
time2 = time.time()
self.gui.listWidget.addItem('搜索完成，用时{0}秒'.format(
round(time2 - time1, 2)))
self.gui.listWidget.addItem('正在下载...')
time1 = time.time()
pixiv.download(freq=self.download_thread,
data=new_data,
path=pics['path'])
time2 = time.time()
self.gui.listWidget.addItem('下载完成，用时{0}秒'.format(
round(time2 - time1, 2)))
else:
self.gui.listWidget.addItem('内容为空！')
else:
pixiv = Pixiv(self.user_cookies)
pics = pixiv.ranking_list(mode=mode, date=date)
if pics != []:
new_data = pixiv.screen(self.screening_criteria, pics['data'],
self.work_thread)
self.gui.listWidget.addItem('正在下载...')
pixiv.download(freq=self.download_thread,
data=new_data,
path=pics['path'])
else:
self.gui.listWidget.addItem('内容为空！')
def ranking(self):
if self.work:
pixiv = Pixiv(self.user_cookies)
if pixiv.login_status():
thread = threading.Thread(target=self._ranking_thread)
thread.start()
else:
self.gui.listWidget.addItem('Error：登录失效')
else:
self.gui.listWidget.addItem('读取配置文件出错，无法运行')
class Editor(QMainWindow):
def __init__(self):
super(Editor, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.main_text.setText('Hello!')
self.ui.menu_save.triggered.connect(self.save)
self.ui.menu_open.triggered.connect(self.open)
self.ui.menu_print.triggered.connect(self.print_file)
self.ui.menu_print_preview.triggered.connect(self.print_preview)
self.ui.menu_export_pdf.triggered.connect(self.export_pdf)
self.text_weight = lambda: QFont.Bold if self.ui.bold_checkBox.isChecked(
) else 0
self.ui.color_change_button.clicked.connect(self.change_font_color)
self.ui.left_alignment.triggered.connect(
lambda: self.ui.main_text.setAlignment(Qt.AlignLeft))
self.ui.center_alignment.triggered.connect(
lambda: self.ui.main_text.setAlignment(Qt.AlignCenter))
self.ui.right_alignment.triggered.connect(
lambda: self.ui.main_text.setAlignment(Qt.AlignRight))
self.ui.justify_alignment.triggered.connect(
lambda: self.ui.main_text.setAlignment(Qt.AlignJustify))
self.ui.bold_checkBox.toggled.connect(
lambda: self.ui.main_text.setFontWeight(self.text_weight()))
self.ui.italic_checkBox.toggled.connect(
lambda: self.ui.main_text.setFontItalic(self.ui.italic_checkBox.
isChecked()))
self.ui.underline_checkBox.toggled.connect(
lambda: self.ui.main_text.setFontUnderline(
self.ui.underline_checkBox.isChecked()))
self.ui.font_size_spinBox.valueChanged.connect(
lambda: self.ui.main_text.setFontPointSize(
self.ui.font_size_spinBox.value()))
self.ui.select_font_box.currentFontChanged.connect(self.change_font)
def change_font_color(self):
color = QColorDialog.getColor()
if color.isValid():
self.ui.main_text.setTextColor(color)
self.ui.color_change_button.setStyleSheet(
"background-color: {}".format(color.name()))
def change_font(self):
self.ui.main_text.setCurrentFont(self.ui.select_font_box.currentFont())
self.ui.main_text.setFontPointSize(self.ui.font_size_spinBox.value())
self.ui.main_text.setFontWeight(self.text_weight())
self.ui.main_text.setFontItalic(self.ui.italic_checkBox.isChecked())
self.ui.main_text.setFontUnderline(
self.ui.underline_checkBox.isChecked())
def save(self):
file_name, _ = QFileDialog.getSaveFileName(
self, 'Save file', '',
'HTML (*.html, *htm); Text documents (*.txt)')
if file_name:
text = self.ui.main_text.toHtml() if os.path.splitext(file_name)[1] in ['.html', '.htm'] \
else self.ui.main_text.toPlainText()
try:
with open(file_name, 'w') as f:
f.write(text)
except UnicodeEncodeError:
return
def open(self):
file_name = QFileDialog.getOpenFileName(self, 'Open File')[0]
if file_name != '':
with open(file_name, 'r') as file:
self.ui.main_text.setText(file.read())
def print_file(self):
printer = QPrinter(QPrinter.HighResolution)
dialog = QPrintDialog(printer, self)
if dialog.exec_() == QPrintDialog.Accepted:
self.ui.main_text.print_(printer)
def print_preview(self):
printer = QPrinter(QPrinter.HighResolution)
preview_dialog = QPrintPreviewDialog(printer, self)
preview_dialog.paintRequested.connect(
lambda: self.ui.main_text.print_(printer))
preview_dialog.exec_()
def export_pdf(self):
fn, _ = QFileDialog.getSaveFileName(self, 'Export to PDF', '',
'PDF files (.pdf) ;; All Files')
if fn != '':
if QFileInfo(fn).suffix() == '':
fn += '.pdf'
printer = QPrinter(QPrinter.HighResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fn)
self.ui.main_text.document().print_(printer)
class DPR(QtWidgets.QMainWindow):
def __init__(self, parent=None):
# call the parent class's constructor
QtWidgets.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.pushButton_1.clicked.connect(self.select_file)
self.ui.pushButton_2.clicked.connect(self.run_datapoints)
self.ui.dateEdit_1.setDateTime(QtCore.QDateTime.currentDateTime())
self.ui.dateEdit_2.setDateTime(QtCore.QDateTime.currentDateTime())
self.ui.dateEdit_1.dateChanged.connect(self.update_date)
self.ui.radioButton_1.setChecked(True)
self.ui.radioButton_4.setChecked(True)
self.ui.pushButton_3.clicked.connect(self.run_regression)
self.ui.lineEdit_3.setText("5")
self.ui.lineEdit_4.setText("10")
self.ui.pushButton_4.clicked.connect(self.write_excel)
self.ui.graphicsView_1.hide()
self.ui.graphicsView_2.hide()
self.MessageBox = ctypes.windll.user32.MessageBoxW
# after first date edit is changed, update second date edit to be a year later
def update_date(self):
get_date = self.ui.dateEdit_1.date().toString("yyyy-M-d")
new_datetime = pd.to_datetime(get_date) + relativedelta(months=+12)
change_datetime = QtCore.QDateTime.fromString(str(new_datetime),
"yyyy-M-d hh:mm:ss")
self.ui.dateEdit_2.setDateTime(change_datetime)
# check if file is selected
def select_file(self):
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
None, "Select File", "", "Text Files (*.txt)")
if filename:
# outputs
self.ui.lineEdit_1.setText(filename)
self.filename = filename
def run_datapoints(self):
delimiter = str(self.ui.comboBox_1.currentText())
has_headers = self.ui.checkBox_1.isChecked()
if self.ui.lineEdit_1.text() == "":
self.MessageBox(None, "No file selected.", "File Error", 0)
return
try:
data = self.prepare_data(delimiter, has_headers)
except pd.errors.EmptyDataError:
self.MessageBox(None, "No data in file.", "Empty Data Error", 0)
return
if data is 0:
self.MessageBox(None,
"Problem reading file. Check header declaration.",
"Attribute Error", 0)
return
elif data is 1:
self.MessageBox(None, "Column 1 should be date type.",
"Attribute Error", 0)
return
elif data is 2:
self.MessageBox(None, "Column 2 should be date type.",
"Attribute Error", 0)
return
elif data is 3:
self.MessageBox(None, "Column 3 should be currency.",
"Attribute Error", 0)
return
# disable calculate button
self.ui.pushButton_2.setEnabled(False)
start_date = pd.to_datetime(
self.ui.dateEdit_1.date().toString("M/d/yyyy"))
end_date = pd.to_datetime(
self.ui.dateEdit_2.date().toString("M/d/yyyy"))
pb_inc = (
end_date - start_date
).days + 36 #number of items in the 2 loops in datapoints fxs
if self.ui.radioButton_1.isChecked():
option = "option1"
elif self.ui.radioButton_2.isChecked():
option = "option2"
else:
option = "option3"
self.worker_thread = DataPointsWorkThread(data, start_date, end_date,
pb_inc, option)
self.worker_thread.signal.connect(self.display_datapoints)
self.worker_thread.signal_pb.connect(self.update_progressbar)
self.worker_thread.start()
def update_progressbar(self, pb_update):
self.ui.progressBar_1.setValue(pb_update)
# construct raw data dataframe from file data
def prepare_data(self, delimiter, has_headers):
if delimiter == "Tab Delimited":
sep = "\t"
elif delimiter == 'Comma Delimited':
sep = ","
elif delimiter == 'Pipe Delimited':
sep = "|"
if has_headers: # data file has headers
try:
data = pd.read_csv(self.filename,
skiprows=1,
sep=sep,
header=None)
except AttributeError:
return 0
else: # data file does not have headers
try:
data = pd.read_csv(self.filename, sep=sep, header=None)
except AttributeError:
return 0
data.columns = ["a", "b", "c"]
try:
data['a'] = pd.to_datetime(data['a'])
except ValueError:
return 1
try:
data['b'] = pd.to_datetime(data['b'])
except ValueError:
return 2
try:
data['c'] = data['c'].replace('[\$,]', '',
regex=True).astype(float)
except ValueError:
return 3
return data
# display dataframe with more specific headers
def display_datapoints(self, dp_output):
self.df = dp_output["df"]
self.x = dp_output["x"]
self.y = dp_output["y"]
self.DOI = dp_output["DOI"]
self.DOI_dollars = dp_output["DOI_dollars"]
df = self.df
x = self.x
y = self.y
DOI = self.DOI
DOI_dollars = self.DOI_dollars
# update progress bar
self.ui.progressBar_1.setValue(100)
# graph plot
self.ui.graphicsView_1.canvas.ax.clear() # clear if already drawn
self.ui.graphicsView_1.canvas.ax.plot(x, y, '-', color="orange")
self.ui.graphicsView_1.canvas.ax.set_xlabel('Time', fontsize=8.0)
self.ui.graphicsView_1.canvas.ax.set_ylabel('Sum', fontsize=8.0)
self.ui.graphicsView_1.canvas.draw() # needed for the first drawing
for ytick in self.ui.graphicsView_1.canvas.ax.get_yticklabels():
ytick.set_fontsize(8.0)
for xtick in self.ui.graphicsView_1.canvas.ax.get_xticklabels():
xtick.set_fontsize(8.0)
fmt = '${x:,.0f}'
tick = mtick.StrMethodFormatter(fmt)
self.ui.graphicsView_1.canvas.ax.yaxis.set_major_formatter(tick)
self.ui.graphicsView_1.canvas.draw() # needed for updated figures
self.ui.graphicsView_1.show()
self.ui.lineEdit_2.setText(DOI)
self.ui.lineEdit.setText(DOI_dollars)
# enable calculate button
self.ui.pushButton_2.setEnabled(True)
# table
df.columns = ["Date Range Start", "Date Range End", "Sum"]
model = PandasModel(df)
self.ui.tableView_1.setModel(model)
def run_regression(self):
x = self.x
y = self.y
try:
df = self.df
except AttributeError:
self.MessageBox(None, "No datapoints have been calculated.",
"Attribute Error", 0)
return
max_segments = int(self.ui.lineEdit_3.text())
max_iter = int(self.ui.lineEdit_4.text())
isnt_discretized = self.ui.radioButton_4.isChecked()
# disable calculate button
self.ui.pushButton_3.setEnabled(False)
self.ui.progressBar_2.setRange(0, 0)
self.worker_thread = RegressionWorkThread(x, y, df, max_segments,
max_iter, isnt_discretized)
self.worker_thread.signal.connect(self.display_regression)
self.worker_thread.start()
def display_regression(self, regression_output):
# instance variables for excel output
self.df_output = regression_output["df"]
self.df_regress_stats = regression_output["df_regress_stats"]
self.df_anova = regression_output["df_anova"]
self.df_coef = regression_output["df_coef"]
self.plt = regression_output["plt"]
# update progress bar
self.ui.progressBar_2.setRange(0, 100)
self.ui.progressBar_2.setValue(100)
# graph plot
self.ui.graphicsView_2.canvas.ax.clear() # clear if already drawn
self.ui.graphicsView_2.canvas.ax.plot(regression_output["x"],
regression_output["y"],
'-',
color="orange")
self.ui.graphicsView_2.canvas.ax.plot(regression_output["xHat"],
regression_output["yHat"],
'--',
color="royalblue")
self.ui.graphicsView_2.canvas.ax.set_xlabel('Time', fontsize=8.0)
self.ui.graphicsView_2.canvas.ax.set_ylabel('Sum', fontsize=8.0)
self.ui.graphicsView_2.canvas.draw()
for ytick in self.ui.graphicsView_2.canvas.ax.get_yticklabels():
ytick.set_fontsize(8.0)
for xtick in self.ui.graphicsView_2.canvas.ax.get_xticklabels():
xtick.set_fontsize(8.0)
fmt = '${x:,.0f}'
tick = mtick.StrMethodFormatter(fmt)
self.ui.graphicsView_2.canvas.ax.yaxis.set_major_formatter(tick)
self.ui.graphicsView_2.canvas.draw()
self.ui.graphicsView_2.show()
# provide number of segments from model
self.ui.lineEdit_5.setText(regression_output["num_segments"])
# provide function value from model
self.ui.lineEdit_6.setText(regression_output["func_value"])
# display regression statistics
model_regress_stats = PandasModel(
regression_output["df_regress_stats"])
self.ui.tableView_2.setModel(model_regress_stats)
# display ANOVA statistics
model_anova = PandasModel(regression_output["df_anova"])
self.ui.tableView_3.setModel(model_anova)
# display coefficients table
model_coef = PandasModel(regression_output["df_coef"])
self.ui.tableView_4.setModel(model_coef)
# enable calculate button
self.ui.pushButton_3.setEnabled(True)
def write_excel(self):
try:
df_output = self.df_output
except AttributeError:
self.MessageBox(None, "No datapoints have been calculated.",
"Attribute Error", 0)
return
df_regress_stats = self.df_regress_stats
df_anova = self.df_anova
df_coef = self.df_coef
plt = self.plt
# prompt for save file path and name, default is desktop
desktop = os.path.join(os.path.join(os.path.expanduser('~')),
'Desktop')
fileout, _ = QtWidgets.QFileDialog.getSaveFileName(
None, "Save File", desktop, "Excel File (*xlsx)")
if fileout:
# append .xlsx to file name
if fileout.endswith(".xlsx"):
fileout = fileout
else:
fileout += ".xlsx"
# split path into basepath and file name
head, tail = os.path.split(fileout)
# save figure to be overwritten each iteration in project folder
plt.savefig("myplot.png", dpi=100)
# rename column headers
df_output = df_output.rename(index=str,
columns={
"C": "Sum",
"col4": "Estimate (y-prediction)"
})
# write dataframes to an input excel file to be overwritten each iteration in project folder
num_columns = len(df_output.columns)
writer = pd.ExcelWriter('input.xlsx', engine='xlsxwriter')
df_output.to_excel(writer, sheet_name='Sheet1', index=False)
df_regress_stats.to_excel(writer,
sheet_name='Sheet1',
startrow=30,
startcol=num_columns + 1,
index=False)
df_anova.to_excel(writer,
sheet_name="Sheet1",
startrow=38,
startcol=num_columns + 1,
index=False)
df_coef.to_excel(writer,
sheet_name='Sheet1',
startrow=43,
startcol=num_columns + 1,
index=False)
writer.save()
# open input excel file, do formatting, add plot, save file as output
wb = openpyxl.load_workbook("input.xlsx")
ws = wb.active
ws.merge_cells('A1:B1')
ws.cell(row=1, column=1).value = "Service Date Range"
img = openpyxl.drawing.image.Image("myplot.png")
ws.add_image(img, 'M1')
wb.save(fileout)
wb.close()
class ApplicationWindow(QtWidgets.QMainWindow):
def __init__(self):
super(ApplicationWindow, self).__init__()
pg.setConfigOption('background', '042629')
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.InputViewerArray = [
self.ui.ImageOneview, self.ui.ImageTwoView,
self.ui.ImageOneComponent, self.ui.ImageTwoComponent,
self.ui.ModifiedOne, self.ui.ModifiefTwo
]
for i in range(len(self.ui.InputViewerArray)):
self.ui.InputViewerArray[i].getPlotItem().hideAxis('left')
self.ui.InputViewerArray[i].getPlotItem().hideAxis('bottom')
self.ImageOneChoice = True
self.ImageObject = [0, 0]
self.ImageDrawArray = [0, 0]
self.ImageArray = [0, 0]
self.FilePathArray = [0, 0]
self.ui.ComponentOneChoice.currentTextChanged.connect(self.ComboValues)
self.ui.Browser.clicked.connect(self.Browse)
self.ui.DrawComboArray = [
self.ui.ImageOneViewChoice, self.ui.ImageTwoViewChoice
]
self.ui.SlidersArray = [self.ui.MixerSliderOne, self.ui.MixerSliderTwo]
self.ui.TextArray = [self.ui.SliderOneValue, self.ui.SliderTwoValue]
self.ui.ImageOneViewChoice.currentTextChanged.connect(
lambda: self.Draw(0, 0, 0, 2, None))
self.ui.ImageTwoViewChoice.currentTextChanged.connect(
lambda: self.Draw(1, 1, 0, 3, None))
self.ui.MixerSliderOne.valueChanged.connect(
lambda: self.SlidersValue(0))
self.ui.MixerSliderTwo.valueChanged.connect(
lambda: self.SlidersValue(1))
for i in range(2):
self.ui.ImageMixerOneChoice.model().item(i + 1).setEnabled(False)
self.ui.ImageMixerTwoChoice.model().item(i + 1).setEnabled(False)
#-------------------------------------------------ApplicationWindow--------------------------------------------------------------
#-------------------------------------------------Browse------------------------------------------------------------------------
def Browse(self):
#Image Loading
filePaths = QtWidgets.QFileDialog.getOpenFileNames(
self, 'Choose image file', "~/Desktop", "*.jpg")
for filePath in filePaths:
for f in filePath:
if f == '*' or f == None:
break
if self.ImageOneChoice == True:
i = 0
elif self.ImageOneChoice == False:
i = 1
self.ImageOneChoice = True
self.ImageObject = ImageModel(f)
self.FilePathArray[i] = f
# Size Checking and Image Analysis
try:
if i == 1:
Check = self.ImageArray[0].EqualSizeCheck(self.ImageObject)
if Check == True:
self.ui.WarningTabOne.setText(
"Error: The 2 Images Must Be Same Size- Reload Image 2 Again"
)
self.ImageOneChoice = False
else:
self.ImageArray[i] = self.ImageObject
self.ui.WarningTabOne.setText(
"Perfection! Images loaded Successfully,Now You can View any componet you want"
)
logging.info(
'User Loaded similar sized Images Successfully and ready to proceed'
)
self.ImageDrawArray[i] = pg.ImageItem(
np.asarray(Image.open(f)))
self.ImageDrawArray[i].rotate(270)
self.ui.InputViewerArray[i].addItem(
self.ImageDrawArray[i])
self.ImageOneChoice = False
self.ui.ImageMixerOneChoice.model().item(2).setEnabled(
True)
self.ui.ImageMixerTwoChoice.model().item(2).setEnabled(
True)
elif i == 0:
self.ImageArray[i] = self.ImageObject
self.ui.WarningTabOne.setText(
"Great image one is loaded Successfully")
self.ImageDrawArray[i] = pg.ImageItem(
np.asarray(Image.open(f)))
self.ImageDrawArray[i].rotate(270)
self.ui.InputViewerArray[i].addItem(self.ImageDrawArray[i])
self.ImageOneChoice = False
self.ui.ImageMixerOneChoice.model().item(1).setEnabled(
True)
self.ui.ImageMixerTwoChoice.model().item(1).setEnabled(
True)
except:
logging.info(
'Somthing Went Wrong with Size Checking, Check if you loaded to images first!'
)
#Image Drawing
#-------------------------------------------------Browse------------------------------------------------------------------------
#-------------------------------------------------Draw------------------------------------------------------------------------
def Draw(self, ImageChoice, ComboChoice, DrawingOption, GraphChoice, img):
try:
if DrawingOption == 0:
check = self.ui.DrawComboArray[ComboChoice].currentText()
if check == "Phase":
Drawable = pg.ImageItem(self.ImageArray[ImageChoice].phase)
elif check == "Mag":
Drawable = pg.ImageItem(
self.ImageArray[ImageChoice].magnitude)
elif check == "Img":
Drawable = pg.ImageItem(
self.ImageArray[ImageChoice].imaginary)
elif check == "Real":
Drawable = pg.ImageItem(self.ImageArray[ImageChoice].real)
self.ui.InputViewerArray[GraphChoice].addItem(Drawable)
logging.info('Drawing has been done Successfully')
elif DrawingOption == 1:
Drawable = pg.ImageItem(img)
Drawable.rotate(270)
if GraphChoice == 0:
self.ui.ModifiedOne.addItem(Drawable)
logging.info(
'Hooraayy- Output one has been mixed Successfully ')
self.ui.WarningTabTwo.setText(
"Perfection! Output one has been Generated Successfully"
)
elif GraphChoice == 1:
self.ui.ModifiefTwo.addItem(Drawable)
logging.info(
'Hooraayy- Output two has been mixed Successfully ')
self.ui.WarningTabTwo.setText(
"Perfection! Output two has been Generated Successfully"
)
except:
logging.info(
'Somthing went wrong with drawing your image object- it may be broken :( '
)
self.ui.WarningTabTwo.setText(
"Somthing went wrong with drawing your image object- it may be broken :("
)
#-------------------------------------------------Draw------------------------------------------------------------------------
#-------------------------------------------------SlidersValue----------------------------------------------------------------
def SlidersValue(self, componentChoosen):
try:
self.ui.TextArray[componentChoosen].setText(
str(self.ui.SlidersArray[componentChoosen].value()))
ModeIndex = "NULL" # Set To Nothing Until Both componets are choosen
CallerIndix = 0 #By default
Picture = self.ui.ImageMixerOneChoice.currentText()
if Picture == "ImageOne":
PicIndix = 0
elif Picture == "ImageTwo":
PicIndix = 1
CallerObj = self.ui.ImageMixerTwoChoice.currentText()
if CallerObj == "ImageOne":
CallerIndix = 0
elif CallerObj == "ImageTwo":
CallerIndix = 1
componentOne = self.ui.ComponentOneChoice.currentText()
componentTwo = self.ui.ComponentTwoChocie.currentText()
if componentOne == "Mag" or componentOne == "UniMag":
ModeIndex = Modes.magnitudeAndPhase
Mag_Real_Indix = 0
Phase_Imag_Indox = 1
elif componentOne == "Phase" or componentOne == "UniPhase":
ModeIndex = Modes.magnitudeAndPhase
Mag_Real_Indix = 1
Phase_Imag_Indox = 0
elif componentOne == "Real":
ModeIndex = Modes.realAndImaginary
Mag_Real_Indix = 0
Phase_Imag_Indox = 1
elif componentOne == "Imag":
ModeIndex = Modes.realAndImaginary
Mag_Real_Indix = 1
Phase_Imag_Indox = 0
(Mag_Real_Ratio) = float(
self.ui.SlidersArray[Mag_Real_Indix].value()) / 100
(Phase_Imag_Ratio) = float(
self.ui.SlidersArray[Phase_Imag_Indox].value()) / 100
OutPutCheck = self.ui.OutputChoice.currentText()
TempImage = ImageModel((self.FilePathArray[0]))
TempCaller = ImageModel((self.FilePathArray[1]))
if OutPutCheck == "OutPutOne":
if componentOne == "UniMag" or componentTwo == "UniMag":
TempImage.magnitude = np.ones(
self.ImageArray[PicIndix].magnitude.shape)
TempCaller.magnitude = np.ones(
self.ImageArray[CallerIndix].magnitude.shape)
if componentOne == "UniPhase" or componentTwo == "UniPhase":
TempImage.phase = np.zeros(
self.ImageArray[PicIndix].phase.shape)
TempCaller.phase = np.zeros(
self.ImageArray[CallerIndix].phase.shape)
if componentOne == "UniMag" or componentTwo == "UniMag" or componentOne == "UniPhase" or componentTwo == "UniPhase":
OutputImageOne = TempCaller.mix(TempImage, Mag_Real_Ratio,
Phase_Imag_Ratio,
ModeIndex)
else:
OutputImageOne = self.ImageArray[CallerIndix].mix(
self.ImageArray[PicIndix], Mag_Real_Ratio,
Phase_Imag_Ratio, ModeIndex)
logging.info(
'Output one generated and ready to be sent to drawing function!'
)
self.Draw(0, 0, 1, 0, OutputImageOne)
elif OutPutCheck == "OutputTwo":
if componentOne == "UniMag" or componentTwo == "UniMag":
TempImage.magnitude = np.ones(
self.ImageArray[PicIndix].magnitude.shape)
TempCaller.magnitude = np.ones(
self.ImageArray[CallerIndix].magnitude.shape)
if componentOne == "UniPhase" or componentTwo == "UniPhase":
TempImage.phase = np.zeros(
self.ImageArray[PicIndix].phase.shape)
TempCaller.phase = np.zeros(
self.ImageArray[CallerIndix].phase.shape)
if componentOne == "UniMag" or componentTwo == "UniMag" or componentOne == "UniPhase" or componentTwo == "UniPhase":
OutputImageOne = TempCaller.mix(TempImage, Mag_Real_Ratio,
Phase_Imag_Ratio,
ModeIndex)
else:
OutputImageOne = self.ImageArray[CallerIndix].mix(
self.ImageArray[PicIndix], Mag_Real_Ratio,
Phase_Imag_Ratio, ModeIndex)
logging.info(
'Output two generated and ready to be sent to drawing function!'
)
self.Draw(0, 0, 1, 1, OutputImageOne)
except:
logging.info(
'Somthing went wrong with slider values function or mixer')
#-------------------------------------------------SlidersValue----------------------------------------------------------------
#-------------------------------------------------Combo Values----------------------------------------------------------------
def ComboValues(self):
self.ui.ComponentTwoChocie.setCurrentIndex(0)
for i in range(7):
self.ui.ComponentTwoChocie.model().item(i).setEnabled(False)
componentOne = self.ui.ComponentOneChoice.currentText()
if componentOne == "Mag" or componentOne == "UniMag":
self.ui.ComponentTwoChocie.model().item(2).setEnabled(True)
self.ui.ComponentTwoChocie.model().item(6).setEnabled(True)
logging.info(
'Mag or Uni mag is choosen for component one and enabling only phase or uni phase for component two'
)
elif componentOne == "Phase" or componentOne == "UniPhase":
self.ui.ComponentTwoChocie.model().item(1).setEnabled(True)
self.ui.ComponentTwoChocie.model().item(5).setEnabled(True)
logging.info(
'Phase or Uni Phase is choosen for component one and enabling only Mag or uni Mag for component two'
)
elif componentOne == "Real":
self.ui.ComponentTwoChocie.model().item(4).setEnabled(True)
logging.info(
'Real is choosen for component one and enabling only Imaginary for component two'
)
elif componentOne == "Imag":
logging.info(
'Imaginary is choosen for component one and enabling only Real for component two'
)
self.ui.ComponentTwoChocie.model().item(3).setEnabled(True)
class MainApp:
def __init__(self):
self.img_path = None
self.privKey = None
self.pubKey = None
self.curve = None
self.init_ui()
def init_ui(self):
self.app = QtWidgets.QApplication(sys.argv)
self.MainWindow = QtWidgets.QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.MainWindow)
def init_listeners(self):
self.ui.pushButtonUploadPlain.clicked.connect(self.upload_plain_image)
self.ui.pushButtonUploadEnc.clicked.connect(self.upload_enc_image)
self.ui.pushButtonEncrypt.clicked.connect(self.encrypt_file)
self.ui.pushButtonDecrypt.clicked.connect(self.decrypt_file)
def upload_plain_image(self):
dlg = QFileDialog()
if dlg.exec_():
path = dlg.selectedFiles()[0]
self.img_path = path
self.ui.lineEditPlainImgPath.setText(path)
image = Image.open(path)
image.show()
def upload_enc_image(self):
dlg = QFileDialog()
if dlg.exec_():
path = dlg.selectedFiles()[0]
self.img_path = path
self.ui.lineEditEncImgPath.setText(path)
def init_curve(self):
self.curve = registry.get_curve('brainpoolP256r1')
if os.path.exists(KEY_FILE):
key_file = open(KEY_FILE, 'rb')
keys = pickle.load(key_file)
self.pubKey = keys[0]
self.privKey = keys[1]
else:
self.privKey = secrets.randbelow(self.curve.field.n)
self.pubKey = self.privKey * self.curve.g
keys = [self.pubKey, self.privKey]
key_file = open(KEY_FILE, 'wb')
pickle.dump(keys, key_file)
def encrypt_file(self):
if self.img_path:
with open(self.img_path, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
self.init_curve()
encryptedMsg = SafeEC.encrypt_ECC(self.curve, encoded_string,
self.pubKey)
enc_file = open('encrypted.dat', 'wb')
pickle.dump(encryptedMsg, enc_file)
self.show_message("Encrypted")
file_name = os.path.basename(self.img_path)
s_mail = self.ui.lineEditUsername.text()
s_pwd = self.ui.lineEditPassword.text()
r_mail = self.ui.lineEditMail.text()
mail(r_mail, file_name, s_mail, s_pwd)
else:
self.show_error("No file selected!")
def decrypt_file(self):
if self.img_path:
with open(self.img_path, "rb") as image_file:
# unpickler = pickle.Unpickler(image_file)
# encryptedMsg = unpickler.load()
encryptedMsg = pickle.load(image_file)
self.init_curve()
decryptedMsg = SafeEC.decrypt_ECC(encryptedMsg, self.privKey)
dec_file = open(DEC_FILE, 'wb')
dec_file.write(base64.b64decode(decryptedMsg))
dec_file.flush()
dec_file.close()
image = Image.open(DEC_FILE)
image.show()
self.show_error("Decrypted")
else:
self.show_error("No file selected!")
def show_error(self, msg):
print(msg)
error_dialog = QtWidgets.QErrorMessage()
error_dialog.showMessage(msg)
def show_message(self, msg):
print(msg)
error_dialog = QtWidgets.QErrorMessage()
error_dialog.showMessage(msg)
def start(self):
self.ui.setupUi(self.MainWindow)
self.init_listeners()
self.MainWindow.show()
sys.exit(self.app.exec_())
class ApplicationWindow(QtWidgets.QMainWindow):
def __init__(self):
super(ApplicationWindow,self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.actionOpen_Image.triggered.connect(self.OpenImage)
self.ui.Combo1.currentTextChanged.connect(self.ChooseOperation)
self.ui.comboBox.currentTextChanged.connect(self.Gradients)
self.ui.Combo1.setCurrentIndex(0)
self.widgets = [self.ui.InputImage1,self.ui.FourierInput1]
for i in range(len(self.widgets)):
self.widgets[i].ui.histogram.hide()
self.widgets[i].ui.roiBtn.hide()
self.widgets[i].ui.menuBtn.hide()
self.widgets[i].ui.roiPlot.hide()
self.pen1 = pg.mkPen(color=(255, 0, 0))
self.pen2 = pg.mkPen(color=(0, 0, 255))
self.ui.pushButton.clicked.connect(self.ShowGraph)
def ShowGraph (self):
np.random.seed(42)
rand_Bz = np.random.randint(-3,4,20)
const_Bx = [0]*20
const_By = [0]*20
const_Bz = [2]*20
nonUn_Bz = rand_Bz + const_Bz
self.ui.withx.clear()
self.ui.withy.clear()
self.ui.withz.clear()
self.ui.withz.plotItem.plot(nonUn_Bz,pen=self.pen1)
self.ui.withz.setLabel('left', 'B', units='Tesla')
self.ui.withz.setLabel('bottom', 'Z-axis')
self.ui.withx.plotItem.plot(const_Bx,pen=self.pen2)
self.ui.withx.setLabel('left', 'B', units='Tesla')
self.ui.withx.setLabel('bottom', 'X-axis')
self.ui.withy.plotItem.plot(const_By,pen=self.pen2)
self.ui.withy.setLabel('left', 'B', units='Tesla')
self.ui.withy.setLabel('bottom', 'Y-axis')
def Gradients (self):
var = np.arange(-1,1,0.1)
if (str(self.ui.comboBox.currentText())) == 'Gradient Effect':
print('Choose prope Gradient Coil')
elif (str(self.ui.comboBox.currentText())) == 'Slice Selection':
const_Bx = [0]*20
const_BxG = const_Bx + var
self.ui.withx.clear()
self.ui.withx.plotItem.plot(const_BxG,pen=self.pen2)
elif (str(self.ui.comboBox.currentText())) == 'Phase Encoding':
const_By = [0]*20
const_ByG = const_By + var
self.ui.withy.clear()
self.ui.withy.plotItem.plot(const_ByG,pen=self.pen2)
elif (str(self.ui.comboBox.currentText())) == 'Frequency Encoding':
const_Bz = [2]*20
rand_Bz = np.random.randint(-3,4,20)
nonUn_Bz = rand_Bz + const_Bz
const_BzG = nonUn_Bz + var
self.ui.withz.clear()
self.ui.withz.plotItem.plot(const_BzG,pen=self.pen1)
def OpenImage(self):
self.filePath = QtWidgets.QFileDialog.getOpenFileName(None, 'Open file', 'F:\25-9\Downloads\talta tebya\Second Semester\DSP\Task2 Equalizer\TASK 2')
self.image = cv.cvtColor(cv.imread(self.filePath[0]),cv.COLOR_BGR2GRAY)
self.ui.InputImage1.show()
self.ui.InputImage1.setImage(self.image.T)
self.dft = np.fft.fft2(self.image)
self.real = np.real(self.dft)
self.imaginary = np.imag(self.dft)
self.magnitude = np.abs(self.dft)
self.phase = np.angle(self.dft)
def ChooseOperation(self):
if (str(self.ui.Combo1.currentText())) == 'FT Magnitude':
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(np.fft.fftshift(20 * np.log(self.magnitude.T)))
elif (str(self.ui.Combo1.currentText())) == 'FT Phase':
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(self.phase.T)
elif (str(self.ui.Combo1.currentText())) == 'FT Real Component':
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(20 * np.log(self.real.T))
elif (str(self.ui.Combo1.currentText())) == 'FT Imaginary Component':
self.ui.FourierInput1.show()
self.ui.FourierInput1.setImage(self.imaginary.T)
if (str(self.ui.Combo1.currentText())) == 'Select an Option':
print('Please select a proper option')
class MyWindowClass(QMainWindow):
def __init__(self, parent=None):
super(self.__class__, self).__init__()
self.car = None
self.rps_counter = None
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.forwardBtn.clicked.connect(self.forward_clicked)
self.ui.backBtn.clicked.connect(self.backward_clicked)
self.ui.leftBtn.clicked.connect(self.left_clicked)
self.ui.rightBtn.clicked.connect(self.right_clicked)
self.ui.stopBtn.clicked.connect(self.stop_clicked)
self.ui.startButton.clicked.connect(self.start_clicked)
self.ui.actionOpen_Writer.triggered.connect(self.open_writer)
self.ui.actionExit.triggered.connect(self.exit)
self.ui.actionAbout.triggered.connect(self.about)
self.img_left = self.ui.img_left
self.img_right = self.ui.img_right
self.img_center = self.ui.img_center
self.camera_label = {
'camera_r': self.img_left,
'camera_c': self.img_center,
'camera_l': self.img_right
}
self.sensor_label = {
'left': self.ui.sensor_left,
'center': self.ui.sensor_center,
'right': self.ui.sensor_right
}
self.add_log("DrivingMatter GUI Started.")
self.show_image()
def open_writer(self):
self.add_log("OpenWriter called")
self.writer = Writer(self.car)
self.writer.setWindowTitle('Driving Matter - Writer')
self.writer.show()
def exit(self):
self.add_log("Exit called")
def about(self):
self.add_log("About called")
def add_log(self, message):
from datetime import datetime
message = str(
datetime.now().strftime('%Y-%m-%d %H:%M:%S')) + ": " + message
self.ui.logdata.appendPlainText(message)
#scroll log textedit to bottom
self.ui.logdata.verticalScrollBar().setValue(
self.ui.logdata.verticalScrollBar().maximum())
def load_car(self):
ip, okPressed = QInputDialog.getText(self, "Car IP Address",
"Enter IP Address",
QLineEdit.Normal, "192.168.137.2")
if okPressed:
try:
socket.inet_aton(ip) # throw exception in invalid ip
car_link = "ws://{}:{}".format(ip, "8000")
action_link = "{}/action".format(car_link)
state_link = "{}/state".format(car_link)
self.add_log("Action Link: " + action_link)
self.add_log("State Link: " + state_link)
self.car = Car(action_link, url_state=state_link)
self.rps_counter = RPSCounter()
self.car.set_state_callback(self._handle_dataset_response)
self.ui.startButton.setText('Started')
except socket.error:
pass # leave the condition
else:
self.ui.startButton.setText('Start')
self.ui.startButton.setEnabled(False)
def stop_clicked(self):
self.car.stop()
def backward_clicked(self):
self.add_log("Car::backward()")
self.car.backward()
def right_clicked(self):
self.add_log("Car::right()")
self.car.forwardRight()
def left_clicked(self):
self.add_log("Car::left()")
self.car.forwardLeft()
def forward_clicked(self):
self.add_log("Car::forward()")
self.car.forward()
def start_clicked(self):
global running
running = True
self.ui.startButton.setEnabled(False)
self.ui.startButton.setText('Starting...')
self.load_car()
def show_image(self):
qim = QtGui.QImage("../images/no-image.png") # PNG only
qim = qim.scaled(200,
200,
aspectRatioMode=QtCore.Qt.KeepAspectRatio,
transformMode=QtCore.Qt.SmoothTransformation)
self.ui.img_left.setPixmap(QtGui.QPixmap.fromImage(qim))
self.ui.img_right.setPixmap(QtGui.QPixmap.fromImage(qim))
self.ui.img_center.setPixmap(QtGui.QPixmap.fromImage(qim))
self.ui.img_left.adjustSize()
self.add_log("Showing default images.")
def _handle_dataset_response(self, data, ws):
current_datavector = json.loads(data)
pc_rps = self.rps_counter.get()
#logger.debug("PC RPS: " + str(pc_rps) + "\n\nCar RPS: " + str(car_rps) + "\n\nTotal: " + str(total_requests))
sensors = current_datavector['sensors']
for key, value in sensors.items():
self.sensor_label[key].setText(str(value))
if value:
self.sensor_label[key].setStyleSheet('color: red')
else:
self.sensor_label[key].setStyleSheet('color: green')
camera_names = [
key for key in current_datavector if key.startswith('camera')
]
for name in camera_names:
frame_data = current_datavector[name] # [type, array, shape]
frame = BytesIO(base64.decodestring(frame_data.encode("utf-8")))
frame = np.asarray(Image.open(frame))
qim = QtGui.QImage(
frame.data, frame.shape[1], frame.shape[0], frame.strides[0],
QImage.Format_RGB888) # https://gist.github.com/smex/5287589
qim = qim.scaled(200,
200,
aspectRatioMode=QtCore.Qt.KeepAspectRatio,
transformMode=QtCore.Qt.SmoothTransformation)
self.camera_label[name].setPixmap(QtGui.QPixmap.fromImage(qim))
self.camera_label[name].adjustSize()
self.add_log("Received dataset. RPS: " + str(int(pc_rps)))
class ApplicationWindow(QtWidgets.QMainWindow):
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
#intialize memebers of class plot_data that contains all the functions
#and the variables needed for plotting to avoid repeativness
self.Ugraph_1 = Plot_Data()
#Empty arrays used in singular-import function
self.Empty_X = []
self.Empty_Y = []
#Toggles for the exception handling of pressing start button and crashing before any graph is drawn, used in import
self.HasEntered1stView = 0
pg.setConfigOption('background', 'w')
self.ui.setupUi(self)
self.ui.StartButton.clicked.connect(self.Startplot)
self.ui.StopButton.clicked.connect(self.Stop_1)
self.ui.HideButton.clicked.connect(self.Hide)
self.ui.ExitButton.clicked.connect(self.Exit)
self.ui.EmptyButton.clicked.connect(self.Empty)
def Plot_1(self):
if self.Ugraph_1.Plot_Stop == 1 and self.HasEntered1stView == 1:
self.Ugraph_1.Start()
self.Startplot()
elif self.HasEntered1stView == 1:
self.Ugraph_1.Start()
def Stop_1(self):
self.Ugraph_1.Stop()
def Graph1(self):
#print(self.Ugraph_1.data_Y)
#(self.Ugraph_1.data_X)
self.ui.GraphicsView.plot(self.Ugraph_1.data_X,
self.Ugraph_1.data_Y,
pen='r')
if len(self.Ugraph_1.data_X) > 2:
self.ui.GraphicsView.setXRange(
self.Ugraph_1.data_X[-1] -
(self.Ugraph_1.data_X[1] - self.Ugraph_1.data_X[0]) * 100,
self.Ugraph_1.data_X[-1])
min_y = np.amin(self.Ugraph_1.data_Y)
max_y = np.amax(self.Ugraph_1.data_Y)
self.ui.GraphicsView.plotItem.getViewBox().setLimits(
xMin=self.Ugraph_1.data_X[0],
xMax=self.Ugraph_1.data_X[-1],
yMin=min_y - min_y * 0.1,
yMax=max_y + max_y * 0.1)
QtCore.QCoreApplication.processEvents()
#self.Ugraph_1.data_stop = self.Ugraph_1.data_stop + 10S
# if self.Ugraph_1.data_stop >= len(self.Ugraph_1.data_X):
# self.Ugraph_1.data_stop = 0
# self.Ugraph_1.Stop()
def Hide(self):
self.Ugraph_1.Stop()
self.ui.GraphicsView.clear()
def Empty(self):
self.Hide()
self.Ugraph_1.Empty()
self.HasEntered1stView = 0
self.Ugraph_1.GraphIsWav = 0
def Startplot(self):
self.Ugraph_1.Plot_Stop = 0
self.getdatafromserial()
def getdatafromserial(self):
threshold = 514.0
oldvalue = 0
newvalue = 0
reading123 = 0
oldmillis = 0
newmillis = 0
timings = [0] * 16
self.HasEntered1stView = 1
#insert ur COM here
ser = Serial('COM15')
ser.flushInput()
while self.Ugraph_1.Plot_Stop == 0:
try:
ser_bytes = ser.readline()
decoded_bytes = float(ser_bytes[0:len(ser_bytes) -
2].decode("utf-8"))
except:
print("Keyboard Interrupt")
break
oldvalue = newvalue
newvalue = 0
for i in range(16): # Average over 16 measurements
newvalue += decoded_bytes
newvalue = newvalue / 16
self.Ugraph_1.data_X.append(
reading123
) #self.Ugraph_1.data_X.append((time.strftime("%H:%M:%S", time.localtime()))) #np.append(self.Ugraph_1.data_X,((time.strftime("%H:%M:%S", time.localtime()))))
reading123 += 1
self.Ugraph_1.data_Y.append(
newvalue) #np.append(self.Ugraph_1.data_Y,newvalue)
self.Graph1()
# find triggering edge
if oldvalue < threshold and newvalue >= threshold:
oldmillis = newmillis
newmillis = time.time() * 1000
# fill in the current time difference a ringbuffer
timings.append((int)(newmillis - oldmillis))
if len(timings) > 16:
timings.pop(0) #filling queue of time differences
totalmillis = 0
# calculate average of the last 16 time differences
for i in range(16):
totalmillis += timings[i]
# calculate heart rate
heartrate = 60000 // (totalmillis / 16)
if heartrate > 40 and heartrate < 130:
print(heartrate)
else:
print("Measuring Heart rate")
QtCore.QCoreApplication.processEvents()
def Exit(self):
sys.exit()
from GUI import Ui_MainWindow
from PyQt5 import QtGui, QtWidgets
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
glFormat = QtGui.QSurfaceFormat()
ui = Ui_MainWindow()
ui.setupUi(glFormat, MainWindow)
MainWindow.show()
code = app.exec_()
sys.exit(code)
class StartQT4(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
##################Buttons#######################################################################
self.ui.pushButton.clicked.connect(self.calculate)
##################Buttons#######################################################################
def calculate(self):
Vnom = float(self.ui.lineEdit_1.text())
stallTorque = float(self.ui.lineEdit_2.text())
motor_ESR = float(self.ui.lineEdit_3.text())
NL_Curr = float(self.ui.lineEdit_4.text())
NL_RPM = float(self.ui.lineEdit_5.text())
spoolDiam = float(self.ui.lineEdit_6.text())
inputVolt = float(self.ui.lineEdit_7.text())
PWM_DC = float(self.ui.lineEdit_8.text())
batt_Ah = float(self.ui.lineEdit_9.text())
torque_load = float(self.ui.lineEdit_10.text())
gear_ratio = float(self.ui.lineEdit_21.text())
#v/rpm
bemf_const = (Vnom - (motor_ESR * NL_Curr)) / NL_RPM
#rpm/v (not sure which one to use)
motor_kv = 1 / bemf_const
motor_kv = NL_RPM / Vnom
effective_voltage = inputVolt * PWM_DC / 100.0
self.ui.lineEdit_13.setText(str(effective_voltage))
max_torque = stallTorque * effective_voltage / Vnom
self.ui.lineEdit_11.setText(str(max_torque * gear_ratio))
shaft_torque = max_torque * torque_load / 100.0
self.ui.lineEdit_12.setText(str(shaft_torque * gear_ratio))
#help! this need fixing
shaft_rpm = (motor_kv *
effective_voltage) - (NL_RPM / stallTorque) * shaft_torque
self.ui.lineEdit_19.setText(str(shaft_rpm / gear_ratio))
travel_speed = shaft_rpm * 60.0 * 2.0 * 3.14159265359 * spoolDiam / 1000.0
self.ui.lineEdit_20.setText(str(travel_speed / gear_ratio))
#current eqn
i_mot = (effective_voltage - (bemf_const * shaft_rpm)) / motor_ESR
self.ui.lineEdit_14.setText(str(i_mot))
power_in = effective_voltage * i_mot
self.ui.lineEdit_16.setText(str(power_in))
power_out = shaft_torque * shaft_rpm / 60.0 * 2.0 * 3.14159265359
self.ui.lineEdit_17.setText(str(power_out))
efficiency = power_out / power_in * 100
self.ui.lineEdit_18.setText(str(efficiency))
runtime_hour = (inputVolt * batt_Ah) / (effective_voltage * i_mot)
self.ui.lineEdit_15.setText(str(runtime_hour))
cable_stress = shaft_torque * gear_ratio / (spoolDiam / 2)
statmsg = "Cable stress = " + str(round(cable_stress,2)) + "N/m^2 # " + \
"Distance travelled/minute = " + str(round(travel_speed*1000.0/60.0/gear_ratio, 2)) + "m # " + \
"Cable Force = " + str(round(cable_stress/9.80665, 2)) + "kg # " + \
"Total distance travelled with the battery = " + str(round(travel_speed*runtime_hour/gear_ratio, 2)) + "km"
self.ui.statusbar.showMessage(statmsg)
from PyQt5 import QtCore, QtGui, QtWidgets
import sys
from GUI import Ui_MainWindow as UIM
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = UIM()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
class ApplicationWindow(QtWidgets.QMainWindow):
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(1500, 930)
############## UI control lists ##############
self.imageViews = [self.ui.graphicsView , self.ui.graphicsView_2 ]
self.legend = [0, 0, 0] # guard for legend overaddition
for image in self.imageViews : ## hide unwanted options
image.ui.histogram.hide()
image.ui.roiBtn.hide()
image.ui.menuBtn.hide()
image.ui.roiPlot.hide()
############# initialize fourier #############
self.originalImage0 = cv.cvtColor(cv.imread('images/Brain2.png'),cv.COLOR_BGR2GRAY)
#plot original
self.imageViews[0].show()
self.imageViews[0].setImage(self.originalImage0.T)
#plot fourier
self.imageViews[1].show()
self.imageViews[1].setImage(fourier(self.originalImage0).T)
####################################
#self.axes1 = self.ui.graphicsView1.figure.add_subplot(111, title="$M_x/M_o$ vs time")
#self.axes2 = self.ui.graphicsView2.figure.add_subplot(111)
#self.axes3 = self.ui.graphicsView3.figure.add_subplot(111)
############## UI Signals ##############
self.ui.pushButton.clicked.connect(lambda: self.plotEffect())
self.ui.pushButton_2.clicked.connect(lambda : self.plotFourier())
##########################################
def plotFourier(self) :
"""[summary] : plots : original image, it's fourier transform
"""
#Read the image file
fname = QtGui.QFileDialog.getOpenFileName( self, 'choose the image', os.getenv('HOME') ,"Images (*.png *.xpm *.jpg)" )
self.path = fname[0]
#Assertion for path errors
if self.path =="" :
return
#convert image to grey Scale
self.originalImage = cv.cvtColor(cv.imread(self.path),cv.COLOR_BGR2GRAY)
#plot original
self.imageViews[0].show()
self.imageViews[0].setImage(self.originalImage.T)
#plot fourier
self.imageViews[1].show()
self.imageViews[1].setImage(fourier(self.originalImage).T)
return None
def plotEffect(self):
print("Drawing curves")
B = 1.5
BPositive = 2.5
BNegative = 0.5
gyroRatio = 42
w = gyroRatio * B
wPositive = gyroRatio * BPositive
wNegative = gyroRatio * BNegative
T1 = 490/1000
T2 = 43/1000
t = np.arange(start=0, stop=10, step=0.0001)
omega = 2*np.pi*w*t
omegaPositive = 2*np.pi*wPositive*t + np.pi/8
omegaNegative = 2*np.pi*wNegative*t - np.pi/8
Mx = np.exp(-1*t/T2)*np.sin(omega)
MxPositive = np.exp(-1*t/T2)*np.sin(omegaPositive)
MxNegative = np.exp(-1*t/T2)*np.sin(omegaNegative)
My = np.exp(-1*t/T2)*np.cos(omega)
MyPositive = np.exp(-1*t/T2)*np.cos(omegaPositive)
MyNegative = np.exp(-1*t/T2)*np.cos(omegaNegative)
Mxy = np.sqrt(Mx**2 + My**2)
MxyPositive = np.sqrt(MxPositive**2 + MyPositive**2)
MxyNegative = np.sqrt(MxNegative**2 + MyNegative**2)
self.axes1 = self.ui.graphicsView1.figure.add_subplot(111, title="$M_x/M_o$ vs time",xlabel="time",ylabel="$M_x/M_o$")
self.axes1.plot(t[:1000], Mx[:1000], 'r', label="No Noise")
self.axes1.plot(t[:1000], MxPositive[:1000], 'b', label="Positive Noise")
self.axes1.plot(t[:1000], MxNegative[:1000], 'y', label="Negative Noise")
if self.legend[0] == 0:
self.axes1.legend()
self.legend[0] += 1
self.axes2 = self.ui.graphicsView2.figure.add_subplot(111,title="$M_y/M_o$ vs time",xlabel="time",ylabel="$M_y/M_o$")
self.axes2.plot(t[:1000], My[:1000], 'r', label="No Noise")
self.axes2.plot(t[:1000], MyPositive[:1000], 'b', label="Positive Noise")
self.axes2.plot(t[:1000], MyNegative[:1000], 'y', label="Negative Noise")
if self.legend[1] == 0:
self.axes2.legend()
self.legend[1] = 1
self.axes3 = self.ui.graphicsView3.figure.add_subplot(111,title="$M_{xy}$ in X-Y Plane",xlabel="$M_x/M_o$",ylabel="$M_y/M_o$")
self.axes3.plot(Mx, My, 'r', label="No Noise")
self.axes3.plot(MxPositive, MyPositive, 'b', label="Positive Noise")
self.axes3.plot(MxNegative, MyNegative, 'y', label="Negative Noise")
if self.legend[2] == 0:
self.axes3.legend()
self.legend[2] = 1
self.axes1.figure.canvas.draw()
self.axes2.figure.canvas.draw()
self.axes3.figure.canvas.draw()