def generateSolution(self):
"""
Generate a solution for the current cubestring and display in the GUI
"""
self.statusbar.showMessage("Generating Solution")
msg = "Generating solution for cubestring: " + self.cube.cubestring
self.addLogEntry(msg)
timer = QElapsedTimer()
timer.start()
solution = "No Solution"
try:
solution = kociemba.solve(self.cube.cubestring)
except Exception as err:
print(err)
error_dialog = QErrorMessage()
error_dialog.showMessage(err.args[0])
error_dialog.exec_()
solution = err.args[0]
self.statusbar.showMessage("Solution generation failed!")
msg = "Solution could not be calculated: " + solution
self.addLogEntry(msg)
self.lineEdit_InOut.setText(solution)
self.label_CurrentString.setText("Solution:")
self.statusbar.showMessage("Generated Solution")
msg = "Solution calculation took: {} ms".format(timer.nsecsElapsed() /
1000000)
self.addLogEntry(msg)
# self.timer1ms.stop()
pass
class Window(QMainWindow):
''' docstring '''
def __init__(self):
super().__init__()
self.conn_status = False
self.query_status = False
self.sckt = None
self.new_tcp_host = "192.168.43.67" #TCP_HOST_IP
self.init_ui()
self.q_p1_x = 116.30
self.q_p1_y = 39.97
self.q_p2_x = 116.32
self.q_p2_y = 40.00
self.query_elapsed = None
self.proc_elapsed = 0
self.timer = QElapsedTimer()
def init_ui(self):
''' docstring '''
#self.com = Communicate()
# self.com.close_app.connect(self.close)
self.custom_wid = MainWidget(self)
self.custom_wid.control_wid.connect_btn.clicked.connect(
self.connect_server)
self.custom_wid.control_wid.open_btn.clicked.connect(self.open_file)
self.custom_wid.control_wid.close_btn.clicked.connect(self.close_app)
self.custom_wid.control_wid.plot_btn.clicked.connect(self.load_data)
self.custom_wid.control_wid.query_btn.clicked.connect(
self.query_region)
self.setCentralWidget(self.custom_wid)
self.statusBar()
self.statusBar().showMessage('Ready')
self.resize(1280, 720)
self.center()
self.setWindowTitle('Trajectory Mapping - Client App')
self.show()
def center(self):
''' docstring '''
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def connect_server(self):
''' docstring '''
self.new_tcp_host, ok = QInputDialog.getText(
self, 'Connect to Server', 'Enter server IP address:',
QLineEdit.Normal, str(self.new_tcp_host))
if ok:
# close existing socket
try:
self.sckt.close()
except:
pass
# create a socket object
self.sckt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# connection to hostname on the port.
print(self.new_tcp_host)
try:
self.sckt.connect((self.new_tcp_host, TCP_PORT))
except:
return
self.conn_status = True
# send message to server
msg_to_send = 'Houssem & Ayoub'
self.sckt.send(msg_to_send.encode('utf-8'))
# Receive no more than BUFFER_SIZE bytes
msg = self.sckt.recv(BUFFER_SIZE)
# print received reply
print(msg.decode('utf-8'))
self.statusBar().showMessage(msg.decode('utf-8'))
def open_file(self):
''' docstring '''
self.timer.restart()
if self.conn_status:
fname = QFileDialog.getOpenFileName(self, 'Open file', '/home')
if fname[0]:
fsize = os.path.getsize(fname[0])
self.sckt.send(str(fsize).encode('utf-8'))
with open(fname[0], 'rb') as f:
data_buffer = f.read(BUFFER_SIZE)
while data_buffer:
self.sckt.send(data_buffer)
data_buffer = f.read(BUFFER_SIZE)
print('File opened and sent to server')
self.statusBar().showMessage('File opened and sent to server')
self.receive_files()
else:
self.statusBar().showMessage('First connect to server')
def close_app(self):
''' docstring '''
if self.conn_status:
self.sckt.close()
QApplication.instance().quit()
def receive_files(self):
''' docstring'''
with open(ORIGINAL_DATASET_FILE, 'wb') as f:
print('Receiving data ...')
msg = self.sckt.recv(BUFFER_SIZE)
fsize = int(msg.decode('utf-8'))
rsize = 0
while True:
data = self.sckt.recv(BUFFER_SIZE)
#print('Received data = %s', (data))
rsize = rsize + len(data)
f.write(data)
#print(rsize)
if rsize >= fsize:
print('Breaking from file write')
break
with open(REDUCED_DATASET_FILE, 'wb') as f:
print('Receiving data ...')
msg = self.sckt.recv(BUFFER_SIZE)
fsize = int(msg.decode('utf-8'))
rsize = 0
while True:
data = self.sckt.recv(BUFFER_SIZE)
#print('Received data = %s', (data))
rsize = rsize + len(data)
f.write(data)
#print(rsize)
if rsize >= fsize:
print('Breaking from file write')
break
self.statusBar().showMessage('Files received from server')
self.proc_elapsed = self.timer.nsecsElapsed()
print(self.timer.clockType())
print(self.proc_elapsed)
self.custom_wid.control_wid.label_7.setText(
"Processing time: {}".format(self.proc_elapsed))
def load_data(self):
''' docstring'''
full_ds = 0
reduced_ds = 0
reduction_rate = 0
query_full_ratio = 0
query_reduced_ratio = 0
lines_buffer = []
original_dataset = []
with open(ORIGINAL_DATASET_FILE, 'r') as f:
lines_buffer = f.readlines()
full_ds = len(lines_buffer)
#print(lines_buffer)
for line in lines_buffer:
tmp = line.split(',')
tmp[0] = float(tmp[0])
tmp[1] = float(tmp[1])
original_dataset.append(tmp)
#print(original_dataset)
lines_buffer = []
reduced_dataset = []
with open(REDUCED_DATASET_FILE, 'r') as f:
lines_buffer = f.readlines()
reduced_ds = len(lines_buffer)
#print(lines_buffer)
for line in lines_buffer:
tmp = line.split(',')
tmp[0] = float(tmp[0])
tmp[1] = float(tmp[1])
reduced_dataset.append(tmp)
#print(reduced_dataset)
reduction_rate = 100 * (1 - reduced_ds / full_ds)
self.custom_wid.control_wid.label_1.setText(
"Full dataset: {}".format(full_ds))
self.custom_wid.control_wid.label_2.setText(
"Reduced dataset: {}".format(reduced_ds))
self.custom_wid.control_wid.label_3.setText(
"Reduction rate: {} %".format(round(reduction_rate, 2)))
query_original_dataset = []
query_reduced_dataset = []
if self.query_status:
lines_buffer = []
with open(QUERY_ORIGINAL_DATASET_FILE, 'r') as f:
lines_buffer = f.readlines()
query_full_ratio = 100 * len(lines_buffer) / full_ds
#print(lines_buffer)
for line in lines_buffer:
tmp = line.split(',')
tmp[0] = float(tmp[0])
tmp[1] = float(tmp[1])
query_original_dataset.append(tmp)
lines_buffer = []
with open(QUERY_REDUCED_DATASET_FILE, 'r') as f:
lines_buffer = f.readlines()
query_reduced_ratio = 100 * len(lines_buffer) / reduced_ds
#print(lines_buffer)
for line in lines_buffer:
tmp = line.split(',')
tmp[0] = float(tmp[0])
tmp[1] = float(tmp[1])
query_reduced_dataset.append(tmp)
else:
self.custom_wid.control_wid.coord1_x.setValue(
reduced_dataset[0][0])
self.custom_wid.control_wid.coord1_y.setValue(
reduced_dataset[0][1])
self.custom_wid.control_wid.coord2_x.setValue(
reduced_dataset[-1][0])
self.custom_wid.control_wid.coord2_y.setValue(
reduced_dataset[-1][1])
self.custom_wid.control_wid.label_4.setText(
"Results ratio to full dataset: {} %".format(
round(query_full_ratio)))
self.custom_wid.control_wid.label_5.setText(
"Results ratio to reduced dataset: {} %".format(
round(query_reduced_ratio)))
xy = np.array(reduced_dataset)
q_xy = np.array([])
tmp = self.custom_wid.control_wid.combo_box.currentText()
if tmp == "Full Dataset":
xy = np.array(original_dataset)
q_xy = np.array(query_original_dataset)
elif tmp == "Reduced Dataset":
xy = np.array(reduced_dataset)
q_xy = np.array(query_reduced_dataset)
# Plot the path as red dots connected by a blue line
plt.hold(True)
if self.query_status:
fig = plt.figure()
ax = fig.add_subplot(111)
rect = mpatches.Rectangle(
[min(self.q_p1_x, self.q_p2_x),
min(self.q_p1_y, self.q_p2_y)],
abs(self.q_p1_x - self.q_p2_x), abs(self.q_p1_y - self.q_p2_y))
ax.add_patch(rect)
#plt.plot()
plt.plot(xy[:, 0], xy[:, 1], 'ko')
if self.query_status and len(q_xy):
plt.plot(q_xy[:, 0], q_xy[:, 1], 'rD')
plt.plot(xy[:, 0], xy[:, 1], 'b')
root, ext = os.path.splitext(__file__)
mapfile = root + '.html'
print("mapfile: {}".format(mapfile))
# Create the map. Save the file to basic_plot.html. _map.html is the default
# if 'path' is not specified
mplleaflet.show(inbrowser=False, path=mapfile)
self.custom_wid.map_wid.setUrl(
QUrl.fromLocalFile(QFileInfo(mapfile).absoluteFilePath()))
def query_region(self):
''' docstring '''
self.timer.restart()
print('Sending query ...')
self.q_p1_x = self.custom_wid.control_wid.coord1_x.value()
self.q_p1_y = self.custom_wid.control_wid.coord1_y.value()
self.q_p2_x = self.custom_wid.control_wid.coord2_x.value()
self.q_p2_y = self.custom_wid.control_wid.coord2_y.value()
msg_to_send = '{},{},{},{}'.format(self.q_p1_x, self.q_p1_y,
self.q_p2_x, self.q_p2_y)
self.sckt.send(msg_to_send.encode('utf-8'))
print('Query sent ...')
with open(QUERY_ORIGINAL_DATASET_FILE, 'wb') as f:
print('Receiving query data ...')
msg = self.sckt.recv(BUFFER_SIZE)
fsize = int(msg.decode('utf-8'))
rsize = 0
if fsize:
while True:
data = self.sckt.recv(BUFFER_SIZE)
#print('Received data = %s', (data))
rsize = rsize + len(data)
f.write(data)
#print(rsize)
if rsize >= fsize:
print('Breaking from query file write')
break
with open(QUERY_REDUCED_DATASET_FILE, 'wb') as f:
print('Receiving query data ...')
msg = self.sckt.recv(BUFFER_SIZE)
fsize = int(msg.decode('utf-8'))
rsize = 0
if fsize:
while True:
data = self.sckt.recv(BUFFER_SIZE)
#print('Received data = %s', (data))
rsize = rsize + len(data)
f.write(data)
#print(rsize)
if rsize >= fsize:
print('Breaking from query file write')
break
self.query_status = True
self.query_elapsed = self.timer.nsecsElapsed()
print(self.timer.clockType())
print(self.query_elapsed)
self.custom_wid.control_wid.label_6.setText("Query time: {}".format(
self.query_elapsed))
for i in range(0, len(avg_colors[face])):
current_color = avg_colors[face][i]
if i == 4:
identifier = face[0]
else:
identifier = get_identifier(current_color, center_colors)
cubestring += identifier
# for
#compare averages to center color
return cubestring
#when executed directly as means to benchmark
if __name__ == "__main__":
f = open("imageBenchmark.txt", "w")
overall = 0
for i in range(0, 1000):
timer = QElapsedTimer()
timer.start()
cubestring = analyzeCubeImages(bDebug=0)
end = timer.nsecsElapsed()
f.write("{}\n".format(end))
print(end)
overall += end
f.close()
# print("; "+cubestring)
# print(overall//20)
from time import sleep
from PyQt5.QtCore import QTimer, QElapsedTimer
from PyQt5.QtWidgets import QApplication
from pyprone.entities.midifile import PrMidiFile
from pyprone.entities.midifile.track import PrMidiTrack
from pyprone.core.helpers.formats import sec2HMSF, tick2MBT, MBT2tick, tempo2bpm
from mido import open_output
etimer = QElapsedTimer()
etimer.start()
print('abc')
print(etimer.nsecsElapsed())
etimer.start()
a = 100 + 234
print(etimer.nsecsElapsed())
etimer.start()
a = 123123123 * 1000000000
print(etimer.nsecsElapsed())
etimer.start()
a = 123123123 / 10002323000000
print(etimer.nsecsElapsed())
