def main() -> None:
app = QtWidgets.QApplication(sys.argv)
app.setWindowIcon(QtGui.QIcon(resource_path("icon.ico")))
gui = MainWindow(Const.windowName)
gui.show()
app.exec_()
def __init__(self, addr, port):
self.addr = addr
self.port = port
self.sckt = socket(AF_INET, SOCK_STREAM)
self.queue = Queue()
self.added_queue = Queue()
self.sended_queue = Queue()
self.deleted_queue = Queue()
self.created_queue = Queue()
self.sended = False
self.main_window = MainWindow()
self.receive = Receive(self)
self.processing = Processing(self)
self.receive.mysignal_recv.connect(self.show,
QtCore.Qt.QueuedConnection)
self.processing.mysignal_invite.connect(self.send_agreement,
QtCore.Qt.QueuedConnection)
self.contact_model = QtGui.QStandardItemModel()
self.message_model = QtGui.QStandardItemModel()
# self.processing.mysignal_contact.connect(self.model_add, QtCore.Qt.QueuedConnection)
self.processing.mysignal_message.connect(self.message,
QtCore.Qt.QueuedConnection)
self.main_window.ui.pushButton_2.clicked.connect(self.add_contact)
self.main_window.ui.pushButton.clicked.connect(self.send_message)
self.contact = None
# self.processing.mysignal_history.connect(self.add_history, QtCore.Qt.QueuedConnection)
# self.message_list = []
# self.message_model.setStringList(self.message_list)
# self.send_mute = QtCore.QMutex
self.chat_model = QtGui.QStandardItemModel()
self.main_window.ui.listView_2.clicked.connect(self.select_contact)
self.main_window.ui.listView_2.customContextMenuRequested.connect(
self.context_menu)
self.delete_action = QtWidgets.QAction(self.main_window.tr('Удалить'),
self.main_window)
self.delete_action.triggered.connect(self.del_action)
self.create_chat_action = QtWidgets.QAction(
self.main_window.tr('Создать групповую беседу'), self.main_window)
self.create_chat_action.triggered.connect(self.create_chat)
self.main_window.ui.listView_3.setModel(self.chat_model)
self.main_window.ui.listView_3.setWordWrap(True)
self.main_window.ui.listView_3.customContextMenuRequested.connect(
self.second_context_menu)
self.invite_action = QtWidgets.QAction(
self.main_window.tr('Пригласить в чат'), self.main_window)
self.invite_action.triggered.connect(self.invite_chat)
self.leave_action = QtWidgets.QAction(
self.main_window.tr('Покинуть чат'), self.main_window)
self.leave_action.triggered.connect(self.leave_chat)
self.listik = NotMainWindow()
self.listik.ui.listView_2.setModel(self.contact_model)
# self.listik.setWindowModality(QtCore.Qt.ApplicationModal)
self.contact_for_invite = None
self.listik.ui.pushButton.clicked.connect(self.button_invite)
self.listik.hide()
self.chat_name = None
self.processing.mysignal_users.connect(self.add_chat)
self.main_window.ui.listView_3.clicked.connect(self.select_chat)
def main():
file = 'interface_setup.txt'
this_file = inspect.getfile(inspect.currentframe())
this_folder = os.path.dirname(os.path.abspath(this_file))
setup = setupFile()
data = readJson()
graphe = Graph()
setup.read(this_folder + os.sep + file)
setup._colorframe = '#4f81bd'
root.configure(bg=setup._colorframe)
MainWindow(root, setup, graphe)
root.mainloop()
logging.getLogger('zeroconf').setLevel(log_level)
def get_ip_address(logger=None):
try:
gw = netifaces.gateways()['default'][netifaces.AF_INET]
except KeyError:
gw = netifaces.gateways()[netifaces.AF_INET][0]
gw_ip = '.'.join(gw[0].split('.')[:3])
gw_iface = gw[1]
addrs = netifaces.ifaddresses(gw_iface)
addr = addrs[netifaces.AF_INET][0]
ip = addr['addr']
if logger is not None:
logger.info("ip: " + ip + " interface: " + gw_iface)
return ip, gw_iface
if __name__ == "__main__":
debug_mode = False
if len(sys.argv) > 1:
debug_mode = sys.argv[1:] == ['--debug']
setup_logging(debug_mode)
logger = logging.getLogger(__name__)
local_ip, interface = get_ip_address(logger)
main_window = MainWindow(ip=local_ip)
main_window.mainloop()
import sys
import cv2
from PyQt5.QtWidgets import QApplication
from GUI import MainWindow
bg_img = cv2.imread("bgPath")
videoFilePath = r"videoPath"
if __name__ == '__main__':
app = QApplication(sys.argv)
main_window = MainWindow(bg_img, videoFilePath)
main_window.show()
sys.exit(app.exec_())
def main():
app = QApplication([])
window = MainWindow()
window.show()
app.exec()
#raise NotImplementedError("gui isnt fonctionnal with session yet")
import qdarkstyle
from PyQt5 import QtGui
from PyQt5.QtWidgets import QApplication
from GUI import MainWindow
if "local" in args.session:
from core import Local_session as Session
else:
from core import Live_session as Session
app = QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
launch = MainWindow(
Session(mode=args.mode,
config=args.config,
contract_type='classic'))
launch.show()
sys.exit(app.exec_())
elif args.build:
from core import Local_session as Session
args.build = "PPO"
session = Session(mode=args.mode,
config=args.config,
contract_type='classic',
agent=args.build)
session._stop()
else:
if "local" in args.session:
import matplotlib.pyplot as plt
# Custom Libraries
from GUI import MainWindow
from servos import servofunctions
def switch(arg): #equivalent of switch case in python. dictionary look up/jump table
switcher = { "|sin|":servo.absolute,"sin^2":servo.squared,
"sin^4":servo.fourth,"sin^6":servo.sixth}
return switcher.get(arg,"invalid")
if __name__=='__main__':
servo = servofunctions() #creates object to control robot
func = servo.absolute #initializes breathing pattern
root = tk.Tk() #creates window for tkinter
Window = MainWindow(root) #creates object to control tkinter
# Main Loop
while(1):
if(Window.UpdateCheck==1): #runs if update or start/stop has been clicked in GUI (or if exiting)
if Window.running:
servo.A = Window.AMP #these all take GUI values and sends them to the pattern calculations in servo
servo.M = Window.OFF
servo.freq = Window.BPM
func = switch(Window.FUNC)
servo.reset() #resets the robot to the offset
Window.UpdateCheck = 0 #stops this branch from running multiple times without user input
else: #resets the robot to zero position when stopped or exiting
servo.M = 21 #21 duty cycle corresponds with 0 location
servo.reset()
from PyQt5 import QtWidgets as qtW
from GUI import MainWindow
import sys
if __name__ == '__main__':
try:
import qdarkstyle as qd
except ModuleNotFoundError:
qd = None
app = qtW.QApplication(sys.argv)
if qd is not None:
app.setStyleSheet(qd.load_stylesheet_pyqt5())
ex = MainWindow()
ex.show()
sys.exit(app.exec_())
from GUI import MainWindow
if __name__ == "__main__":
test = MainWindow()
test.mainloop()
from PyQt5.QtWidgets import QApplication
import sys
from GUI import MainWindow
if __name__ == '__main__':
app = QApplication([])
mw = MainWindow()
sys.exit(app.exec())
3D printer error detection application.
This is the main entry for the application.
This application is part of a bachelor thesis project
at NTNU Ålesund Department of ICT and Natural Sciences.
Developed and written by Tomas Paulsen.
RUN: On Raspberry pi set "useRPI" flag to True
On PC set "useRPI" flag to False
Run main.py to start
Usage: On Raspberry pi a physical button should be used to trigger gathering of images.
On PC a key button is used to trigger gathering of images.
Start camera page.
Apply mask.
Set HSV threshold values and morphological operations.
Apply Save Masked Images.
Start monitoring 3D print.
The application alert if error is detected.
"""
from GUI import MainWindow
from facade import Facade
useRPi = True
facade = Facade(useRPi=useRPi)
GUIApplication = MainWindow(facade=facade)
GUIApplication.start()
self.eData = self.eData[-self.length:]
if __name__=='__main__':
# Set up manager for sharing data between processes
BaseManager.register("servoData",ServoData)
m = BaseManager()
m.start()
sData = m.servoData(0)
#servo = Servos()
#evo = TeraRanger()
root = tk.Tk()
Window = MainWindow(root)
s = multiprocessing.Process(target = Servos, args = (sData,))
s.start()
g = multiprocessing.Process(target = Window.updatePlot, args = (sData,))
g.start()
#while(1):
# continue
#print(evo.data,evo.time)
#print(servo.data)
# Main Loop
while(1):
#if Window.UpdateCheck:
# if Window.running:
type=int,
help=
"Training or eval mode, default is training. Uselfull only without GUI displayed",
default=0,
choices=[0, 1])
args = parser.parse_args()
if args.GUI == 1:
import qdarkstyle
from PyQt5 import QtGui
from PyQt5.QtWidgets import QApplication
from GUI import MainWindow
app = QApplication(sys.argv)
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
launch = MainWindow()
launch.show()
sys.exit(app.exec_())
else:
from environnement import Environnement
from core import Local_Worker
env = Environnement(0)
if args.mode == 1:
env.mode = "eval"
else:
env.mode = "train"
worker = Local_Worker(env)
worker.run(env)
sys.exit(0)
#!/usr/bin/env python
# coding: utf-8
import sys
from PyQt5.QtWidgets import QApplication
from GUI import MainWindow
if __name__ == '__main__':
app = QApplication(sys.argv)
mainWin = MainWindow()
mainWin.resize(400, 300)
mainWin.setWindowTitle('Simple')
mainWin.show()
status = app.exec()
sys.exit(status)
