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 __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)
class ClipWiz:
def __init__(self):
#Set up DB
self.db = DB()
#Call keyboard manager
self.km = KM (self)
#Call GUI & set it up
self.gui = Ui_MainWindow(self)
self.gui.setup()
self.km.stop()
sys.exit()
def copy(self, content):
pyperclip.copy(content)
def getData(self):
return self.db.data
def insert_clip(self, content):
inserted = self.db.insert_clip(content)
if inserted:
self.gui.ins_data_in_table(inserted, False)
def search(self, text):
return self.db.search(text)
def reset(self):
self.db.reset()
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)
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 __init__(self, parent=None):
QMainWindow.__init__(self, parent)
Ui_MainWindow.__init__(self)
self.setupUi(self)
# canvas with graph
layout = QVBoxLayout(self.graphicsView)
layout.setContentsMargins(0, 0, 0, 0)
self.graphicsView.setLayout(layout)
# create plotHandler
self.plotHandler = PlotHandler(self)
layout.addWidget(self.plotHandler.get_widget())
self.changeButton.clicked.connect(self.update_plot)
self.generateButton.clicked.connect(self.generate_population)
# ToolBox with algorithms
QtCore.QObject.connect(self.chooseSearchToolBox,
QtCore.SIGNAL('currentChanged(int)'),
self,
QtCore.SLOT('algorithm_change_callback(int)')
)
# Run button
self.ButtonRun.clicked.connect(self.run_button_callback)
# Step Button
self.ButtonStep.clicked.connect(self.step_button_callback)
# Evolution algorithm important properties
self.algorithm = None
self.test_functions = None
self.fitness_function = None
self.actualPopulation = None
# Plot initialization
self.initialize_plot()
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 __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ip = ""
self.port = ""
self.link = "http://aargin.com/"
def __init__(self):
#Set up DB
self.db = DB()
#Call keyboard manager
self.km = KM (self)
#Call GUI & set it up
self.gui = Ui_MainWindow(self)
self.gui.setup()
self.km.stop()
sys.exit()
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)
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.importar.clicked.connect(self.getxls)
self.analizar.clicked.connect(self.plot1)
self.analizar.clicked.connect(self.reporte)
self.analizar.clicked.connect(self.progreso)
print("Morita 1.0")
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_()
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 __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)
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()
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 __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 __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
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)
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
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()
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()
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 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)))
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()
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)
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 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()
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)
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("кто это?")
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()
#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()
