def __init__(self, host, user, password="", database="zbd_project"):
"""Initialize database object"""
# Initialize logger
self.logger = Logger(__name__, loggingLevel="debug")
self.logger.debug("Database logger has started.")
self.connection = None
# Initialize database connection
try:
self.logger.debug("Trying to attempt connection with database.")
self.connection = pymysql.connect(host=host, user=user, passwd=password, database=database)
except Exception as e:
self.logger.critical(f"Could not connect to database! Error = {e}")
raise ConnectionRefusedError(f"Could not connect to database! Error = {e}")
self.logger.info("Database connection is stable.")
self.config = dict()
try:
with open("config.json") as f:
self.config = {**self.config, **json.load(f)}
except IOError as e:
self.logger.error(f"Error occured while reading config from .json file!. Error = {e}")
exit(-1)
self.logger.debug("Config has been read.")
# Initialize global cursor
self.logger.debug("Creating global cursor.")
self.cursor = self.connection.cursor()
self.logger.debug("Global cursor created.")
def fill_blanks(self, fill):
response = copy.deepcopy(self.template)
for i in range(len(self.dependent_nodes)):
to_insert = ""
Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i])
print(self.relation[i])
if self.dependent_nodes[i] is not None:
curr_index = response.index(self.dependent_nodes[i])
if self.blanks[i] == 'Object' or self.blanks[i] == 'Character':
to_insert = self.relations_blanks[0][i].name
Logger.log_dialogue_model_basic(
str(self.relations_blanks[0][i].name))
elif self.blanks[i] == 'IsA':
to_insert = self.relations_blanks[0][i].first
Logger.log_dialogue_model_basic(
str(self.relations_blanks[0][i].first))
# <2 UsedFor 3>
elif int(self.relation[i][0]) < int(self.relation[i][2]):
to_insert = self.relations_blanks[0][i].second
Logger.log_dialogue_model_basic(
str(self.relations_blanks[0][i].second))
# <3 CreatedBy 2>
else:
to_insert = self.relations_blanks[0][i].first
Logger.log_dialogue_model_basic(
str(self.relations_blanks[0][i].first))
response[curr_index] = to_insert
return response
def create_connection():
host = config.get_config("database-settings", "host")
if host is False or host is None:
logger = Logger.get_instance()
logger.err("Value \"host\" must not be None")
return False
user = config.get_config("database-settings", "user")
if user is False or user is None:
logger = Logger.get_instance()
logger.err("Value \"user\" must not be None")
return False
password = config.get_config("database-settings", "password")
if password is False:
logger = Logger.get_instance()
logger.err("Value \"password\" has not been declared in file.config")
return False
database = config.get_config("database-settings", "database")
if database is False or database is None:
logger = Logger.get_instance()
logger.err("Value \"database\" must not be None")
return False
return DBConnection(host, user, password, database)
def fill_blanks(self, dialogue_history):
print("KA STUFF")
# for x in range(len(dialogue_history)):
# print(dialogue_history[x].dialogue_type)
response = self.template
if len(dialogue_history) < 3:
return None
else:
print(dialogue_history[len(dialogue_history) - 3].dialogue_type)
suggestion_blanks = dialogue_history[len(dialogue_history) -
3].word_relation
subject = ""
for x in range(len(suggestion_blanks)):
print(suggestion_blanks[x])
if suggestion_blanks[x].second_token == "character":
if self.blanks[0] == 'Character':
subject = suggestion_blanks[x].first_token
elif suggestion_blanks[x].second_token == "object":
if self.blanks[0] == 'Object':
subject = suggestion_blanks[x].first_token
Logger.log_dialogue_model_basic("Subject: " + subject)
response = [x.replace("1", subject) for x in response]
return response
def __init__(self, argv):
QtGui.QMainWindow.__init__(self)
self.MainWindow = Ui_MainWindow
self.ui = Ui_MainWindow
self.MainWindow.__init__(self.window)
self.setupUi(self)
self.show()
self.logger = Logger(self.logPanel)
self.device = EthernetDevice(self.logger)
self.device.disconState = QtGui.QPixmap(
_fromUtf8('../res/disconnected'))
self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
self.device.currentState = 0
self.device.power = 0
self.device.direction = 0
self.addWidgets()
self.updater = DataUpdateThread(self) # create a thread
self.updater.trigger.connect(
self.updateState) # connect to it's signal
self.updater.start()
self.cam = Camera(self)
def __init__(self, agent, temp_it=CFG.temp_thresh + 1, player_name=None):
self.agent = agent
self.game = self.agent.game
self.logger = Logger()
self.temp_it = temp_it
self.player_name = player_name
self.tree = State(None, 1, self.game(), prior=1.0)
def listen(self):
try:
self.listeningSocket.bind(("127.0.0.1", 0))
except socket.error as msg:
Logger.error('[GAME] Bind failed. Error : ' + str(sys.exc_info()))
return (False)
self.listeningSocket.listen(1)
def __init__(self, auction_id, test=False):
self.auction_id = auction_id
self.highest_bid = 0
self.highest_bidder = None
self.bid_time = 0
self.no_bids = 0
self.test = test # suppress logging in tests
self.log = Logger(id=auction_id, test=self.test)
self.log.init_logfile()
def run(self):
self.socket.connect((self.serverIp, self.serverPort))
self.connected = True
recvData = self.socket.recv(4096)
while recvData:
self.parser.feed(recvData)
if self.processPackets() == False:
return (False)
recvData = self.socket.recv(4096)
self.connected = False
Logger.info("[GAME] Server disconnected")
def run(self):
self.socket.connect(("34.251.172.139", 443))
self.connected = True
recvData = self.socket.recv(4096)
while recvData:
self.parser.feed(recvData)
if self.processPackets() == False:
return (False)
recvData = self.socket.recv(4096)
self.connected = False
Logger.info("[REALM] Server disconnected")
def run(self):
self.connected = True
self.remoteServer = RealmRemoteClient(self)
self.remoteServer.start()
recvData = self.fd.recv(4096)
while recvData:
self.parser.feed(recvData)
if self.processPackets() == False:
return (False)
recvData = self.fd.recv(4096)
self.connected = False
Logger.info("[REALM] Client " + self.ip + ":" + self.port + " disconnected")
def processPackets(self):
newPacket = self.parser.getPacket()
while newPacket:
Logger.debug("[GAME] << " + newPacket)
DatabaseManager().addPacket(0, newPacket)
data = bytearray(newPacket.encode("utf-8"))
data += b'\x00'
if self.localClient.send(data) == False:
self.socket.close()
Logger.info("[GAME] Server disconnected")
return (False)
newPacket = self.parser.getPacket()
return (True)
def fill_blanks(self, fill):
dBOConceptGlobalImpl = DBOConceptGlobalImpl()
rand_concept = dBOConceptGlobalImpl.get_random_concept()
response = copy.deepcopy(self.template)
for i in range(len(self.nodes)):
to_insert = rand_concept.first
Logger.log_dialogue_model_basic(str(to_insert))
curr_index = response.index(self.nodes[i])
response[curr_index] = to_insert
return response
def processPackets(self):
newPacket = self.parser.getPacket()
while newPacket:
Logger.debug("[REALM] >> " + newPacket)
DatabaseManager().addPacket(1, newPacket)
data = bytearray(newPacket.encode("utf-8"))
data += b'\x00'
if self.remoteServer.send(data) == False:
self.fd.close()
Logger.info("[REALM] Client " + self.ip + ":" + self.port + " disconnected")
return (False)
newPacket = self.parser.getPacket()
return (True)
def fill_blanks(self, event):
print(self.full_string())
# response = self.template
# response = DialogueTemplateBuilder.build(*self)
response = copy.deepcopy(self.template)
for i in range(len(self.nodes)):
to_insert = ""
curr_index = response.index(self.nodes[i])
Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i])
if self.blanks[i] == 'Repeat':
to_insert = self.check_subject(event.subject.name) + " "
# to_insert = event.subject.name + " "
if event.get_type() == EVENT_ACTION:
to_insert = to_insert + str(event.verb)
Logger.log_dialogue_model_basic(
str(to_insert + str(event.verb)))
elif event.get_type() == EVENT_CREATION:
to_insert = event.subject.name
Logger.log_dialogue_model_basic(str(event.subject.name))
elif event.get_type() == EVENT_DESCRIPTION:
#Iterate through attributes
for X in event.attributes:
to_insert = to_insert + X.keyword + " " + str(
X.description.lemma_)
Logger.log_dialogue_model_basic(
str(to_insert + X.keyword + " " +
str(X.description.lemma_)))
response[curr_index] = to_insert
return response
def takeoff(self):
try:
print("takeoff")
self.toggleButtonEnabled()
self.drone.takeoff()
except:
print('Not connected to a drone')
return
if self.drone.navdata:
self.toggleButtonEnabled()
self.logger = Logger()
self.begin_log()
print("taking off")
def run(self):
Logger.info("[DB] Starting the database...")
self.db = sqlite3.connect('data.db')
self.createDb()
Logger.info("[DB] Waiting for data")
while True:
with self.condition:
self.condition.wait()
cursor = self.db.cursor()
while self.tasks.empty() == False:
task = self.tasks.get()
cursor.execute(
"INSERT INTO packets(direction, packet, date) VALUES(?, ?, ?);",
(task[0], task[1], datetime.datetime.now()))
self.db.commit()
def __init__(self):
super().__init__()
self.title = 'GameOfDrones Test GUI'
self.left = 100
self.top = 100
self.width = 1024
self.height = 768
self.initUI()
self.logger = Logger()
self.drone = ARDrone(connect=True)
self.drone.send(at.CONFIG('general:navdata_demo', True))
font = QFont()
font.setBold(True)
font.setPixelSize(18)
self.setFont(font)
def __init__(self, argv):
QtGui.QMainWindow.__init__(self)
self.MainWindow=Ui_MainWindow
self.ui=Ui_MainWindow
self.MainWindow.__init__(self.window)
self.setupUi(self)
self.show()
self.logger = Logger(self.logPanel)
self.device = EthernetDevice(self.logger)
self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected'))
self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
self.device.currentState = 0
self.device.power=0
self.device.direction=0
self.addWidgets()
self.updater = DataUpdateThread(self) # create a thread
self.updater.trigger.connect(self.updateState) # connect to it's signal
self.updater.start()
self.cam = Camera(self)
class FunctionController:
def __init__(self, rootWindow, database, backEvent, year):
self.rootWindow = rootWindow
self.backEvent = backEvent
self.database = database
self.year = year
# Start logger
self.logger = Logger(__name__, loggingLevel="debug")
self.logger.debug("FunctionController logger has started.")
self.functionWindow = Toplevel(self.rootWindow)
self.functionWindow.title("Check a book.")
self.functionWindow.protocol('WM_DELETE_WINDOW', self.goBack)
self.functionWindow.bind("<<back>>", lambda _: self.backEvent())
self.data = self.database.findBestBook(self.year)
values = self.database.executeStatement(
f"SELECT * FROM `ksiazki` WHERE `tytul` = '{self.data[0][0][0]}'")
self.finalData = dict()
self.finalData["Title"] = values[0][1]
self.finalData["Date"] = str(values[0][2])
self.finalData["Genre"] = values[0][3]
self.finalData["Amount"] = self.data[1][0][0]
self.mainFrame = Frame(self.functionWindow,
bd=4,
relief=RAISED,
width=self.functionWindow.winfo_width(),
height=self.functionWindow.winfo_height())
self.mainFrame.pack(fill='both', side=TOP)
titleLabel = Label(self.mainFrame,
text=f"Most hired book in year {year} is..",
font=("Arial Bold", 18))
titleLabel.grid(row=0, column=0, columnspan=3, padx=40, pady=20)
rowNo = 1
for no, val in self.finalData.items():
l1 = Label(self.mainFrame,
text=f"{no}: {val}",
font=("Arial Bold", 14))
l1.grid(row=rowNo, column=0, columnspan=3, padx=10, pady=10)
rowNo += 1
def goBack(self):
self.functionWindow.event_generate("<<back>>")
def get_config(setting_name, key_name):
with open(config_file, "r") as file:
text = file.read()
pattern = re.compile("\"" + setting_name + "\":\s*\{\s*([\n \"a-zA-Z0-9.:_-]*)\s*\}")
settings = pattern.finditer(text)
for e in settings:
settings = e.group(1).replace("\t", "").replace(" ", "").split("\n")
settings = list(filter(None, settings))
# returns False if "settings_name" was not found
if settings == []:
logger = Logger.get_instance()
logger.err("Could not find \"" + setting_name + "\" in file .config")
return False
# transform settings into dictionary
settings_dict = {}
for e in settings:
# key
pattern = re.compile("\"([^.*\"]*)\":")
key = pattern.finditer(e)
for i in key:
key = i.group(1)
# value
pattern = re.compile("\:\s*\"([^.*\"]*)\"")
value = pattern.finditer(e)
for i in value:
value = i.group(1)
settings_dict.update({key: value})
# returns False if "key_name" was not found
if settings_dict.__contains__(key_name) == False:
logger = Logger.get_instance()
logger.err("Could not find \"" + key_name + "\" in object \"" + setting_name + "\" in file .config")
return False
return settings_dict[key_name]
def parsePacket(self, packet):
if len(packet) > 3 and packet[0] == 'A' and packet[
1] == 'X' and packet[2] == 'K':
Logger.debug("[REALM] onSelectServer packet detected!")
encryptedIp = packet[3:11]
encryptedPort = packet[11:14]
ticket = packet[14:]
decryptedIp = CipherManager.decryptIp(encryptedIp)
decryptedPort = CipherManager.decryptPort(encryptedPort)
newGameClient = GameLocalClient(decryptedIp, decryptedPort)
newGameClient.listen()
newEncryptedIp = CipherManager.encryptIp(
newGameClient.getListeningIp())
newEncryptedPort = CipherManager.encryptPort(
newGameClient.getListeningPort())
newPacket = "AXK" + newEncryptedIp + newEncryptedPort + ticket
Logger.debug("[REALM] Replacing packet '" + packet +
"' with packet '" + newPacket + "'")
newGameClient.start()
return (newPacket)
return (packet)
def __init__(self, configPath, width=640, height=480):
# Initialize logger
self.logger = Logger(__name__, loggingLevel="debug")
self.logger.debug(
"==================================================================="
)
self.logger.debug("Application logger has started.")
self.config = dict()
try:
with open(configPath) as f:
self.config = {**self.config, **json.load(f)}
except IOError as e:
self.logger.error(
f"Error occured while reading config from .json file!. Error = {e}"
)
exit(-1)
self.logger.debug("Config has been read.")
# Initialize app window
self.logger.debug("Initializing application window.")
self.window = Tk()
self.window.title("Database Application.")
self.logger.debug("Application window has been initialized.")
self.window.geometry(f"{int(width)}x{int(height)}+0+0")
self.window.resizable(0, 0)
self.window.attributes("-topmost", True)
# Setting a theme picture
self.theme = Canvas(width=width, height=height, bg='black')
self.theme.grid(column=0, row=0)
self.imagesDict = dict()
self.imagesDict["themeC"] = PhotoImage(file="theme.gif")
self.imagesDict["themeG"] = PhotoImage(file="grayscale_theme.gif")
self.logger.debug("Images has been loaded.")
self.imageOnCanvas = self.theme.create_image(
0, 0, image=self.imagesDict["themeG"], anchor=NW)
self.logger.debug("Setting grayscale theme.")
def fill_blanks(self, event):
response = self.template
for i in range(len(self.nodes)):
to_insert = ""
curr_index = response.index(self.nodes[i])
Logger.log_dialogue_model_basic("Current Blank: " + self.blanks[i])
if self.blanks[i] == 'Character':
to_insert = self.check_subject(
event.get_characters_involved()[0].name)
# if event.get_characters_involved()[0].name.lower() == 'i':
# to_insert = 'you'
# else:
# to_insert = event.get_characters_involved()[0].name
elif self.blanks[i] == 'Object' or self.blanks[i] == 'Item':
to_insert = event.get_objects_involved()[0].name
Logger.log_dialogue_model_basic(
str(event.get_objects_involved()[0].name))
elif self.blanks[i] == 'Event':
to_insert = self.check_subject(event.subject.name) + " " + str(
event.verb.lemma_)
# to_insert = event.subject.name + " " + str(event.verb.lemma_)
elif self.blanks[i] == 'Repeat':
to_insert = self.check_subject(event.subject.name) + " "
# to_insert = event.subject.name + " "
if event.get_type() == EVENT_ACTION:
to_insert = to_insert + str(event.verb)
elif event.get_type() == EVENT_CREATION:
to_insert = event.subject.name
elif event.get_type() == EVENT_DESCRIPTION:
#Iterate through attributes
for X in event.attributes:
to_insert = to_insert + X.keyword + " " + str(
X.description.lemma_)
response[curr_index] = to_insert
return response
def setup(self):
self.log = Logger('./%s.log')
# import the two players
from src.Players.Dave2Player import Dave2Player
from src.Players.Dave2Player_old import Dave2Player_old
self.bot1 = Dave2Player() # your player!
self.bot2 = Dave2Player_old()
test_map = 'M 1 0 0 0\n'\
+ 'P 10 10 1 1 119 4\n'\
+ 'P 10 20 2 0 100 5\n'\
+ 'P 20 10 3 0 100 5\n'\
+ 'P 20 20 4 2 119 4\n'
self.pw = PlanetWars(test_map, logger=self.log.turn)
def __init__(self, host, user, password, database):
self.logger = Logger.get_instance()
try:
self.connection = mysql.connector.connect(
host=host,
user=user,
password=password,
database=database,
)
self.cursor = self.connection.cursor()
self.logger.log('connection to database established')
except:
self.logger.err('failed to establish a connection to the database')
exit(2)
def flow_handler(args):
if len(args) == 1:
print("1 positional argument missing!")
print("\tuse_captured_video: detection on captured video\n\tuse_onboard_camera: detection on real-time video "
"from tx2 camera\n\tuse_local_rtsp: detection on captured video with rtsp server")
return
father_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
log = Logger(father_dir + '/results/log/smart_parking.log', 'info')
if args[1] == 'use_captured_video' or args[1] == 'use_onboard_camera' or args[1] == 'use_local_rtsp':
detection_pipeline(log, args=args)
else:
print("\tuse_captured_video: detection on captured video\n\tuse_onboard_camera: detection on real-time video "
"from tx2 camera\n\tuse_local_rtsp: detection on captured video with rtsp server")
return
def get_rel_list(self, init_list, relation):
# TODO: Randomizer should not be here
temp_list = []
for X in init_list:
if len(X) > int(relation[0]) - 1:
print("X len is: ", len(X))
curr_refer = X[int(relation[0]) - 1]
# idk if dapat may randomizer dito
# curr_refer = np.random.choice(curr_refer_list)
if type(curr_refer) == Character or type(curr_refer) == Object:
print("testing: ", curr_refer.name)
temp_list.append(
self.dbo_concept.get_concept_by_first_relation(
curr_refer.name, relation[1]))
else:
print("testing: ", curr_refer.first)
temp_list.append(
self.dbo_concept.get_concept_by_first_relation(
curr_refer.first, relation[1]))
else:
for items in range(len(X)):
if isinstance(X[items], LocalConcept):
curr_refer = X[items]
print("testing: ", curr_refer.second)
temp_list.append(
self.dbo_concept.get_concept_by_second_relation(
curr_refer.second, relation[1]))
Logger.log_dialogue_model_basic_example(
"List of all Valid Relations: ")
if (len(temp_list)) > 0:
for x in range(len(temp_list[0])):
Logger.log_dialogue_model_basic_example(str(temp_list[0][x]))
updated_list = []
if (len(temp_list)) > 0:
if (len(temp_list[0])) > 0:
updated_list.append(np.random.choice(temp_list[0]))
Logger.log_dialogue_model_basic_example("Chosen Relation: ")
Logger.log_dialogue_model_basic_example(str(updated_list[0]))
return updated_list
def get_backup_files_list():
with open(config_file, "r") as file:
config_text = file.read()
match = __get_contents__("match", config_text)
include = __get_contents__("include", config_text)
exclude = __get_contents__("exclude", config_text)
# returns False if no files were found
if match == [] and include == []:
logger = Logger.get_instance()
logger.err("Could not find any files to back-up in file .config\nPlease include the object \"include\" or \"match\" in file .config")
return False
# gets a list of all the files which require a back-up
files_path = "files"
files = [f for f in listdir(files_path) if isfile(join(files_path, f))]
files_to_backup = []
# match
for e in match:
for file in files:
if file.__contains__(e):
files_to_backup.append(file)
# include
for e in include:
for file in files:
if file == e:
files_to_backup.append(e)
files_to_backup = list(dict.fromkeys(files_to_backup))
# exclude
for e in exclude:
for file in files:
if file == e:
files_to_backup.remove(e)
files_to_backup = [files_path + "/" + f for f in files_to_backup]
return files_to_backup
def start(self):
try:
self.socket.bind(("127.0.0.1", 12345))
except socket.error as msg:
Logger.error('[REALM] Bind failed. Error : ' + str(sys.exc_info()))
return (False)
self.socket.listen(16)
Logger.info("[REALM] Listening on port 12345...")
while True:
fd, addr = self.socket.accept()
ip, port = str(addr[0]), str(addr[1])
Logger.info('[REALM] New incomming connection: ' + ip + ':' + port)
newClient = RealmLocalClient(fd, addr, ip, port)
newClient.start()
self.socket.close()
def run(self):
Logger.info("[GAME] Listening on " + self.getListeningIp() + ":" +
str(self.getListeningPort()) + "...")
self.fd, self.addr = self.listeningSocket.accept()
self.ip, self.port = str(self.addr[0]), str(self.addr[1])
Logger.info('[GAME] New incomming connection: ' + self.ip + ':' +
self.port)
self.listeningSocket.close()
self.connected = True
self.remoteServer = GameRemoteClient(self, self.serverIp,
self.serverPort)
self.remoteServer.start()
recvData = self.fd.recv(4096)
while recvData:
self.parser.feed(recvData)
if self.processPackets() == False:
return (False)
recvData = self.fd.recv(4096)
self.connected = False
Logger.info("[GAME] Client " + self.ip + ":" + self.port +
" disconnected")
class ControlApp(QtGui.QMainWindow, Ui_MainWindow):
#def values
camDirectionAngle=0
keylist = []
cam = None
updater = None
def __init__(self, argv):
QtGui.QMainWindow.__init__(self)
self.MainWindow=Ui_MainWindow
self.ui=Ui_MainWindow
self.MainWindow.__init__(self.window)
self.setupUi(self)
self.show()
self.logger = Logger(self.logPanel)
self.device = EthernetDevice(self.logger)
self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected'))
self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
self.device.currentState = 0
self.device.power=0
self.device.direction=0
self.addWidgets()
self.updater = DataUpdateThread(self) # create a thread
self.updater.trigger.connect(self.updateState) # connect to it's signal
self.updater.start()
self.cam = Camera(self)
def addWidgets(self):
""" В этом методе мы добавляем виджеты и wприсоединяем обработчики сигналов.
Обработчик сигнала для виджета так же называется "слотом"
"""
#camview setup
#path="C:\\Users\\SCB\\Downloads\\test.avi"
path=QtCore.QUrl("rtsp://192.168.2.100:7070/")
media = Phonon.MediaSource(path)
self.videoPlayer.load(media)
self.videoPlayer.play()
#set maps properties
url = "res.gmap.html"
page = QtCore.QUrl("../res/gmap.html")
self.mapView.load(page)
#thumper pic
myPixmap = QtGui.QPixmap(_fromUtf8('../res/thumper_top.jpg'))
self.thumperImage.setPixmap(myPixmap)
self.thumperImage.setScaledContents(True)
#camDirection
myPixmap = QtGui.QPixmap(_fromUtf8('../res/cam.png'))
myPixmap = myPixmap.transformed(QtGui.QTransform().rotate(self.camDirectionAngle))
self.camDirection.setPixmap(myPixmap)
self.camDirection.setScaledContents(True)
#logger
self.actionSaveLog.triggered.connect(self.saveLog)
self.actionSaveLog.setShortcut('Ctrl+S')
#define menu actions
self.actionExit.triggered.connect(self.exitApp)
self.actionExit.setShortcut('Ctrl+Q')
#device state
#self.connectStateIndicator.connect(self.connectStateIndicator, QtCore.SIGNAL("")
self.connectStateIndicator.setPixmap(self.device.disconState)
self.connectStateIndicator.setScaledContents(True)
self.actionConnect.triggered.connect(self.changeConnectionState)
self.actionConnect.setShortcut('F5')
self.resetTelemetry()
#get state
self.actionBattery.triggered.connect(self.addMarkerWithLabel)
#init direction level (altitude direction indicator)
#init battery state
#self.actionBattery.setShortcut('R')
def keyPressEvent(self, event):
if event.key() not in self.keylist:
self.keylist.append(event.key())
self.processmultikeys(self.keylist)
def keyReleaseEvent(self, event):
if event.key() in self.keylist:
if not event.isAutoRepeat():
self.keylist.remove(event.key())
self.processmultikeys(self.keylist)
def processmultikeys(self, keyspressed):
#TODO send eth control
print(self.keylist)
Key_G = QtCore.Qt.Key_G in self.keylist
Key_J = QtCore.Qt.Key_J in self.keylist
Key_Y = QtCore.Qt.Key_Y in self.keylist
Key_H = QtCore.Qt.Key_H in self.keylist
Key_Q = QtCore.Qt.Key_Q in self.keylist
Key_E = QtCore.Qt.Key_E in self.keylist
Key_R = QtCore.Qt.Key_R in self.keylist
Key_W = QtCore.Qt.Key_W in self.keylist
Key_S = QtCore.Qt.Key_S in self.keylist
self.device.power = 0 + Key_W - Key_S
Key_A = QtCore.Qt.Key_A in self.keylist
Key_D = QtCore.Qt.Key_D in self.keylist
Key_I = QtCore.Qt.Key_I in self.keylist
self.device.direction = 0 + Key_A - Key_D
Key_SPACE = QtCore.Qt.Key_Space in self.keylist
if(self.device.isConnected()):
self.device.movePD(1 + Key_W - Key_S, 1 + Key_A - Key_D)
print("ololololololo"+str(Key_W) +"|"+ str(QtCore.Qt.Key_W))
self.cam.zdirection = 0 + Key_Q - Key_E
self.cam.hdirection = 0 + Key_G - Key_J
self.cam.vdirection = 0 + Key_Y - Key_H
if(Key_I):
self.cam.moveReset();
else:
if(Key_R):
self.cam.home();
else:
self.cam.move();
def closeEvent(self, event):
# do stuff
self.updater.stop()
self.updater.wait()
self.device.destroy()
print("Goodby, World!")
sys.exit()
def exitApp(self):
self.updater.stop()
self.updater.wait()
self.device.destroy()
print("Goodby, World!")
sys.exit()
def saveLog(self):
self.logger.save()
def updateState(self):
BatteryState = self.device.getBatteryState()
self.leftBatteryState.setValue(int(BatteryState[0]))
self.rightBatteryState.setValue(int(BatteryState[1]))
self.obstacleLeftTop.setValue(10)
self.obstacleRightTop.setValue(10)
self.obstacleTop.setValue(10)
self.obstacleBottom.setValue(10)
#if BatteryState[0] <= 7000:
# self.logger.append("Low left battery level")
#if BatteryState[1] <= 7000:
# self.logger.append("Low right battery level")
def addMarkerWithLabel(self):
doc = self.mapView.page().mainFrame().documentElement()
#user = doc.findFirst("div[id=map_canvas]")
#user.evaluateJavaScript("panTo(new google.maps.LatLng(51.98646, 81.90669));")
def resetTelemetry(self):
self.obstacleLeftTop.setValue(0)
self.obstacleRightTop.setValue(0)
self.obstacleTop.setValue(0)
self.obstacleBottom.setValue(0)
def changeConnectionState(self):
if(self.device.isConnected()):
self.device.disconnect()
self.connectStateIndicator.setPixmap(self.device.disconState)
self.actionConnect.setText("Connect")
self.actionConnect.setShortcut('F5')
self.device.currentState = 0
self.resetTelemetry()
else:
if self.device.connect() == 0:
self.connectStateIndicator.setPixmap(self.device.conState)
self.actionConnect.setText("Disconnect")
self.actionConnect.setShortcut('Ctrl+D')